零基础 “入坑” Java--- 八、类和对象（一）

一、初识面向对象

Java是一门纯面向对象的语言（OOP），在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象与对象之间的交互来完成事情。 使用面向对象的思想，对于大型程序的设计、扩展和维护都十分友好。

注意：面向对象并不是一门语言，而是一种解决问题的方法。

在学习类和对象之前，我们需要先记住：对象的产生依赖于类；而类是需要我们自己定义的。

二、类的定义和使用

1.认识类

类是用来对一个实体（对象）进行描述的，对实体进行抽象，主要描述其具备哪些属性（如：颜色、大小等）以及哪些功能。

2.类的定义格式

在Java中需要用到class关键字来定义类，语法格式为：

class ClassName{
// 属性或成员变量
// 行为或成员方法
}

class为定义类的关键字，ClassName为类名，{}中的为类的主体。类的主体中包含的内容称为类的成员。属性是用来描述类的，称为成员属性或成员变量；行为是用来描述类的功能，称为成员方法。

举个例子，我们定义一个洗衣机类：

class WashMachine {
    //成员变量
    public String brand; //品牌
    public double weight; //重量
    public double length; //长
    public double width; //宽
    public double height; //高
    public String color; //颜色
    //成员方法
    public void wash() {
        System.out.println("洗衣");
    }
    public void dry() {
        System.out.println("烘干");
    }
    public void time() {
        System.out.println("定时");
    }
}

成员属性/成员变量定义在类的里面，方法的外面。

注意：在此处我们先将成员前的访问修饰限定符统一写为public，且不带static关键字。

我们再来尝试定义一个狗类：

class Dog {
    //成员属性
    public String brand; //品种
    public String color; //颜色
    public String name; //姓名
    public String sex; //性别
    public int age; //年龄
    //成员方法
    public void call() {
        System.out.println("汪汪");
    }
    public void eat() {
        System.out.println("吃狗粮");
    }
}

在定义类时，我们需要注意：

1.建议一个文件中只定义一个类。
2.由public修饰的类必须要和文件名相同。
3.如果想要修改由public修饰的类的名称，需要通过IDEA去修改（如下图）。

三、类的实例化

定义了一个类，就相当于定义了一种新的类型，与int，double等类似，只不过int，double是Java语言自带的数据类型。当我们定义了一个类之后，就可以使用类来定义对象。

用类 类型创建对象的过程，称为类的实例化。 在Java中通过new关键字和类名来实例化对象。

通过对象的引用（.）访问对象的属性/变量 和方法。

对象的成员属性在没有赋值时，其值为 其数据类型的默认值。

class Dog {
    //成员属性
    public String brand; //品种
    public String color; //颜色
    public String name; //姓名
    public String sex; //性别
    public int age; //年龄
    //成员方法
    public void call() {
        System.out.println(name + "汪汪");
    }
    public void eat() {
        System.out.println(name + "吃狗粮");
    }
}
public class Test {
    public static void main(String[] args) {
        //通过new关键字实例化了一个Dog对象
        Dog a = new Dog(); //a就是一个引用，指向了Dog对象
        //通过对象的引用访问对象的属性/变量 和方法。
        a.name = "小狗1";
        a.age = 6;
        a.call();
        a.eat();
        //通过new关键字可以实例化多个对象
        Dog b = new Dog();
        b.name = "小狗2";
        b.age = 6;
        b.call();
        b.eat();
    }
}

通过new关键字可以实例化多个对象，并且会为每一个实例化出的对象都开辟一块内存空间，存储成员变量。

成员属性存储在对象中，而方法存储在方法区。

可以将类想象为一个模型，用来描述实体。有了类才有对象，类是根据现实中存在的实体抽象出来的，而类想要在代码中表示具体的事物，就需要通过new关键字 实例化对象。

四、this引用

我们先来定义一个日期类：

public class Date {
    public int year;
    public int month;
    public int day;
    //赋值操作
    public void set(int y, int m, int d) {
        year = y;
        month = m;
        day = d;
    }
    //打印日期
    public void print() {
        System.out.println("年：" + year + " 月：" + month + " 日：" + day);
    }

    public static void main(String[] args) {
        Date a = new Date();
        a.set(2025, 7, 5);
        a.print();
        
        Date b = new Date();
        a.set(2025, 6, 5);
        a.print();
    }
}

我们对赋值操作方法的代码进行修改：

    public void set(int year, int month, int day) {
        year = year;
        month = month;
        day = day;
    }

修改完后，输出的结果并不是我们预期的值。这是因为局部变量优先原则，会导致局部变量自己给自己赋值，结果为局部变量数据类型的默认值。

此时，我们就可以使用this来解决这个问题：

    public void set(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

代码的运行结果与我们预期的相符。

1.this引用指向当前对象（当前对象指：成员方法运行时调用该成员方法的对象）。
2.this的类型取决于哪个对象调用，哪个对象调用就是哪个对象的引用类型。
3.this只能在成员方法中使用。
4.this本身 代表的是当前对象的引用。

还可以使用this调用当前对象的方法：

    public void set(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
        //this调用当前对象的方法
        this.print();
    }

使用this调用print方法，程序也可以正常运行，且运行结果与我们预期的相符。

五、对象的构造及初始化

1.有关初始化

在学习有关变量的知识时，我们知道：在定义变量时，一定要给变量一个初始值，否则会导致程序报错。但是当我们定义日期类时，并没有给成员变量赋值，程序却能正常运行。这是因为：当成员变量没有被初始化时，编译器会根据变量的数据类型存储其默认值。

2.构造方法

构造方法是一种特殊的方法：其方法名必须和类名相同且没有返回值。

我们定义一个学生类 并以此举例：

class Student {
    public String name; //姓名
    public int age; //年龄
    public String sex; //性别
    public void stu() {
        System.out.println("学习");
    }
    //构造方法
    public Student() {
        System.out.println("不带参数的构造方法");
    }
}
public class Test_gz {
    public static void main(String[] args) {
        Student a = new Student();
    }
}

我们实例化一个学生类对象，运行程序，控制台上打印出了"不带参数的构造方法"这句话。

我们也可以编写带有参数的构造方法：

class Student {
    public String name; //姓名
    public int age; //年龄
    public String sex; //性别
    public void stu() {
        System.out.println("学习");
    }
    //构造方法
    public Student() {
        System.out.println("不带参数的构造方法");
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("带有2个参数的构造方法");
    }
}
public class Test_gz {
    public static void main(String[] args) {
        Student a = new Student();
        Student b = new Student("小王", 20);
    }
}

此时，"带有2个参数的构造方法"这句话，因为实例化了一个学生类：b，所以也被打印出来。

在创建对象时，构造方法由编译器自动调用，且在整个对象（如：a、b）的生命周期内只调用一次！只有当调用完成构造方法之后，对象才产生了。

在日期类中，我们并没有编写构造方法，但程序仍能运行，这是因为：当一个类中，没有任何一个构造方法时，编译器会自动提供一个不带参数的构造方法。

但是当一个类中，存在一个带有参数的构造方法时，编译器就不会提供不带参数的构造方法。 在上面这段代码中，如果我们删掉不带参数的构造方法，再次运行程序，程序就会报错！！

我们仔细观察上面这段代码中的两个构造方法，其实可以发现 他们之间构成了方法的重载。即构造方法之间是可以构成方法的重载的！！！

完成一个对象的构造需要先分配内存，再调用合适的构造方法，因此：构造方法的作用就是对 对象中的成员变量进行初始化，但并不负责为对象开辟内存空间。

还可以使用 this() 调用当前类中的其他构造方法，具体调用哪个构造方法由 this() 的参数决定：

    public Student() {
        //this()
        this("小王", 20);
        System.out.println("不带参数的构造方法");
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("带有2个参数的构造方法");
    }

注意：this() 只能在构造方法内部使用！！！且只能在构造方法的第一行使用！！！

构造方法绝大多数情况下都是被public修饰的，在某些特殊场景下也会被private修饰。

3.就地初始化

在定义成员变量时，对其直接进行赋值：

    public String name = "小王"; //姓名
    public int age = 20; //年龄
    public String sex = "男"; //性别

但并不推荐这种初始化方式。

未完待续…