Java面向对象编程基础详解#

什么是面向对象编程？#

面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它将现实世界中的事物抽象为对象，通过对象之间的交互来实现程序功能。Java是一种纯面向对象的编程语言。

面向对象编程的核心概念#

1. 类（Class）#

类是对象的蓝图或模板，它定义了对象的属性（成员变量）和行为（成员方法）。

类的定义：

1
public class Person {
2
    // 成员变量（属性）
3
    private String name;
4
    private int age;
5

6
    // 构造方法
7
    public Person(String name, int age) {
8
        this.name = name;
9
        this.age = age;
10
    }
11

12
    // 成员方法（行为）
13
    public void sayHello() {
14
        System.out.println("Hello, my name is " + name);
15
    }
16

17
    // getter和setter方法
18
    public String getName() {
19
        return name;
20
    }
21

22
    public void setName(String name) {
23
        this.name = name;
24
    }
25

26
    public int getAge() {
27
        return age;
28
    }
29

30
    public void setAge(int age) {
31
        this.age = age;
32
    }
33
}

2. 对象（Object）#

对象是类的实例，它具有类定义的属性和行为。

对象的创建和使用：

1
// 创建对象
2
Person person = new Person("张三", 25);
3

4
// 调用对象的方法
5
person.sayHello(); // 输出：Hello, my name is 张三
6

7
// 修改对象的属性
8
person.setAge(26);
9

10
// 获取对象的属性
11
System.out.println(person.getName() + " is " + person.getAge() + " years old");

3. 封装（Encapsulation）#

封装是将对象的属性和行为封装在一起，对外部隐藏实现细节，只提供公共的访问方式。

封装的实现：

使用private关键字修饰成员变量
提供public的getter和setter方法来访问和修改成员变量

封装的优点：

隐藏实现细节，提高代码的安全性
便于修改内部实现，提高代码的可维护性
统一接口，提高代码的可读性

4. 继承（Inheritance）#

继承是子类继承父类的属性和方法，实现代码复用。

继承的实现：

1
// 父类
2
public class Animal {
3
    protected String name;
4

5
    public Animal(String name) {
6
        this.name = name;
7
    }
8

9
    public void eat() {
10
        System.out.println(name + " is eating");
11
    }
12
}
13

14
// 子类
15
public class Dog extends Animal {
16
    public Dog(String name) {
17
        super(name); // 调用父类的构造方法
18
    }
19

20
    // 重写父类的方法
21
    @Override
22
    public void eat() {
23
        System.out.println(name + " is eating bones");
24
    }
25

26
    // 子类特有的方法
27
    public void bark() {
28
        System.out.println(name + " is barking");
29
    }
30
}

继承的特点：

Java只支持单继承，一个子类只能有一个直接父类
子类可以继承父类的非private成员
子类可以重写父类的方法
子类可以添加自己特有的方法和属性

5. 多态（Polymorphism）#

多态是指同一个方法调用可以根据对象的不同而表现出不同的行为。

多态的实现：

继承：子类继承父类
方法重写：子类重写父类的方法
向上转型：父类引用指向子类对象

多态的示例：

1
// 父类引用指向子类对象
2
Animal animal = new Dog("旺财");
3

4
// 调用的是子类重写的方法
5
animal.eat(); // 输出：旺财 is eating bones
6

7
// 向下转型
8
if (animal instanceof Dog) {
9
    Dog dog = (Dog) animal;
10
    dog.bark(); // 输出：旺财 is barking
11
}

多态的优点：

提高代码的灵活性和可扩展性
简化代码结构，提高代码的可读性
便于实现面向接口编程

构造方法#

构造方法是一种特殊的方法，用于创建对象时初始化对象。

构造方法的特点：

构造方法的名称与类名相同
构造方法没有返回值类型
构造方法在创建对象时自动调用
如果没有显式定义构造方法，编译器会生成一个默认的无参构造方法
如果显式定义了构造方法，编译器不会生成默认的无参构造方法

构造方法的重载：

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

5
    // 无参构造方法
6
    public Person() {
7
    }
8

9
    // 有参构造方法
10
    public Person(String name) {
11
        this.name = name;
12
    }
13

14
    // 有参构造方法
15
    public Person(String name, int age) {
16
        this.name = name;
17
        this.age = age;
18
    }
19
}

this关键字#

this关键字表示当前对象的引用，它可以：

访问当前对象的成员变量
调用当前对象的成员方法
调用当前对象的其他构造方法

示例：

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

5
    public Person() {
6
        this("Unknown", 0); // 调用其他构造方法
7
    }
8

9
    public Person(String name) {
10
        this(name, 0); // 调用其他构造方法
11
    }
12

13
    public Person(String name, int age) {
14
        this.name = name; // 访问当前对象的成员变量
15
        this.age = age; // 访问当前对象的成员变量
16
    }
17

18
    public void sayHello() {
19
        System.out.println("Hello, my name is " + this.name); // 访问当前对象的成员变量
20
        this.sayAge(); // 调用当前对象的成员方法
21
    }
22

23
    public void sayAge() {
24
        System.out.println("I am " + this.age + " years old");
25
    }
26
}

super关键字#

super关键字表示父类的引用，它可以：

访问父类的成员变量
调用父类的成员方法
调用父类的构造方法

示例：

1
public class Animal {
2
    protected String name;
3

4
    public Animal(String name) {
5
        this.name = name;
6
    }
7

8
    public void eat() {
9
        System.out.println(name + " is eating");
10
    }
11
}
12

13
public class Dog extends Animal {
14
    public Dog(String name) {
15
        super(name); // 调用父类的构造方法
16
    }
17

18
    @Override
19
    public void eat() {
20
        super.eat(); // 调用父类的方法
21
        System.out.println(name + " is eating bones");
22
    }
23
}

方法重写（Override）#

方法重写是子类重写父类的方法，实现不同的行为。

方法重写的规则：

方法名必须相同
参数列表必须相同
返回值类型必须相同或为父类返回值类型的子类
访问修饰符不能比父类更严格
不能抛出比父类更多的异常

示例：

1
@Override
2
public void eat() {
3
    System.out.println(name + " is eating bones");
4
}

方法重载（Overload）#

方法重载是在同一个类中定义多个同名方法，但参数列表不同。

方法重载的规则：

方法名必须相同
参数列表必须不同（参数个数、参数类型或参数顺序不同）
返回值类型可以不同
访问修饰符可以不同

示例：

1
public class Calculator {
2
    public int add(int a, int b) {
3
        return a + b;
4
    }
5

6
    public double add(double a, double b) {
7
        return a + b;
8
    }
9

10
    public int add(int a, int b, int c) {
11
        return a + b + c;
12
    }
13
}

抽象类和抽象方法#

抽象类是不能实例化的类，它用于定义子类的共同行为。抽象方法是没有实现的方法，它必须由子类实现。

抽象类和抽象方法的定义：

1
public abstract class Shape {
2
    // 抽象方法
3
    public abstract double calculateArea();
4

5
    // 普通方法
6
    public void printArea() {
7
        System.out.println("Area: " + calculateArea());
8
    }
9
}
10

11
public class Circle extends Shape {
12
    private double radius;
13

14
    public Circle(double radius) {
15
        this.radius = radius;
16
    }
17

18
    // 实现抽象方法
19
    @Override
20
    public double calculateArea() {
21
        return Math.PI * radius * radius;
22
    }
23
}
24

25
public class Rectangle extends Shape {
26
    private double width;
27
    private double height;
28

29
    public Rectangle(double width, double height) {
30
        this.width = width;
31
        this.height = height;
32
    }
33

34
    // 实现抽象方法
35
    @Override
36
    public double calculateArea() {
37
        return width * height;
38
    }
39
}

接口#

接口是一种特殊的抽象类，它只包含抽象方法和常量。

接口的定义：

1
public interface Drawable {
2
    // 常量
3
    int MAX_WIDTH = 1000;
4
    int MAX_HEIGHT = 1000;
5

6
    // 抽象方法
7
    void draw();
8

9
    // Java 8+ 可以有默认方法
10
    default void printInfo() {
11
        System.out.println("Drawing with max dimensions: " + MAX_WIDTH + "x" + MAX_HEIGHT);
12
    }
13

14
    // Java 8+ 可以有静态方法
15
    static void printDefault() {
16
        System.out.println("Default drawing settings");
17
    }
18
}

接口的实现：

1
public class Circle implements Drawable {
2
    private double radius;
3

4
    public Circle(double radius) {
5
        this.radius = radius;
6
    }
7

8
    // 实现接口的方法
9
    @Override
10
    public void draw() {
11
        System.out.println("Drawing a circle with radius " + radius);
12
    }
13
}

接口的特点：

Java支持多接口实现，一个类可以实现多个接口
接口中的方法默认是public abstract的
接口中的变量默认是public static final的
Java 8+ 接口可以有默认方法和静态方法
Java 9+ 接口可以有私有方法

面向对象编程的原则#

1. 单一职责原则（Single Responsibility Principle）#

一个类应该只有一个引起它变化的原因，即一个类只负责一项职责。

2. 开放封闭原则（Open-Closed Principle）#

软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。

3. 里氏替换原则（Liskov Substitution Principle）#

子类应该能够替换父类，并且不影响程序的正确性。

4. 接口隔离原则（Interface Segregation Principle）#

客户端不应该依赖它不需要的接口。

5. 依赖倒置原则（Dependency Inversion Principle）#

高层模块不应该依赖低层模块，两者都应该依赖抽象。抽象不应该依赖细节，细节应该依赖抽象。

最佳实践#

使用有意义的类名和方法名：类名和方法名应该能够清晰地表达它们的用途。
使用封装：将成员变量设为private，提供public的getter和setter方法。
使用继承实现代码复用：当多个类有共同的属性和行为时，使用继承实现代码复用。
使用多态提高代码的灵活性：通过父类引用指向子类对象，提高代码的灵活性和可扩展性。
使用接口定义契约：使用接口定义类的行为契约，实现面向接口编程。
合理使用抽象类：当多个类有共同的实现时，使用抽象类。
遵循面向对象编程原则：遵循SOLID原则，编写高质量的面向对象代码。
使用注释：为复杂的类和方法添加注释，提高代码的可读性。

常见陷阱#

忘记使用this关键字：在构造方法或setter方法中，忘记使用this关键字区分成员变量和局部变量。
忘记调用父类的构造方法：在子类的构造方法中，忘记调用父类的构造方法。
方法重写的规则错误：违反方法重写的规则，如方法名不同、参数列表不同等。
多态的使用错误：在使用多态时，试图调用子类特有的方法而没有进行类型转换。
接口和抽象类的使用混淆：不知道何时使用接口，何时使用抽象类。
过度使用继承：为了代码复用而过度使用继承，导致类的层次结构过于复杂。
违反单一职责原则：一个类负责多项职责，导致代码难以维护。

总结#

面向对象编程是Java编程的核心范式，它通过类和对象、封装、继承、多态等概念，帮助我们编写更加模块化、可维护、可扩展的代码。

本文介绍了Java面向对象编程的基本概念和核心特性，包括类和对象的定义与使用、封装的实现、继承的使用、多态的实现、构造方法的使用、this和super关键字的使用、方法重写和重载、抽象类和接口的使用，以及面向对象编程的原则和最佳实践。

希望本文能够帮助你更好地理解Java的面向对象编程，为后续的学习打下坚实的基础。

练习#

编写一个类表示汽车，包含品牌、型号、年份等属性，以及启动、加速、刹车等方法。
编写一个类表示银行账户，包含账号、余额等属性，以及存款、取款、查询余额等方法。
编写一个抽象类表示图形，包含计算面积的抽象方法，然后实现几个具体的图形类，如圆形、矩形、三角形等。
编写一个接口表示可飞翔的对象，包含飞翔的方法，然后实现几个具体的类，如鸟、飞机、火箭等。
编写一个继承体系，如动物类、哺乳动物类、鸟类、狗类、猫类、鹦鹉类等，展示继承和多态的使用。

溪谷回声

记录每一次探索与抵达

Java面向对象编程基础详解