一、类的定义方式以及实例化

1.面向对象

Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在Java的世界里一切皆为对象。

2.类的定义和使用

1.在java中定义类时需要用到class关键字

3.类的实例化

4.类实例化的使用

二、this引用

例子1：this能区分调用方法的对象。

例子2：this区分局部变量和引用对象。

例子3：建议给对象都加上this.

三、对象的构造及初始化

1.初始化对象

1.通过引用赋值来初始化

2.就地初始化：定义成员变量的同时初始化。（一般不用）

2.构造方法

(1) 不带参数的构造方法

1.这个构造方法是如何被调用的？？？

2.那为什么之前没有写构造方法的时候，也能正常执行show方法呢？？？

(2) 带参数的构造方法

1.构造方法可以有多个且构造方法之间构成重载关系

2.一旦自己写了构造函数，编译器不会自动提供了

3.构造函数快捷键生成

4.使用this（）在构造方法内，调用其他构造方法

this（）这个语法只能出现在构造方法当中

只能出现在当前构造方法的第一行！！！

注意：不能自己调用自己！！！

（4）this引用的小总结

一、类的定义方式以及实例化

1.面向对象

Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在Java的世界里一切皆为对象。

举个例子：洗衣服

面向过程：人 - 把洗衣粉倒进盆里 - 打开水龙头 - 放衣服 - 搓衣服 - 清水洗 - 再放洗衣粉 - 搓衣服 - 清水洗 - 扭干衣服

面向对象：人 - 洗衣粉 - 洗衣机

至于洗衣机是左旋转几圈还是右旋转几圈，不在乎洗的过程。

2.类的定义和使用

类是用来对一个实体 ( 对象 ) 来进行描述的 ，主要描述该实体 ( 对象 ) 具有哪些属性 ( 外观尺寸等 ) ，哪些功能 ( 用来干啥) ，描述完成后计算机就可以识别了

定义了一个类，相当于在计算机中定义了一种新的类型

1.在java中定义类时需要用到class关键字

class WashMachine{
//属性
public String brand; // 品牌
public String type; // 型号
public double weight; // 重量
public String color; // 颜色

//方法
public void washClothes(){ // 洗衣服
System.out.println("洗衣功能");
}
public void dryClothes(){ // 脱水
System.out.println("脱水功能");
}
public void setTime(){ // 定时
System.out.println("定时功能");
}
}

3.类的实例化

实例化：用定义的类创建对象，就是类的实例化
用new关键字实例化对象（同一个类可以实例化多个对象）

以下代码：

PetDog petDog1 = new PetDog();

同理PetDog petDog2 = new PetDog();就是在实例化对象

类相当于是一个模型，用这个模型可以造出很多个对象。所以可以实例化多个对象。

class PetDog{
    //狗的属性
    public String name;//名字
    public String color;//颜色

    //狗的行为
    public void barks(){
        System.out.println(name + ":旺旺旺~~~");
    }
    public void wag(){
        System.out.println(name + ":摇尾巴~~~");
    }
}
public class Test2 {
    public static void main(String[] args) {
        //实例化 ：定义了一个类，相当于在计算机中定义了一种新的类型
        //用 定义的类 创建对象，就是类的实例化
        //用new关键字实例化对象（同一个类可以实例化多个对象）
        PetDog petDog1 = new PetDog();
        petDog1.color = "红色";
        petDog1.name  = "feifei";
        //访问实例化对象的属性
        System.out.println(petDog1.name);
        System.out.println(petDog1.color);
        //调用实例化对象的行为
        petDog1.barks();
        petDog1.wag();

        System.out.println("============================");

        PetDog petDog2 = new PetDog();
        petDog2.color = "白色";
        petDog2.name = "huahua";
        //访问实例化对象的属性
        System.out.println(petDog2.name);
        System.out.println(petDog2.color);
        //调用实例化对象的行为
        petDog2.barks();
        petDog2.wag();

//        System.out.println(petDog1);//对象的地址
//        System.out.println(petDog2);
    }
}

4.类实例化的使用

给对象赋值

打印实例化对象的属性，以及 .方法来调用方法

结果：

二、this引用

this引用指向当前对象 ( 成员方法运行时调用该成员方法的对象 ) ，在成员方法中所有成员变量的操作，都是通过该 引用去访问 。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

作用：
1.能区分调用方法的对象。
        date调用的，就对date操作；date2调用的，就对date2操作。
2.区分局部变量和引用对象。
        避免形参名与对象名相同时，局部变量自己赋值。

例子1：this能区分调用方法的对象。

方法只有1个，现在有两个实例化对象date和date2，那么在调用这个方法的时候，我们怎么确定
这个方法是给date赋值，还是在给date2赋值？
date.setDate(1999,1,1);//调用setDate方法,传参 1999,1,1
date2.setDate(2000,2,2);//调用setDate方法,传参 2000,2,2
虽然在调用的时候，有写date或者date2，但是进入方法以后，谁知道谁是谁呢？
    其实，这个方法有个隐藏的函数，Date.this

public class Date {
//属性
    public int year;//public int year = 2023;//一般不写值，写了相当于默认值
    public int month;
    public int day;
//方法
    public void setDate(int y,int m,int d){
        year = y;
        month = m;
        day = d;
    }
}  

public void print(){
    System.out.println("year:"+year+" month:"+month+" day:"+day);
}


public static void main(String[] args) {
        Date date = new Date();//实例化一个date
        date.setDate(1999,1,1);//调用setDate方法,传参 1999,1,1
        // 然后进入该方法，y,m,d根据方法里的内容赋值

        Date date2 = new Date();//又实例化一个date2
        date2.setDate(2000,2,2);//调用setDate方法,传参 2000,2,2
        date.print();
        date2.print();

    }
}

例子2：this区分局部变量和引用对象。

给当传入的形参名，与被赋值的对象名不同时，加不加this，没有任何影响，打印出来时正常的。相同时，例如：此时形参名year和对象名 year相同，此时赋值，受局部变量优先的影响，形参（year）自己给自己赋值，这样打印的结果就不是正常的

得到的结果：

public class Date {
//属性
    public int year;//public int year = 2023;//一般不写值，写了相当于默认值
    public int month;
    public int day;
//方法
    public void setDate(int year,int month,int day){
        year = year;
        month = month;
        day = day;
  

public void print(){
    System.out.println("year:"+year+" month:"+month+" day:"+day);
}


public static void main(String[] args) {
        Date date = new Date();//实例化一个date
        date.setDate(1999,1,1);//调用setDate方法,传参 1999,1,1
        // 然后进入该方法，y,m,d根据方法里的内容赋值

        Date date2 = new Date();//又实例化一个date2
        date2.setDate(2000,2,2);//调用setDate方法,传参 2000,2,2
        date.print();
        date2.print();

    }
}

例子3：建议给对象都加上this.

又得到了预期的结果

所以建议以后写，都加上this，避免这些容易犯的错误

public class Date {
//属性
    public int year;//public int year = 2023;//一般不写值，写了相当于默认值
    public int month;
    public int day;
//方法
public void setDate(Date this,int year,int month,int day){
    this.year = year;
    this.month = month;
    this.day = day;
} 

public void print(){
    System.out.println("year:"+year+" month:"+month+" day:"+day);
}


public static void main(String[] args) {
        Date date = new Date();//实例化一个date
        date.setDate(1999,1,1);//调用setDate方法,传参 1999,1,1
        // 然后进入该方法，y,m,d根据方法里的内容赋值

        Date date2 = new Date();//又实例化一个date2
        date2.setDate(2000,2,2);//调用setDate方法,传参 2000,2,2
        date.print();
        date2.print();

    }
}

三、对象的构造及初始化

1.初始化对象

1.通过引用赋值来初始化

在定义属性的时候一般不赋值，也就是不初始化。
与局部变量不同，局部变量在使用前必须初始化，否则会报错。
而成员变量没有初始化时，有一个默认值。比如int - 0,float - 0.0f,double - 0.0,boolean - false，char - '\u0000'
引用类型例如String - null
2.就地初始化：定义成员变量的同时初始化。（一般不用）
就地初始化：有特殊的业务需求，比如任何一次对象的实例化之后，都期望这个对象叫张三
或者年龄都是9

class Student{
    public String name ;//没有初始化，默认为null
    public int age ;//没有初始化，默认为0 
//public String name = "张三";
//public int age = 9;
    public void eat() {
        System.out.println(this.name+"吃饭！");
    }

    public void show(){
        //this.eat();//可以在成员方法里，调用另一个成员方法
        System.out.println("姓名："+this.name+" 年龄："+this.age);
    }
}

public class Test {
    public static void main(String[] args) {
        /**
         * 实例化对象
         */
        Student student = new Student();
        //同过对象的引用来初始化
        student.name = "zhangsan";
        student.age = 10;
        student.show();

        System.out.println("====================");

        Student student2 = new Student();
        student2.name = "lisi";
        student2.age = 15;
        student2.show();
    }
}

2.构造方法

构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且 在整个对象的生命周期内只调用一次。

构造方法：（非常特殊！！）

1.没有返回值

2.方法名必须和类名一样

特性

1. 名字必须与类名相同

2. 没有返回值类型，设置为 void 也不行

3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次 ( 相当于人的出生，每个人只能出生一次 )

4. 构造方法可以重载 ( 用户根据自己的需求提供不同参数的构造方法 )

这是当前类

这是类里写的构造方法

(1) 不带参数的构造方法

class Student{

    public String name ;//没有初始化，默认为null// 就地初始化：定义成员变量的同时初始化。public String name = "张三"
    public int age ;//没有初始化，默认为0 //public int age = 9

    public void eat() {
        System.out.println(this.name+"吃饭！");
    }

    public void show(){
        //this.eat();//可以在成员方法里，调用另一个成员方法
        System.out.println("姓名："+this.name+" 年龄："+this.age);
    }

    //构造方法
    public Student(){
        this.name = "鼠标";
        this.age = 9;
        System.out.println("构造方法Student()");
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.show();
    }

}

1.这个构造方法是如何被调用的？？？

运行代码时，发现调用show（）方法之前，先调用了构造方法Student（）

在new Student（）这先调用了构造方法public Student，然后在这个构造方法里赋值了，打印了 ”构造方法Student（）“这个内容。然后调用了student.show，将属性打印出来姓名：鼠标年龄：9

2.那为什么之前没有写构造方法的时候，也能正常执行show方法呢？？？

因为，当我们没有写任何一个构造方法的时候，Java会自动提供一个不带参数的构造方法。就是这个样子
    public Student(){

    }

(2) 带参数的构造方法

1.构造方法可以有多个且构造方法之间构成重载关系

class Student{

    public String name ;//没有初始化，默认为null// 就地初始化：定义成员变量的同时初始化。public String name = "张三"
    public int age ;//没有初始化，默认为0 //public int age = 9

    public void eat() {
        System.out.println(this.name+"吃饭！");
    }

    public void show(){
        //this.eat();//可以在成员方法里，调用另一个成员方法
        System.out.println("姓名："+this.name+" 年龄："+this.age);
    }

    /**
     * 构造方法
     */
    //不带参数的构造方法
    public Student(){
        this.name = "鼠标";
        this.age = 9;
        System.out.println("不带参数的构造方法Student()");
    }
    //带参数的构造方法
    public Student(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("带参数的构造方法Student(String,int)");
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.show();

        System.out.println("==================");

        Student student2 = new Student("小明",19);
        student2.show();
    }

}

运行结果

可以发现：

1.构造方法可以有多个

2.构造方法之间构成重载关系

2.一旦自己写了构造函数，编译器不会自动提供了

假如此时把不带参数的构造方法删掉，就会报错了

class Student{

    public String name ;//没有初始化，默认为null// 就地初始化：定义成员变量的同时初始化。public String name = "张三"
    public int age ;//没有初始化，默认为0 //public int age = 9

    public void eat() {
        System.out.println(this.name+"吃饭！");
    }

    public void show(){
        //this.eat();//可以在成员方法里，调用另一个成员方法
        System.out.println("姓名："+this.name+" 年龄："+this.age);
    }

    /**
     * 构造方法
     */

    //带参数的构造方法
    public Student(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("带参数的构造方法Student(String,int)");
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.show();

        System.out.println("==================");

        Student student2 = new Student("小明",19);
        student2.show();
    }

}

不是说，编译器会自动提供不带参数的构造方法吗？？这里为什么又会报错呢？？

原因很简单，当一个构造函数都没有的情况下，才会默认自动提供一个不带参数的

构造方法。目前没有不带参数的构造方法，但是有一个带参数的构造方法，就不会提供了。

以自己编写的这个带参数的构造方法为主，此时，new Student()实例化一个新的对象，里面没有带参数，而自己写的那个是带参数的，所以就报错了。

3.构造函数快捷键生成

如果有太多构造函数需要编写，IDEA有一个快捷键，一键生成。

快捷键 alt+insert ，或者鼠标右键

4.使用this（）在构造方法内，调用其他构造方法

this（）这个语法只能出现在构造方法当中

只能出现在当前构造方法的第一行！！！

注意：不能自己调用自己！！！

成功调用

只能出现在构造方法的第一行！！！

下面这个就错了！！

（4）this引用的小总结

1.this.成员变量

2.this.成员方法

3.this（）在构造方法里调用其他构造方法

注意！！this代表当前对象的引用，而不是当前对象。

因为实例化对象的重要两步是：

1.为对象分配内存

2.调用合适的构造方法

而在调用构造方法的时候，this还在其中使用，所以是对当前对象的印象！！！