JavaSE【类和对象】（1）（重点：this引用、构造方法）

目录

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

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还在其中使用，所以是对当前对象的印象！！！