Java从入门到“放弃”（精通）之旅🚀——类和对象全面解析⑦#

在这里插入图片描述

一、面向对象初探#

1.1 什么是面向对象？#

Java是一门纯面向对象的语言(OOP)，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。

面向对象的==特点==：

更符合人类对事物的认知方式
对大型程序的设计、扩展和维护更加友好
通过对象之间的交互来完成任务

1.2 面向对象 vs 面向过程#

让我们通过洗衣服的例子来理解两者的区别：

传统洗衣服(面向过程)：

现代洗衣服(面向对象)：

对象：人、衣服、洗衣粉、洗衣机

交互过程：人将衣服放进洗衣机、倒入洗衣粉、启动洗衣机面向对象方式不关注具体洗衣过程，而是通过对象间的交互完成任务。

二、类的定义和使用#

2.1 什么是类？#

类是用来对一个实体(对象)进行描述的，主要描述该实体具有哪些属性(外观尺寸等)和哪些功能(用来做什么)。

例如，洗衣机类的属性和功能：

属性：品牌、型号、重量、尺寸、颜色等
功能：洗衣、烘干、定时等

2.2 类的定义格式#

1
// 创建类
2
class ClassName {
3
    field;  // 字段(属性)或成员变量
4
    method; // 行为或成员方法
5
}

洗衣机类示例：

1
class WashMachine {
2
    // 成员变量(属性)
3
    public String brand;   // 品牌
4
    public String type;    // 型号
5
    public double weight;  // 重量
6
    public double length;  // 长
7
    public double width;   // 宽
8
    public double height;  // 高
9
    public String color;   // 颜色
10

11
    // 成员方法(功能)
12
    public void washClothes() {  // 洗衣服
13
        System.out.println("洗衣功能");
14
    }
15

16
    public void dryClothes() {   // 脱水
17
        System.out.println("脱水功能");
18
    }
19

20
    public void setTime() {      // 定时
21
        System.out.println("定时功能");
22
    }
23
}

2.3 小练习#

2.3.1 定义狗类#

在这里插入图片描述

1
class PetDog {
2
   // 属性
3
   public String name;   // 名字
4
   public String color;  // 颜色
5

6
   // 行为
7
   public void bark() {
8
       System.out.println(name + "：旺旺旺~~");
9
   }
10

11
   public void wag() {
12
       System.out.println(name + "：摇尾巴~~");
13
   }
14
}

2.3.2 定义学生类#

在这里插入图片描述

1
public class Student {
2
   // 属性
3
   public String name;
4
   public String gender;
5
   public short age;
6
   public double score;
7

8
   // 方法
9
   public void DoClass() {
10
       System.out.println("按时上课，不要迟到，如果请假，及时去补");
11
   }
12

13
   public void DoHomework() {
14
       System.out.println("教务系统，完成作业，一旦拖沓，神仙难救");
15
   }
16

17
   public void Exam() {
18
       System.out.println("考试目的，了解学情，人人必考，暴露问题");
19
   }
20
}

注意事项：

一般一个文件只定义一个类
main方法所在的类通常用public修饰
public修饰的类必须与文件名相同
不要轻易修改public类的名称

三、类的实例化#

3.1 什么是实例化？#

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

实例化示例：

1
class PetDog {
2
    public String name;
3
    public String color;
4

5
    public void bark() {
6
        System.out.println(name + "：旺旺旺~~~");
7
    }
8

9
    public void wag() {
10
        System.out.println(name + "：摇尾巴~~~");
11
    }
12
}
13

14
public class Main {
15
    public static void main(String[] args) {
16
        // 通过new实例化对象
17
        PetDog dogH = new PetDog();
18
        dogH.name = "小黄";
19
        dogH.color = "黑黄";
20
        dogH.bark();
21
        dogH.wag();
22

23
        PetDog dogS = new PetDog();
24
        dogS.name = "赛虎";
25
        dogS.color = "棕色";
26
        dogS.bark();
27
        dogS.wag();
28
    }
29
}

输出结果：

1
小黄: 旺旺旺~~~
2
小黄: 摇尾巴~~~
3
赛虎: 旺旺旺~~~
4
赛虎: 摇尾巴~~~

3.2 类和对象的关系#

类是一个模型，用于描述实体
类是一种自定义类型，可以用来定义变量
一个类可以实例化多个对象
类比：类就像建筑设计图，对象是根据设计图建造的实际房子

四、this引用#

4.1 为什么需要this引用？#

考虑以下日期类：

1
public class Date {
2
    public int year;
3
    public int month;
4
    public int day;
5

6
    public void setDay(int year, int month, int day) {
7
        year = year;    // 这里会有歧义
8
        month = month;
9
        day = day;
10
    }
11
}

问题：

形参名与成员变量名相同时，赋值语句有歧义
多个对象调用同一方法时，方法如何知道操作的是哪个对象的数据？

4.2 this引用解决方案#

1
public class Date {
2
    public int year;
3
    public int month;
4
    public int day;
5

6
    public void setDay(int year, int month, int day) {
7
        this.year = year;   // 使用this明确指向当前对象的成员变量
8
        this.month = month;
9
        this.day = day;
10
    }
11

12
    public void printDate() {
13
        System.out.println(this.year + "/" + this.month + "/" + this.day);
14
    }
15
}

4.3 this引用特性#

this的类型：对应类类型引用
this只能在成员方法中使用
在成员方法中，this只能引用当前对象
this是成员方法的第一个隐藏参数，编译器自动传递

五、对象的构造及初始化#

5.1 构造方法#

构造方法是一种特殊成员方法，用于初始化对象。

1
public class Date {
2
    public int year;
3
    public int month;
4
    public int day;
5

6
    // 构造方法
7
    public Date(int year, int month, int day) {
8
        this.year = year;
9
        this.month = month;
10
        this.day = day;
11
        System.out.println("Date(int,int,int)方法被调用了");
12
    }
13

14
    public void printDate() {
15
        System.out.println(year + "-" + month + "-" + day);
16
    }
17

18
    public static void main(String[] args) {
19
        Date d = new Date(2021, 6, 9);  // 自动调用构造方法
20
        d.printDate();  // 输出：2021-6-9
21
    }
22
}

5.2 构造方法==特性==#

名字必须与类名相同
没有返回值类型，void也不行
创建对象时由编译器自动调用，生命周期内只调用一次
可以重载
用户未定义时，编译器生成默认无参构造方法
构造方法中可通过this调用其他构造方法
通常使用public修饰

5.3 默认初始化和就地初始化#

默认初始化：成员变量未显式初始化时，Java会赋予默认值

数据类型	默认值
byte	0
short	0
int	0
long	0L
float	0.0f
double	0.0
char	’\u0000’
boolean	false
reference	null

在这里插入图片描述

就地初始化：声明成员变量时直接赋初值

1
public class Date {
2
    public int year = 1900;
3
    public int month = 1;
4
    public int day = 1;
5

6
    // ...
7
}

六、封装#

6.1 封装概念#

==封装是面向对象三大特性之一，将数据和操作数据的方法有机结合，隐藏对象的属性和实现细节，仅对外公开接口。==

举个栗子🌰：计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

6.2 访问限定符#

Java提供四种访问权限：

在这里插入图片描述

封装示例：

1
public class Computer {
2
    private String cpu;     // private: 仅本类可访问
3
    private String memory;  // private: 仅本类可访问
4
    public String screen;   // public: 任何类可访问
5
    String brand;          // default: 同包可访问
6

7
    public Computer(String brand, String cpu, String memory, String screen) {
8
        this.brand = brand;
9
        this.cpu = cpu;
10
        this.memory = memory;
11
        this.screen = screen;
12
    }
13

14
    public void Boot() {
15
        System.out.println("开机---");
16
    }
17
}

6.3 包(package)#

包是对类的封装机制，用于更好地组织类。（可以理解为目录）

在这里插入图片描述

包的导入：

1
import java.util.Date;  // 导入特定类
2
import java.util.*;     // 导入整个包(不推荐)

自定义包：

1
package com.example.demo;
2

3
public class Test {
4
    // 类内容
5
}

七、static成员#

7.1 static修饰成员变量#

static修饰的成员变量属于类，所有对象共享。

1
public class Student {
2
    private String name;
3
    private static String classRoom = "Bit306";  // 静态成员变量
4

5
    public static String getClassRoom() {
6
        return classRoom;
7
    }
8
}
9

10
public class Test {
11
    public static void main(String[] args) {
12
        System.out.println(Student.getClassRoom());  // 输出：Bit306
13
    }
14
}

7.2 static修饰成员方法#

静态方法属于类，不依赖于特定对象实例。

1
public class Student {
2
    private static String classRoom = "Bit306";
3

4
    public static String getClassRoom() {
5
        return classRoom;
6
    }
7
}

静态方法特性：

属于类方法
推荐通过类名调用
不能访问非静态成员变量
不能调用非静态方法
无法重写

八、代码块#

8.1 普通代码块#

定义在方法中的代码块。

1
public class Main {
2
    public static void main(String[] args) {
3
        {
4
            int x = 10;
5
            System.out.println("x1 = " + x);
6
        }
7
        int x = 100;
8
        System.out.println("x2 = " + x);
9
    }
10
}

8.2 构造代码块(实例代码块)#

定义在类中，用于初始化实例成员变量。

1
public class Student {
2
    private String name;
3
    private int age;
4

5
    // 实例代码块
6
    {
7
        this.name = "bit";
8
        this.age = 12;
9
        System.out.println("实例代码块执行");
10
    }
11

12
    public Student() {
13
        System.out.println("构造方法执行");
14
    }
15
}

8.3 静态代码块#

使用static定义，用于初始化静态成员变量。

1
public class Student {
2
    private static String classRoom;
3

4
    // 静态代码块
5
    static {
6
        classRoom = "bit306";
7
        System.out.println("静态代码块执行");
8
    }
9
}

注意事项：

静态代码块只会执行一次
多个静态代码块按定义顺序执行
实例代码块每次创建对象都会执行

九、内部类#

9.1 实例内部类#

未用static修饰的成员内部类。

1
public class OutClass {
2
    private int a = 10;
3

4
    // 实例内部类
5
    class InnerClass {
6
        public void print() {
7
            System.out.println(a);  // 可以直接访问外部类成员
8
        }
9
    }
10
}

9.2 静态内部类#

用static修饰的成员内部类。

1
public class OutClass {
2
    private static int b = 20;
3

4
    // 静态内部类
5
    static class InnerClass {
6
        public void print() {
7
            System.out.println(b);  // 只能访问外部类静态成员
8
        }
9
    }
10
}

9.3 局部内部类#

定义在方法中的内部类。

1
public class OutClass {
2
    public void method() {
3
        class InnerClass {
4
            public void print() {
5
                System.out.println("局部内部类");
6
            }
7
        }
8

9
        InnerClass inner = new InnerClass();
10
        inner.print();
11
    }
12
}

9.4 匿名内部类#

没有名字的内部类，通常用于实现接口或抽象类。

1
interface Message {
2
    void send(String msg);
3
}
4

5
public class Test {
6
    public static void main(String[] args) {
7
        Message m = new Message() {  // 匿名内部类
8
            @Override
9
            public void send(String msg) {
10
                System.out.println("发送消息：" + msg);
11
            }
12
        };
13

14
        m.send("Hello");
15
    }
16
}

十、对象的打印#

默认打印对象时输出的是对象的哈希码，可以通过重写toString()方法自定义输出。

1
public class Person {
2
    String name;
3
    String gender;
4
    int age;
5

6
    public Person(String name, String gender, int age) {
7
        this.name = name;
8
        this.gender = gender;
9
        this.age = age;
10
    }
11

12
    @Override
13
    public String toString() {
14
        return "Person[name=" + name + ", gender=" + gender + ", age=" + age + "]";
15
    }
16

17
    public static void main(String[] args) {
18
        Person p = new Person("张三", "男", 25);
19
        System.out.println(p);  // 输出：Person[name=张三, gender=男, age=25]
20
    }
21
}

总结#

本文全面介绍了Java中类和对象的各个方面，包括：

类的定义和实例化
成员变量和成员方法
this引用的使用
构造方法和对象初始化
封装特性和访问控制
static成员的使用
各种代码块的作用
内部类的分类和使用
对象的打印和toString()方法

掌握这些内容是学习Java面向对象编程的基础，希望本文能帮助大家更好地理解和运用这些概念。在实际开发中，合理使用面向对象的特性可以让代码更加清晰、可维护性更高。

JavaSE专栏（CSDN）

Java从入门到“放弃”（精通）之旅——启航①

Java从入门到“放弃”（精通）之旅——数据类型与变量②

Java从入门到“放弃”（精通）之旅——运算符③

Java从入门到“放弃”（精通）之旅——程序逻辑控制④

Java从入门到“放弃”（精通）之旅——方法的使用⑤

Java从入门到“放弃”（精通）之旅——数组的定义与使用⑥

Java从入门到“放弃”（精通）之旅——类和对象全面解析⑦

Java从入门到“放弃”（精通）之旅——继承与多态⑧

Java从入门到“放弃”（精通）之旅——抽象类和接口⑨

Java从入门到“放弃”（精通）之旅——String类⑩

Java从入门到“放弃”（精通）之旅——JavaSE终篇（异常）

Java从入门到“放弃”（精通）之旅——反射、枚举与Lambda

Overthinker!

Overthinker!

Overthinker!

Java从入门到“放弃”（精通）之旅🚀——类和对象全面解析⑦#

一、面向对象初探#

1.1 什么是面向对象？#

1.2 面向对象 vs 面向过程#

二、类的定义和使用#

2.1 什么是类？#

2.2 类的定义格式#

2.3 小练习#

2.3.1 定义狗类#

2.3.2 定义学生类#

三、类的实例化#

3.1 什么是实例化？#

3.2 类和对象的关系#

四、this引用#

4.1 为什么需要this引用？#

4.2 this引用解决方案#

4.3 this引用特性#

五、对象的构造及初始化#

5.1 构造方法#

5.2 构造方法==特性==#

5.3 默认初始化和就地初始化#

六、封装#

6.1 封装概念#

6.2 访问限定符#

6.3 包(package)#

七、static成员#

7.1 static修饰成员变量#

7.2 static修饰成员方法#

八、代码块#

8.1 普通代码块#

8.2 构造代码块(实例代码块)#

8.3 静态代码块#

九、内部类#

9.1 实例内部类#

9.2 静态内部类#

9.3 局部内部类#

9.4 匿名内部类#

十、对象的打印#

总结#