【JavaSE】----- 类和对象

最新推荐文章于 2024-10-17 10:27:13 发布

潇湘夜雨.

最新推荐文章于 2024-10-17 10:27:13 发布

阅读量432

点赞数 10

文章标签： java 开发语言后端经验分享

本文链接：https://blog.csdn.net/qq_45058331/article/details/122675363

版权

本文详细介绍了Java中的面向对象编程概念，包括类、对象的实例化、成员变量、方法、静态关键字、toString方法、封装、构造方法、代码块以及匿名对象。通过实例解析了面向对象的核心思想和使用技巧，帮助读者理解Java中类和对象的关系以及如何通过对象进行交互。

摘要由CSDN通过智能技术生成

一、初识类与对象

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
面向过程注重的是过程，在整个过程中所涉及的行为，就是功能。
面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来

🍓面向过程与面向对象举例

洗衣服的方式举例

🎄面向过程：

拿个盆子 -> 放水 -> 放衣服 -> 放洗衣粉 -> 手搓 -> 换水 -> 手搓 -> 换水 -> 手搓 -> 拧干 -> 晾衣服。

🎄面向对象：

使用洗衣机洗
总共有4个对象：人、衣服、洗衣粉、洗衣机
整个洗衣服的过程：人将衣服放进洗衣机、倒入洗衣粉，启动洗衣机，洗衣机就会完成整个过程并甩干。
整个过程主要是：人、衣服、洗衣粉、洗衣机四个对象之间交互完成的，人不需要关注洗衣机具体是如何洗衣服的，是如何甩干的。

🍓面向对象的概念

面向对象是思考问题的一种思考方式，是一种思想。比如：概念与实例。理论与实践。名和实等等。
类就是一类对象的统称。对象就是这一类具体化的一个实例。
面向对象的好处：将复杂的事情变简单了，只要面对一个对象就行。

面向对象设计：面向对象只需要做的是：找对象，创建对象，使用对象，并维护对象之间的关系。
总结：面向对象就是用代码(类)来描述客观世界的事物的一种方式. 一个类主要包含一个事物的属性和行为。

二、类和类的实例化

类就是一类对象的统称。对象就是这一类具体化的一个实例。
举例：我们做月饼的模子就是一个类，而通过这个模子可以做出月饼，那么在这个例子当中，类就是那个模子，而月饼就是那个对象,所以月饼就是一个实体。一个模子可以实例化无数个对象。
总的来说：类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。
声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型， Java 使用关键字 class 来声明类。

🍓创建类

⭐基本语法

// 创建类
class <class_name>{
    field;//成员属性
    method;//成员方法
}
// 实例化对象是在 main 方法中 new 一个对象
<class_name> <对象名> = new <class_name>();

🍉class为定义类的关键字，ClassName为类的名字，{}中为类的主体。
✨类中的元素称为：成员属性。类中的函数称为：成员方法。

🌊代码示例：创建一个人的类

class Person{
    //字段 -》属性 -》成员变量
    public String name;
    public int age;

    //成员方法 -》行为
    public void eat(){
        System.out.println(name+"正在吃饭");
    }
    public void sleep(){
        System.out.println(name+"正在睡觉");
    }
}

💥注意事项：类中的方法是成员方法，成员方法可以不使用 static 关键字修饰。

🍓类的实例化

🍎用类类型创建对象的过程，称为类的实例化

类只是一个模型一样的东西，限定了类有哪些成员.
一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量
打个比方：类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。

🌊 代码示例：

class Person{
    //字段 -》属性 -》成员变量 ->定义在类的内部，方法的外部
    public String name;
    public int age;

    //方法 -》行为
    public void eat(){
        System.out.println("正在吃饭");
    }
    public void sleep(){
        System.out.println("正在睡觉");
    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        Person person = new Person();//通过new实例化对象
        person.eat();//成员方法调用需要通过对象的引用调用
        person.sleep();
        //产生对象 实例化对象
        Person person2 = new Person();
        Person person3 = new Person();
    }
}

运行结果

✨ Person person = new Person();中，person 是一个变量，只不过这个变量存储的是实例化对象（ new Person(); ）的地址，所以这个变量也别叫做引用。

💥注意事项：

new 关键字用于创建一个对象的实例.
使用 . 来访问对象中的属性和方法.
同一个类可以创建多个实例。

🍓对象在内存中的存储

🌊代码示例：创建对象调用成员变量并赋值

class Person{
    //字段 -》属性 -》成员变量 ->定义在类的内部，方法的外部
    public String name ;
    public int age;
}
public class TestDemo2 {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "张三";
        person.age = 20;
        System.out.println(person.name);
        System.out.println(person.age);
        System.out.println("----------------------");
        Person person1 = new Person();
        System.out.println(person1.name);
        System.out.println(person1.age);
    }
}

代码分析

运行结果

三、类的成员

✨类的成员可以包含以下：字段、方法、代码块、内部类和接口等。此文章中只介绍前三个。

🍓字段/属性/成员变量

在类中, 但是方法外部定义的变量. 这样的变量我们称为 "字段" 或 "属性" 或 "成员变量"(三种称呼都可以, 一般不会严格区分).

🌊代码示例：

class Person{
    //字段 -》属性 -》成员变量 ->定义在类的内部，方法的外部
    public String name;
    public int age;
}
public class TestDemo2 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);
        System.out.println(person.age);
    }
}

运行结果

💥注意事项

使用 . 访问对象的字段.
"访问" 既包含读, 也包含写.
对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值.

🍓成员变量默认值规则

❄对于整数类型（byte、short、int、long）默认值为0。
❄对于浮点型（float、double）默认值为0.0。
❄对于字符型（char）默认值为'\u0000'（'\u0000'代表的是空字符，属于控制字符，也叫不可显字符，与空格字符同，空格字符是'\u0020'）。
❄对于 boolean 类型, 默认值为 false.
❄对于引用类型(String, Array, 以及自定制类), 默认值为 null。

🍓认识null

null 在 Java 中为 "空引用", 表示(引用)不指向任何对象.。
类似于 C 语言中的空指针. 如果对 null 进行 . 操作就会引发异常。

💦补充：引用不一定是在栈上

class Person{
    public String name ;
    public int age;
}
public class TestDemo {
    //成员变量
    Person person = new Person();
    public static void main(String[] args) {
        TestDemo testDemo = new TestDemo();
    }
}

代码分析

🍎字段就地初始化

很多时候我们不希望字段使用默认值, 而是需要我们显式设定初值. 可以这样写:

class Person{
    //字段 -》属性 -》成员变量 ->定义在类的内部，方法的外部
    public String name = "张三";
    public int age = 18;

}
public class TestDemo2 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);
        System.out.println(person.age);
    }
}

运行结果

🍓方法

Java中的方法就是其他编程语言中的函数。

class Person{
    public String name ;
    public int age;

    //方法 -》行为
    public void eat(){
        System.out.println(name+"正在吃饭");
    }
    public void sleep(){
     System.out.println(name+"正在睡觉");
    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "张三";
        person.age = 20;
        person.eat();
        person.sleep();
    }
}

运行结果

此处的 eat 方法与 sleep 方法, 表示 Person 这个对象具有一个 "展示自我" 的行为.
这样的方法是和 person 实例相关联的。

🍓static关键字

修饰属性
修饰方法
代码块
修饰类

🍎修饰属性

Java静态属性和类相关, 和具体的实例无关. 换句话说, 同一个类的不同实例共用同一个静态属性。

class Person{
    public int age;
    public static int count;
}
public class TestDemo2 {
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.age++;
        System.out.println("person1->age " + person1.age);

        person1.count++;
        System.out.println("person1->count " + person1.count);

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

        Person person2 = new Person();
        person2.age++;
        System.out.println("person2->age " + person2.age);

        person2.count++;
        System.out.println("person2->count " + person2.count);
    }
}

代码分析

运行结果

🍉静态成员变量可以通过类名直接调用

🌊代码示例：

class Person{
    public int age;
    public static int count;
}
public class TestDemo2 {
    public static void main(String[] args) {
        Person.count++;
        System.out.println(Person.count);
        System.out.println("-------------------");
        Person.count++;
        System.out.println(Person.count);
    }
}

运行结果

✨静态成员变量不需要对象~

🍎修饰方法

如果在任何方法上应用 static 关键字，此方法称为静态方法。
静态方法属于类，而不属于类的对象。
可以直接通过类调用静态方法，而无需创建类的实例。
静态方法可以访问静态成员变量，并可以更改静态成员变量的值。

🌊代码示例：

class Person{
    public String name;
    public int age;
    //静态成员变量 -> 类变量
    public static int count;

    //静态方法 -> 类方法
    public static void staticFunc(){
        System.out.println("static::func()");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person.staticFunc();
    }
}

运行结果

💥注意事项 1 :

✨静态成员变量不可以定义在方法中。

✨静态方法内部不可以调用普通方法

✨普通方法中可以调用静态方法

class Person{
    public String name;
    public int age;
  
    //静态方法 -> 类方法
    public static void staticFunc(){

        System.out.println("static::func()");
    }

    //普通方法
    public void print(){
        //调用静态方法
        staticFunc();
        System.out.println("姓名："+name+"，年龄："+age);
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.print();
    }
}

运行结果

普通方法依赖对象，静态方法不依赖对象可以由类直接调用。
对象是由类创建的，所以在调用外面的普通方法时已经通过类创建了对象。
普通方法可以调用静态方法。

💥注意事项 2：

之前写的方法都统一加上了 static，但实际上一个方法具体要不要带 static, 都需要是情形而定。
main 方法为 static 方法.

🍎main函数为什么是静态的？

main函数是不是静态的都可以，只不过JVM加载main函数时有自己的加载逻辑，JVM在设计时规定只能加载静态的main方法。这个主要取决于JVM的实现。

🚀static修饰成员变量与方法的总结：

class Person {
    public int age;//普通成员变量 存放在对象内
    public String name;//普通成员变量
    public String sex;//普通成员变量
    public static int count;//类变量也叫静态变量，编译时已经产生，属于类本身，且只有一份。存放在方法区
   
    //一个对象存储到哪里与是否被final修饰无关
    public final int SIZE = 10;//被final修饰的叫常量，也属于对象。 被final修饰，后续不可更改
    public static final int COUNT = 99;//静态的常量，属于类本身，只有一份 被final修饰，后续不可更改

    //实例成员函数（方法）
    public void eat() {
        //方法内不可以定义静态成员变量
        //static int b = 0; //error

        int a = 10;//局部变量
        System.out.println("eat()!");
    }
    //普通方法
    public void sleep() {
        System.out.println("sleep()!");
    }
    //静态方法
    public static void staticTest(){
        //不能访问非静态成员
        //sex = "man"; error

        //静态方法可以访问静态成员
        count = 100;

        //方法内不可以定义静态成员变量
       // static int b = 0; error
        System.out.println("StaticTest()");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        //产生对象 实例化对象
        Person person = new Person();//person为对象的引用
        Person person2 = new Person();//person为对象的引用

        System.out.println(person.age);//默认值为0
        System.out.println(person.name);//默认值为null
        //System.out.println(person.count);//会有警告!

        //正确访问方式：
        System.out.println(Person.count);
        System.out.println(Person.COUNT);
        Person.staticTest();

        //总结：所有被static所修饰的方法或者属性，全部不依赖于对象。
        person.eat();
        person.sleep();
    }
}

运行结果

数据属性的内存布局

四、toString方法

在打印属性时，都是自己实现 print 函数（方法），再调用 print 方法进行打印：

class Person{
    public String name;
    public int age;

    public void print(){
        System.out.println("姓名："+name+"，年龄："+age);
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.print();
    }
}

✨Java中打印内容是通过调用底层Object类的 toString 方法进行打印：

class Person{
    public String name;
    public int age;
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person);
    }
}

🌌 因为person引用指向它实例化的对象，person存放对象的地址，所以打印person就会打印出它指向的对象的地址。

⭐ @前面是当前所指向的对象类型，@后面是一个哈希值，这个值是就是经过处理后的person所指向的对象的地址值。（因为Java比较安全，不能拿到对象真正的地址）。

既然已经了解了Java中打印内容是通过调用底层 Object 类的 toString 方法进行打印的，就可以直接使用 toString 这样的方法来将对象自动转成字符串返回到main函数中打印（自己实现时要与底层的toString 方法的方法类型、方法名保持一致）。这样就不用自己去写一个打印函数打印来内容了。

class Person{
    public String name;
    public int age;
    public String  toString(){
        return "hello";
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person);
    }
}

运行结果

此时打印的结果就是调用自己实现的 toString 方法的返回值。

✨自己写 toString 方法，如果改变了方法名，打印时就不会调用底层Object类的toString方法。

⭐ 通过使用 toString 方法（这里的toString方法是通过IDEA快捷键生成的）打印对象的属性：

class Person{
    public String name;
    public int age;
    //重写Object的toString方法
    @Override  
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "张三";
        person.age = 20;
        System.out.println(person);
    }
}

运行结果

⭐总结：

toString 方法会在使用 println 的时候被自动调用.
将对象转成字符串这样的操作我们称为序列化，将字符串转换为对象称为返序列化。
toString 是 Object 类提供的方法, 我们自己创建的 Person 类默认继承自 Object 类, 可以重写 toString 方法实现我们自己版本的转换字符串方法. (关于继承和重写这样的内容, 我会后面的文章中介绍).
@Override 在 Java 中称为 "注解", 此处的 @Override 表示下面实现的 toString 方法是重写了父类的方法。
IDEA快速生成Object的toString方法快捷键：Alt+Insert。

五、封装

🍓什么是封装?

软件开发的本质就是对程序复杂程度的管理. 如果一个软件代码复杂程度太高, 那么就无法继续维护. 如何管理复杂程度? 封装就是最基本的方法.
在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者.
封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了.这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度。

🍓private实现封装

🍎private/ public 这两个关键字表示 "访问权限控制" .

被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用.
换句话说, 类的使用者根本不需要知道, 也不需要关注一个类都有哪些 private 的成员. 从而让类调用者（类的使用者）以更低的成本来使用类。
使用public修饰会导致类的使用者(main方法的代码)必须要了解 Person 类内部的实现, 才能够使用这个类.。
一旦类的实现者修改了代码(例如把 name 改成 myName), 那么类的使用者就需要大规模的修改自己的代码, 维护成本较高。

✨如果在写代码时使用 private 封装属性, 并提供 public 方法供类的使用者使用，这样就算类的实现者修改了代码，使用者也不需要修改代码，从而降低了维护成本。

class Person{
    private String name;
    private int age;
    //设置成员变量name，对其赋值
    public void setName(String myName){
        name = myName;
    }
    //获取成员变量name的值
    public String getName(){
        return name;
    }

}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        //person.name = "张三"; //不可以直接调用private修饰的属性
        person.setName("张三");
        System.out.println("姓名："+person.getName());
    }
}

运行结果

使用 private 来修饰. 类的调用者(main方法中)不能直接使用。而需要借助 setName 方法对类中的属性赋值，再使用 getName 方法获取属性的值然后打印内容. 此时类的使用者就不必了解 Person 类的实现细节.
同时如果类的实现者修改了属性的名字, 类的调用者不需要做出任何修改(类的调用者根本访问不到 name, age这样的属性，同时也提高了代码的安全性)。

如果类的实现者修改了 public 方法的名字, 岂不是类的调用者仍然需要大量修改代码？

事情确实如此, 但是一般很少会发生. 一般类的设计都要求类提供的 public 方法能比较稳定, 不应该频繁发生大的改变. 尤其是对于一些基础库中的类, 更是如此. 每次接口的变动都要仔细考虑兼容性问题。

💥注意事项

private 不仅能修饰属性, 也能修饰方法
通常情况下我们会把属性设为 private 属性, 但是方法是否需要设为public, 就需要视具体情形而定。一般我们希望一个类只提供 "必要的" public 方法, 而不是把所有的方法都设为public。

🍓getter和setter方法

如果需要获取或者修改这个 private 属性, 就需要使用 getter / setter 方法。
上面的代码中写的getName 即为 getter 方法, 表示获取这个成员的值；setName 即为 setter 方法, 表示设置这个成员的值。
不是所有的字段都一定要提供 setter / getter 方法, 而是要根据实际情况决定提供哪种方法.
在 IDEA 中可以使用 alt + Insert (或者 alt + F12) 快速生成 setter / getter 方法.

class Person{
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        //person.name = "张三"; //不可以直接调用private修饰的属性
        person.setName("张三");
        person.setAge(20);
        System.out.println("姓名："+person.getName()+"，年龄："+person.getAge());
    }
}

✨当set方法的形参名字和类中的成员变量的名字一样的时候，如果不使用this, 相当于自赋值。 this 表示当前对象的引用。

六、构造方法

🍓基本语法

🍎构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用。

✨一个对象的产生【对象实例化】（new 的执行过程）：

为对象分配内存空间
调用对象的构造方法

🍓语法规则

方法名称必须与类名称相同
构造方法没有返回值类型声明
每一个类中一定至少存在一个构造方法（如果没有明确定义，则系统自动生成一个无参的构造方法）。

💥注意事项：

如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造方法
若类中定义了构造方法，则默认的无参构造将不再生成.
构造方法支持重载. 规则和普通方法的重载一致。

class Person{
    private String name;
    private int age;
    public Person(){
        System.out.println("这是一个无参的构造方法");
    }
    public Person(String name){
        this.name = name;
        System.out.println(name);
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("姓名："+this.name+"，年龄："+this.age);
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("==========");
        Person person2 = new Person("张三");
        System.out.println("==========");
        Person person3 = new Person("张三",20);
    }
}

运行结果

🍓this关键字

this表示当前对象的引用(注意不是当前对象). 可以借助 this 来访问对象的属性和方法。
this.data：调用当前对象的属性
this.func()：调用当前对象的方法
this()：调用当前对象的其他构造方法。
this()：只能存放在构造方法中，必须放在构造方法中的第一行，一个构造方法中只能使用一个this()。

class Person{
    private String name;
    private int age;
    public void eat(){
        System.out.println("正在睡觉");
    }

    public Person(){
        this("李四",25);
        this.eat();
        System.out.println("这是一个无参的构造方法");
    }
    public Person(String name){

        this.name = name;
        System.out.println(name);
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("姓名："+this.name+"，年龄："+this.age);
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("==========");
        Person person2 = new Person("张三");
        System.out.println("==========");
        Person person3 = new Person("张三",20);
    }
}

运行结果

七、代码块

🍓什么是代码块

🎄 使用 {} 定义的一段代码.
✨根据代码块定义的位置以及关键字，又可分为以下四种：

普通代码块（本地代码块）
构造代码块（实例代码块）
静态代码块
同步代码块

🍓普通代码块

🍎普通代码块：定义在方法中的代码块
🌊代码示例：

public class TestDemo {
    public static void main(String[] args) {
        {
            int a = 10;
            System.out.println("本地代码块:"+a);
        }
        int a = 20;
        System.out.println(a);
    }
}

本地代码块很少使用。

🍓构造代码块

🍎构造代码块：

定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

class Person{
    private String name;
    private int age;
    
    public Person(){
        System.out.println("这是一个无参的构造方法");
    }

    {
        System.out.println("实例代码块，也叫构造代码块");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

运行结果

💥注意事项: 实例代码块优先于构造方法执行。

🍓静态代码块

✨使用static定义的代码块。一般用于初始化静态成员变量

class Person{
    private String name;
    private int age;

    {
        System.out.println("实例代码块，也叫构造代码块");
    }

    public Person(){
        System.out.println("这是一个无参的构造方法");
    }

    static {
        System.out.println("这是静态代码块");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

运行结果

🎄结论1：无论静态代码块、实例点代码块、构造方法三个的位置是怎样的，调用顺序都是：

先调用静态代码块，再调用实例代码块，最后调用构造方法。

class Person{
    private String name;
    private int age;

    {
        System.out.println("实例代码块，也叫构造代码块");
    }
    public Person(){
        System.out.println("这是一个无参的构造方法");
    }
    static {
        System.out.println("这是静态代码块");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("============");
        Person person2 = new Person();

    }
}

运行结果

🎄结论2：静态代码块只会被执行一次。

class Person{
    private String name;
    private int age;
                          
    public static int count;
 
    {
        System.out.println("实例代码块，也叫构造代码块");
    }
    public Person(){
        System.out.println("这是一个无参的构造方法");
    }
    static {
        System.out.println("这是静态代码块");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        System.out.println(Person.count);
    }
}

运行结果

🎄结论3：静态代码块不用实例化对象也可以被执行。

🎄实例代码块与静态代码块的结论一样，打印的结果与定义顺序有关。

💦这个知识点不用刻意去记，一般在写代码时都是属性在前面定义，其他的在后面定义。

八、匿名对象

匿名只是表示没有名字的对象。
没有引用的对象称为匿名对象。
匿名对象只能在创建对象时使用。
如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象。

class Person{
    private String name;
    private int age;
    public static int count ;
    
    public void sleep(){
        System.out.println("正在睡觉");
    }
    public Person(){
        System.out.println("这是一个无参的构造方法");
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("姓名："+this.name+"，年龄："+this.age);
    }
}
public class TestDemo {
    public static void main(String[] args) {
        new Person().sleep();
        new Person();
        new Person("张三",22);
    }
}

运行结果

🌌内容总结

一个类可以产生无数的对象，类就是模板，对象就是具体的实例。
类中定义的属性，大概分为几类：类属性，对象属性。其中被static所修饰的数据属性称为类属性, static修饰的方法称为类方法，特点是不依赖于对象，我们只需要通过类名就可以调用其属性或者方法。
静态代码块优先实例代码块执行，实例代码块优先构造函数执行。
this关键字代表的是当前对象的引用。并不是当前对象。

九、练习

🎄编写一个类Calculator,有两个属性num1,num2,这两个数据的值，不能在定义的同时初始化，最后实现加减乘除四种运算。

class Calculator{
    private int num1;
    private int num2;

    public int getNum1() {
        return num1;
    }

    public void setNum1(int num1) {
        this.num1 = num1;
    }

    public int getNum2() {
        return num2;
    }

    public void setNum2(int num2) {
        this.num2 = num2;
    }
    public int add(){
        return num1+num2;
    }
    public int sub(){
        return num1-num2;
    }
    public int mul(){
        return num1*num2;
    }
    public double dev(){
        return (double) num1/num2;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        calculator.setNum1(10);
        calculator.setNum2(20);
        //加法
        System.out.println(calculator.add());
        //减法
        System.out.println(calculator.sub());
        //乘法
        System.out.println(calculator.mul());
        //除法
        System.out.println(calculator.dev());
    }
}

🎄实现交换两个变量的值。要求：需要交换实参的值

class MyValue{
    public int value;
}
public class TestDemo {
    public static void swap(MyValue myV1,MyValue myV2){
        int temp = myV1.value;
        myV1.value = myV2.value;
        myV2.value = temp;
    }

    public static void main(String[] args) {
        MyValue myValue1 = new MyValue();
        myValue1.value = 10;
        MyValue myValue2 = new MyValue();
        myValue2.value = 20;
        System.out.println("交换前：myValue1:"+myValue1.value+"，myValue2:"+myValue2.value);
        swap(myValue1,myValue2);
        System.out.println("交换后：myValue1:"+myValue1.value+"，myValue2:"+myValue2.value);
    }
}

内存布局