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

发布于:2025-07-07 ⋅ 阅读:(20) ⋅ 点赞:(0)

一、初识面向对象

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 = "男"; //性别

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


未完待续…