java类和对象和this

类

类：类是构造对象的模板和蓝图，它包括了属性（也称为成员变量）和方法（或行为）。

我们举个例子：

public class Dog {
    int age;//①
    String name;//②
    String color;//③

    public void sleep() {
        System.out.println("正在睡觉");
    }
    public void play() {
        System.out.println("正在干饭");
    }
}

1. 拿上面这个代码来说，我们把它想象成一个模板，这个模板包括属性和行为，也就是一只狗应该有的特点（即属性，或成员变量），比如名字，颜色，年龄等等。以及一只修勾应该具有的动作（即方法，或行为），比如睡觉和玩。这样子我们就创造了一个类（类的名字是Dog）。
2. 需要注意的是：对于这个例子来说，类其实就是我们想象中的狗的模样，应该有什么样的特点和什么样的动作，也就是狗的共性，仅仅是模板，并不是一只真正的狗。

对象

而在我们创建完上面那个类之后，采用以下方式就可以通过new关键字可以实例化一个对象了。

类名 对象名字 = new 类名();
new运算符实例化一个类对象，通过给这个对象分配内存并返回一个指向该内存的引用

对于上边的狗类就是：

public class Csdn0327 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //Dog dog1 = new Dog();……
    }
}

1. 重点是：new Dog()会实例化一个类对象，通俗一点就是创建了一个对象，并 返回这个对象的引用（可以理解为地址）
2. 也就是说Dog dog = new Dog();中的dog本质就是一个引用(可以理解为指针)，new Dog()实例化对象后返回了一个引用，我们给这个引用取名为dog
3. 同样的我们可以再定义一个Dog dog2 = dog，对于这种情况来说，我们并没有实例化一个对象，因为没有new，而是创建了一个dog2引用，并且new Dog()这个对象同时被dog2 和 dog所指向

其次

• 再Dog dog = new Dog();之后我们就有一只小狗了，但是我们实例化对象的时候并没有主动地去赋值，所以编译器会把这个对象(狗)的属性(颜色，名字，岁数)都置为默认值，各类型的默认值如下：

    类型                            默认值
    byte/short/int/long             0
    float                           0.0f
    double                          0.0d
    char                            '\u0000'
    boolean                         false
    String                          null

• 当然，我们在实例化对象之后，可以主动去改变我们对象的成员变量(属性)，以及执行对象的方法(行为)

public class Csdn0327 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //主动给对象的
        dog.age = 1;
        dog.name = "博主";
        dog.color = "green";  //访问成员变量并改变它的值
        dog.play();   //执行对象的行为
    }
}

除此之外，我们还有两种初始化的方法

对象的初始化

就地初始化

我们还可以通过 就地初始化 和 通过构造方法初始化 来初始化对象

首先是就地初始化：其实就是我们在创造类的属性的时候，就把值赋上，如下：

public class Dog {
    int age = 1;        
    String name = "博主";
    String color = "green";
 		//以上三行都是在定义成员变量的时候就顺便把值给赋上了
    public void sleep() {
        System.out.println("正在睡觉");
    }
    public void play() {
        System.out.println("正在干饭");
    }
}

• 这样的话，如果不去修改，那么我们通过这个模板(类)所创造出来的对象就都拥有这样子的属性。当然，我们可以再创造出对象后再去修改它。比如

	 Dog dog = new Dog();
 	 dog.color = "red";

• 这种方法在某种情况下会比较有用，比如创造出来的对象都要18岁，那么我们就地初始化后就不用再去修改。但是一般情况下用的比较少。

构造方法

构造方法是一种特殊的方法，用于初始化对象。构造方法在对象创建时被调用。
特点：1. 没有返回值(void也不行)，2. 方法名和类名一致 3. 构造方法可以有多个，他们之间构成重载

1. 首先我们在Dog dog = new Dog();的时候会实例化一个对象，并且调用这个类里面的 同名 没返回值 的方法，即构造方法。比如：

class Dog {
    int age = 1;
    String name = "博主";
    String color = "green";
    //顺带执行下面这个构造方法
    public Dog() {
        System.out.println("这个是构造方法");
    }
    
    public void sleep() { System.out.println("正在睡觉");}
    public void play() { System.out.println("正在干饭");}
}

public class Csdn0327 {
    public static void main(String[] args) {
        Dog dog = new Dog();  //实例化对象后没有任何操作了
    }
}

然后我们执行一下主函数中的那个唯一语句：
这也验证了构造方法的一个特点：在实例化对象后自动调用构造方法并执行

2. 那如果我们码的类中没有构造方法呢？比如我最上面的狗类，那么这就涉及到了构造方法的另一个特点：

如果我们没有写构造方法，编译器在实例化对象的时候，会帮我们补上。
如果我们写了，那就不会补上了。

我们分这两种情况谈论
我们如果自己没有写构造方法，那么编译器就会帮我们补充 空的 无参数的 构造方法，比如：

class Dog {
    int age = 1;
    String name = "博主";
    String color = "green";
    //↓
    public Dog(){

    }
    //↑，如果自己没写构造方法，编译器就会补充这个玩意
}
public class Csdn0327 {
    public static void main(String[] args) {
        Dog dog = new Dog();
    }
}

比如这种我们自己写了任意一种构造方法，那么编译器就不会帮我们补充了↓

• 像上图，我们自己写了一个带一个参数的构造方法，但我们在实例化对象的时候并没有传参
  ，并且编译器并没有找到空参数的构造方法，也不会帮我们补充，所以最下面那行代码报错

3. 在实际应用中，构造方法也为我们初始化成员变量提供了很大的便利，我们举个例子

class Dog {
    int age = 1;
    String name = "博主";
    String color = "green";
    public Dog(){
    }
    public Dog(int a) {
        age = a;
    }
    public Dog(int a, String str) {
        age = a;
        name = str;
    }
}
public class Csdn0327 {
    public static void main(String[] args) {
        Dog dog = new Dog(1);  //给年龄赋值
        Dog dog2 = new Dog(1,"博主");  //在实例化对象的时候顺带赋值
    }
}

我们构造一些列重载构造方法，并在实例化对象的时候传参，就能实现便利的初始化。

this

this关键字可以精准地访问一个类的成员变量，可以用于区分参数和解决成员名冲突(不能在静态方法中使用)

this主要有三种用法，包括：

1.访问成员变量
2.访问成员方法
3.this构造方法

1. 访问成员变量

在当前类中，访问当前类的成员变量：我们举个例子：

• 比如下文中的setAge()方法，this.age表示的是当前类的age变量，而等号右边的age表示的是调用这个方法时传进来的参数，这样也起到了区别参数和成员名的作用。
• 在代码中的主方法中，调用dog对象的setAge方法，将2赋值给该对象的age变量

class Dog {
    int age = 1;
    String name = "博主";
    String color = "green";

    public void setAge(int age) {
        this.age = age;
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setAge(2);  //调用dog对象的setAge方法，将2赋值给该对象的age变量
    }
}

2. 访问成员方法

这个比较好理解，我们举个例子。
比如说Dog类中的temp方法通过this.setAge调用Dog类的setAge方法，不过这时候的this可以不写

class Dog {
    int age = 1;
    String name = "博主";
    String color = "green";

    public void setAge(int age) {
        this.age = age;
    }

    public void temp() {
        this.setAge(2);  //此处
    }
    
    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.age);
    }
}

3. this构造方法

this()用于调用本类中其他合适的构造方法
条件：1. 必须放在构造方法中使用 2. 必须放在构造方法内部的第一行 3. 不能形成环

比如下面这个例子

class Dog {
    int age;
    String name;
    String color;
	//==1==
    public Dog(){
        this(66, "博主", "green");
    }
    //==2==
    public Dog(int age, String str,String color) {
        this.age = age;
        this.name = str;
        this.color = color;
    }
    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog);
    }
}

• 我们在主函数中实例化dog对象的过程中，编译器会去调用适合的构造方法，而我们实例化对象的时候并没有传入参数，所以编译器会调用没有参数列表的Dog构造方法，就是例子里1号方法
• 而1号方法中的this(66, "博主", "green");则会去调用对应的构造方法。