java对象和类
- 面向对象
- 对象和类
- 属性
- 方法
- 静态
- 包
- 构建对象
面向对象
所谓的面向对象,其实就是分析问题时,以问题所涉及到的事或物为中心的分析方式。
比如在写小学作文里《美好的一天》,一种写法是记录几点起床,几点吃饭,几点睡觉,这种写法比较简单但拿不到高分;另一种写法是通过一件事或者一个人来阐述这一天发生了什么,比如今天放学妈妈给我送了雨伞这一件事,所以我认为是美好的一天。
对象和类
对象:对象是类的一个实例(对象不是找个女朋友),有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。
类:类是一个模板,它描述一类对象的行为和状态。
比如,男孩(boy)、女孩(girl)为类(class),而具体的每个人为该类的对象(object)。
在java中类的关键字是class,基本语法如下:
class 类名{
特征(属性),
功能(方法)
}
以做一道菜,红烧排骨为例:
那么类:菜,对象:红烧排骨
public class chapter01_Object {
public static void main(String[] args) {
Cooking c = new Cooking();
c.name = "红烧排骨";
c.food = "排骨";
c.execute();
Cooking c1 = new Cooking();
c1.name = "红烧鱼";
c1.food = "鲫鱼";
c1.execute();
}
}
class Cooking {
String name;
String type = "红烧";
String food; // 食材
String relish = "大料"; //佐料
void execute(){
System.out.println("准备食材:"+food);
System.out.println("准备佐料:"+relish);
System.out.println("开始烹饪");
System.out.println("烹饪完成");
}
}
再举一个动物的例子,如果以动物作为class,那么猫和狗则为object;如果以狗为对象,那么斗牛犬、牧羊犬这些则为对象。这里以动物为class,编写以下代码。
public class chapter02 {
public static void main(String[] args) {
Animal a1 = new Animal();
a1.type = "猫";
a1.name = "小黑";
Animal a2 = new Animal();
a2.type = "狗";
a2.name = "大黄";
a1.run();
a2.run();
}
}
class Animal{
String type;
String name;
void run(){
System.out.println(name + type + "跑开了");
}
}
总的来说,对象是将内存地址赋值给了变量,所以变量其实引用了内存中的对象,故称为引用变量,而变量的类型称为引用数据类型。
特殊的对象:空对象(null),没有引用的对象称为空对象,所有引用类型变量的默认取值就是null。
User user = null;
属性
属性其实就是该类的所有对象的相同特征。
class User{
String name;
}
如果和上面这样,不进行属性的初始化,那么属性会在构造对象的时候默认初始化,而默认初始化的值取决于属性的类型。
byte,short,int,long = 0
float,double = 0.0
boolean = false
char = 空字符
引用数据类型 = null
方法
声明和调用的语法:
返回类型 方法名() {
逻辑代码
}
对象.方法名()
public class Java06_Object_Method {
public static void main(String[] args) {
User06 user = new User06();
boolean registerResult = user.register();
if ( registerResult ) {
System.out.println("注册成功,请登录");
boolean loginResult = user.login();
if (loginResult) {
System.out.println("登录成功");
} else {
System.out.println("登录失败");
}
} else {
System.out.println("注册不成功,请重新注册");
}
}
}
class User06 {
boolean register() {
System.out.println("注册软件系统");
// 成功 true
return false;
// 失败 false
}
boolean login() {
System.out.println("登录软件系统");
return true;
}
}
当然,方法也可以进行传参。
传一个参数:
返回值类型[void] 方法名(参数类型 参数名)
如果参数有多个的话,那么在传值的时候需要注意:
- 个数不能缺失
- 类型必须匹配
- 顺序必须匹配
将方法后面的小括号中的所有参数称之为参数列表
public class Java07_Object_Method_Param {
public static void main(String[] args) {
User07 user = new User07();
user.sayHello("zhangsan", 30);
}
}
class User07 {
void sayHello( String name, int age ) {
System.out.println("Hello "+name);
}
}
传多个可变参数:
public class Java07_Object_Method_Param {
public static void main(String[] args) {
// 如果参数的类型(含义)相同,但是个数不确定的场合,JVM提供了可变参数 : 参数的长度可变
// 参数类型...参数名
// 传值的个数也可以是变化的。
User07 user = new User07();
user.printUser(30);
user.printUser(40, "zhangsan");
user.printUser(50, "zhangsan", "lisi", "wangwu");
// 如果参数列表中含有不同含义的多个参数,那么可变参数必须放置在最后,否则出现错误
}
}
class User07 {
void printUser( int age, String... name ) {
System.out.println(name);
}
}
如果参数列表中含有不同含义的多个参数,那么可变参数必须放置在最后,否则出现错误。
以上就是方法传参的各种类型 !
下面再介绍一下,方法传参的底层原理。可以先看下面这个例子:
public class chapter03 {
public static void main(String[] args) {
int i = 10;
test(i);
System.out.println(i);
}
public static void test(int i){
i = i+ 10;
}
}
可以看到以上代码的运行结果是10,这与大部分的所想不一样(20),故下面就介绍传参的原理。
如果是引用数据类型呢?
public class chapter04 {
public static void main(String[] args) {
String s = "abc";
test(s);
System.out.println(s);
}
public static void test(String s){
s = s + "10";
}
}
可以看到结果,还是abc,下面就介绍字符串类型的传参过程:
需要注意的是,当执行s =s +10时,会重新开辟一个内存地址,将内存地址重新赋值给s,所以原来的s还是没有变化。
public class Java07_Object_Method_Param_1 {
public static void main(String[] args) {
User user = new User();
user.name = "zhangsan";
test(user);
System.out.println(user.name);
}
public static void test(User user) {
user.name = "lisi";
}
}
class User {
String name;
}
Java种方法参数的传递为值传递
基本数据类型:数值
引用数据类型:引用地址
静态
针对于具体对象的属性称之为对象属性,成员属性,实例属性
针对于具体对象的方法称之为对象方法,成员方法,实例方法
把和对象无关,只和类相关的称之为静态。和类相关的属性称之为静态属性,和类相关的方法称之为静态方法。故访问这些属性和方法。则使用类进行调用即可。
public class Java08_Object_Static {
public static void main(String[] args) {
Bird.fly();
System.out.println(Bird.type);
}
}
class Bird {
static String type = "鸟";
static void fly() {
System.out.println("飞...");
}
}
先有类,再有对象。成员方法可以访问静态属性和静态方法,但静态方法不可以访问成员属性和成员方法。
静态代码块
类的信息加载完成后,会自动调用静态代码块,可以完成静态属性的初始化功能
public class Java08_Object_Static_2 {
public static void main(String[] args) {
// 类的信息加载完成后,会自动调用静态代码块,可以完成静态属性的初始化功能
// 对象准备创建时,也会自动调用代码块,但不是静态的
//User08.test();
new User08();
}
}
class User08 {
static {
// 静态代码块
System.out.println("静态代码块执行1");
}
static {
// 静态代码块
System.out.println("静态代码块执行2");
}
static void test() {
System.out.println("test...");
}
{
System.out.println("代码块执行1");
}
static {
// 静态代码块
System.out.println("静态代码块执行3");
}
{
System.out.println("代码块执行2");
}
}
包
package中容纳类
基本语法: package 包完整路径, 路径中的多个包使用点隔开
比如: java.lang.Object
主要功能用于分类管理
一个类可以没有包,但是package不可以在同一个源码文件中使用多次
包名为了区分类名,所以一般全部都是小写。
Java中存在不同包的相同名称的类,可以使用包进行区分
一般情况下,在使用类的情况下,我们都会使用类的全名(包名+ 类型)
但使用全名还进行new的话,会很麻烦,故我们可以使用import语法。
import 主要用于在使用类前准备好了,import语句只能使用在package后,class前。
import关键字可以多次使用,导入多个类
如果同一个包中需要导入大量的类,那么可以使用通配符星号来简化操作。
import java.util.*;
如果import不同包中相同名称的类,那么还是需要在使用时增加包名。
构建对象
如果一个类中没有任何的构造方法,那么JVM会自动添加一个公共的,无参的构造方法,方便对象的调用
基本语法: 类名(){}
- 构造方法也是方法,但是没有void关键字。
- 方法名和类名完全 相同
- 如果类中没有构造方法,那么JVM会提供默认的构造方法
- 如果类中有构造方法,那么JVM不会提供默认的构造方法
- 构造方法也是方法,所以也可以传递参数,但是一般传递参数的目的是用于对象属性的赋值
public class Java11_Object_Instance {
public static void main(String[] args) {
//System.out.println("before...");
User11 user = new User11("zhangsan");
//System.out.println("after...");
user.test();
System.out.println(user.username);
// 代码块,是在构造对象之前执行的
}
}
class User11 {
String username;
{
System.out.println("代码块1");
}
User11(String name) {
username = name;
System.out.println("user...");
}
{
System.out.println("代码块2");
}
void test() {
System.out.println("test...");
}
{
System.out.println("代码块3");
}
}