Java中的面向对象编程特性（封装、继承、多态）

目录

类和对象（Classes and Objects）

封装（Encapsulation）

继承（Inheritance）

多态（Polymorphism）

抽象（Abstraction）

---

类和对象（Classes and Objects）

---

        类是Java中面向对象编程的基本构建块，它定义了对象的属性和方法。对象是类的实例，具有类定义的属性和行为。

class Car {
    String brand;
    int year;

    void start() {
        System.out.println("The car is starting.");
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car(); // 创建Car类的对象
        myCar.brand = "Toyota";
        myCar.year = 2022;
        myCar.start();
    }
}

封装（Encapsulation）

---

        封装指的是将数据和方法包装在一个类中，并控制对其访问的权限。封装可以提高代码的安全性和可维护性，避免了外部程序直接访问和修改对象的属性或方法，从而减少了代码出错的可能性。

        在Java中，我们可以通过访问修饰符（public、private、protected、default）来控制属性和方法的访问权限。其中：

1. private：表示私有属性或方法，只能在本类中进行访问，其他类无法访问。

2. public：表示公有属性或方法，可以在任何类中进行访问。

3. protected：表示受保护的属性或方法，可以在本类、子类和同一包中进行访问，但其他类无法访问。

4. default：表示默认属性或方法，只能在同一包中进行访问，其他包中的类无法访问。

        示例：

public class Car {
    private String brand;   // 品牌
    private double price;   // 价格

    public Car(String brand, double price) {
        this.brand = brand;
        this.price = price;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car("BMW", 500000);   // 创建一个汽车对象
        System.out.println(car.getBrand()); // 输出汽车的品牌
        car.setPrice(600000);               // 修改汽车的价格
        System.out.println(car.getPrice()); // 输出汽车的价格
    }
}

        在上面的代码中，我们创建了一个Car类，包含了品牌和价格两个属性，并提供了get/set方法来访问这些属性。在Main类中，我们创建了一个Car对象，并通过调用get/set方法来访问或修改对象的属性。由于属性brand和price是private类型的，外部类无法直接访问，只能通过public的get/set方法来进行访问或修改，从而实现了封装的效果。

继承（Inheritance）

---

        继承指的是通过子类继承父类的属性和方法来实现代码重用和扩展。继承可以减少代码的重复，提高代码的可维护性和可扩展性。在Java中，通过使用关键字 extends 来实现继承。

示例：

public class Animal {
    private String name;  // 名称
    private int age;      // 年龄

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println("Animal is eating.");
    }
}

public class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }

    public void bark() {
        System.out.println("Dog is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Tom", 2);    // 创建一个狗狗对象
        System.out.println(dog.getName() + " is " + dog.getAge() + " years old.");  // 输出狗狗的名称和年龄
        dog.eat();    // 狗狗吃东西
        dog.bark();   // 狗狗叫
    }
}

        我们创建了一个Animal类，包含了名称和年龄两个属性，以及一个eat方法。然后我们创建了一个Dog类，通过 extends 关键字继承了Animal类，并添加了一个bark方法。在Main类中，我们创建了一个Dog对象，并通过调用getName/getAge方法来访问父类的属性，调用eat/bark方法来访问子类的方法。由于Dog类继承了Animal类，所以我们不需要再次定义name/age/eat这些属性和方法，而是可以直接调用父类的属性和方法，从而实现了代码的重用和继承的效果。

多态（Polymorphism）

---

        多态是Java中的面向对象编程特性之一，它指的是同一种行为或方法具有不同的实现方式或表现形式。在Java中，多态有两种实现方式：重载和覆盖。

        重载（Overloading）指的是在同一个类中定义多个同名方法，但参数列表不同，从而实现一种行为具有不同的实现方式的效果。例如：

public class Math {
    public int add(int num1, int num2) {
        return num1 + num2;
    }
    public double add(double num1, double num2) {
        return num1 + num2;
    }
}

        我们定义了两个名称相同但参数列表不同的方法add，分别用于实现整数和浮点数的加法操作。这就是重载的实现方式。

        覆盖（Override）指的是在子类中定义一个与父类中同名同参数方法，从而实现一种行为的不同实现方式。例如：

public class Animal {
    public void move() {
        System.out.println("Animal is moving.");
    }
}

public class Dog extends Animal {
    @Override
    public void move() {
        System.out.println("Dog is running.");
    }
}

        我们定义了一个Animal类，包含一个名为move的方法。然后我们创建了一个Dog类，通过 extends 关键字继承了Animal类，并覆盖了Animal类中的move方法，从而实现了一种不同的行为实现方式。

        在使用多态时，我们可以通过父类类型的引用来调用子类中的方法，从而实现代码的灵活性和扩展性。例如：

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();   // 使用父类类型的引用来创建一个Dog对象
        animal.move();   // 调用子类中覆盖的move方法
    }
}

        我们创建了一个Animal类型的引用animal，并将其指向一个Dog对象。然后我们通过调用animal的move方法，实际上调用的是Dog类中覆盖的move方法，从而实现了多态的效果。

抽象（Abstraction）

---

        抽象指的是一种行为的概念或定义，而不是具体的实现方式。在Java中，我们可以通过抽象类和接口来实现抽象特性。

        抽象类是一种不能实例化的类，它的目的是为了让子类来实现它具体的行为。抽象类中可以包含抽象方法和非抽象方法，其中抽象方法只有方法的声明，而没有具体的实现方式。子类必须实现抽象类中的所有抽象方法才能被实例化。例如：

public abstract class Shape {
    public abstract double getArea(); // 抽象方法，计算图形的面积
    public void printInfo() { // 非抽象方法，用于打印图形的信息
        System.out.println("This is a shape.");
    }
}

public class Circle extends Shape {
    private double radius;
    public Circle(double r) {
        this.radius = r;
    }
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

        我们定义了一个抽象类Shape，其中包含一个抽象方法 getArea 和一个非抽象方法 printInfo。然后我们创建了一个Circle类，通过继承Shape类并实现抽象方法 getArea 来计算圆形的面积，从而实现了抽象类的继承。

        接口是一种没有任何实现的抽象类，它只包含了方法的声明，不包含任何实现。在Java中可以使用关键字 interface 来定义接口。子类必须实现所有接口中声明的方法才能被实例化。例如：

public interface Drawable {
    void draw(); // 接口方法，用于绘制图形
}

public class Circle implements Drawable {
    private double radius;
    public Circle(double r) {
        this.radius = r;
    }
    @Override
    public void draw() {
        // 绘制圆形的代码
    }
}

        我们定义了一个接口Drawable，其中包含一个抽象方法 draw。然后我们创建了一个Circle类，通过实现接口Drawable中的方法 draw 来绘制圆形，从而实现了接口的实现。

        抽象特性的主要作用是提高代码的可扩展性和重用性，通过抽象类和接口来定义一些通用的行为和功能，让具体的子类来实现具体的实现方式，从而实现了一种面向对象编程的设计思想。