Java类和对象（1）

🐵本篇文章将会开始对类和对象的第一部分讲解

一、简单描述类和对象

对象可以理解为一个实体，在现实生活中，比如在创建一个建筑之前，要先有一个蓝图，这个蓝图用来描述这个建筑的各种属性；此时蓝图就是类，建筑就是对象，简单来说类是用来描述对象的

二、类的定义

类是我们自定义的类型，在定义类时要用到class关键字

class 类名 {

}

类中的内容由成员变量（或属性）和成员方法组成，在方法外、类内定义的变量称为成员变量（在方法内定义的变量是局部变量），下面定义一个日期类：

class Date {
    public int year;
    public int month;
    public int day;
    
    public void fun() {
        System.out.println("2023");
    }
}

注：此处成员变量均由public修饰，此处的成员方法不加static，这些后面会详细解释

之前说过一个文件只能有一个被public修饰的类，不要轻易去改这个类的名字，如要修改，见下图

这样修改被public修饰类的名字的前提是在该文件中只有一个类

三、类的实例化

对象是一个实体，在产生实体之前，要先用类来描述这个实体，通过类创建对象的过程叫作类的实例化，在Java中采用new关键字配合类名来实例化对象

public static void main(String[] args) {
    Date d1 = new Date(); //通过new来实例化一个对象，Date是类名，d1是对象的引用

    d1.year = 2024; //通过.来访问对象的属性和方法
    d1.month = 1;
    d1.day = 1;
}

总结：使用new关键字创建对象，每创建一个对象，在内存中就会为对象开辟一块空间，在这块空间中存储的就是对象的属性，对象的属性是在类中定义的；通过.可以访问对象的属性和方法，而对象的引用指向这块内存空间，其类型就是我们创建的类（我们自定义的类型）

四、类和对象的注意事项

1. 引用不能指向引用，引用只能指向对象

Dog dog1 = new Dog(); //Dog是一个类
Dog dog2 = new Dog();
dog1 = dog2; //这里让dog1指向dog2所指向的对象

创建完两个对象后，在堆区分别开辟了两块内存空间，dog1和dog2是对象的引用且分别指向这两块空间，执行完dog1 = dog2；这条语句后dog1和dog2都指向dog2指向的对象，而原来被dog1指向的对象的内存空间会被JVM回收

2. 一个引用只能指向一个对象

Dog dog3 = new Dog();
dog3 = new Dog();
dog3 = new Dog(); //dog3指向的是这个对象，前面两个对象没有被任何引用指向时会被JVM回收

3. 当对象的引用等于null时，意味着该引用不指向任何对象，并不是指向null对象

Dog dog4 = null;

五、练习：交换两个数的值

class Value {
    public int val;
}
public class Test {
    public static void main(String[] args) {
        //创建两个对象
        Value x = new Value();
        Value y = new Value();
        
        //对对象的属性进行赋值
        x.val = 10;
        y.val = 20;
        
        //交换
        swap(x, y);

        //打印
        System.out.println(x.val);
        System.out.println(y.val);
    }
    public static void swap(Value x1, Value y1) {
        int tmp = x1.val;
        x1.val = y1.val;
        y1.val = tmp;
    }
}

六、this引用

6.1 this讲解

this是指向当前对象的引用，举个例子：

class Date {
    public int year;
    public int month;
    public int day;

    public void setDate(int year, int month, int day) {
        this.year = year; //这里的this指向的就是d这个引用所指向的对象
        this.month = month;
        this.day = day;
    }
}
public class Test {
    public static void main(String[] args) {
        Date d = new Date();
        d.setDate(2023, 11, 11);
    }
}

上述代码中如果不加this，那么在setDate这个方法中就不能完成对成员变量赋值的目的，因为方法中的year、month、day都被认为是形参（名字和形参相同），形参是局部变量，局部变量优先；

this从何而来：实际上，每一个成员方法的第一个参数就是this引用，编译器会自动将调用这个方法的对象传给this，简而言之，谁调用这个方法谁就是this，上述代码中this和d都指向同一个对象

6.2 this注意事项

1. this只能在成员方法中使用

2. this.成员变量===>访问成员变量

3. this.成员方法===>访问当前类的成员方法

public void setDate(Date this, int year, int month, int day) {
    this.year = year;
    this.month = month;
    this.day = day;
    this.printDate();
}
public void printDate() {
    System.out.println(year+" "+month+" "+day);
}

4. this()===>调用当前类的构造方法（接下来会讲）

5. this不能出现在静态方法内部（后面会讲）

七、对象的构造和初始化

7.1 默认初始化

class Date {
    public int year;
    public int month;
    public int day;
}

成员变量在没有初始化时被使用，编译也会顺利通过，这是因为成员变量被定义后会被默认初始化为零值，上述代码的成员变量都被默认为0，boolean型变量被默认为false，char型变量被默认为'\u0000'，引用型变量被默认为null

7.2 就地初始化

class Date {
    public int year = 2024;
    public int month = 1;
    public int day = 1;
}

就地初始化就是在声明成员变量时就赋初始值

7.3 构造方法

构造方法一般是用来初始化对象的，构造方法定义在类中，它也是一种成员方法，构造方法的方法名必须和当前类的名字相同，且没有返回值（注意：并不是返回值类型为void，而是在构造方法中没有返回值这一概念）

在使用new创建完对象后，编译器就会调用构造方法，如果我们自己没有写构造方法，那编译器也会去调用不带参数的默认的构造方法，默认的构造方法如下：

class Date {
    public int year;

    //默认的构造方法，该构造方法不会显示在编译器上但也可以自己写
    public Date() {
    
    }
}

也可以自己写构造方法，-构造方法可以写多个，那么当有多个构造方法时，实例化对象会调用合适的构造方法

class Value {
    public int val;
    
    public Value(int x) { //调用这个方法
        this.val = x;
    }
    public Value() {
        this.val = 20;
    }

}
public class Test {
    public static void main(String[] args) {
        //只传一个参数，那就会调用有一个形参的构造方法
        Value v = new Value(20);
    }
}

通过this()来调用当前类的构造方法，注意this这条语句必须放在成员方法的第一句

class Value {
    public int val;

    public Value(int x) { //x = 20;
        this(); //必须放在第一句，否则编译会报错
        this.val = x;
        System.out.println(this.val);
    }
    public Value() {
        System.out.println("调用了这个构造方法");
    }
}

当我们写了构造方法后，编译器不会再调用默认的构造方法，该构造方法也需要我们自己去写

class Value {
    public int val;

    public Value(int x) {
        this.val = x;
        System.out.println(this.val);
    }
}

public class Test {
    public static void main(String[] args) {
        Value v = new Value(20);
        Value v1 = new Value(); //这样编译会报错，必须写一个无参的构造方法
    }
}