Java进阶封装、继承、多态、抽象

一、封装（Encapsulation）

概念

封装是面向对象编程的基本特性之一，它通过将对象的状态（属性）和行为（方法）包装在一起，对外隐藏对象的内部细节，只暴露必要的接口，以实现数据保护和隐藏实现细节的目的。

优点

• 数据保护：防止外部代码直接访问和修改对象的内部数据，确保数据的完整性和有效性。
• 隐藏实现细节：只暴露必要的接口，隐藏对象的实现细节，增强代码的可维护性和可扩展性。
• 提高灵活性：可以根据需要修改内部实现，而不影响外部代码。
• 代码复用：通过封装，将通用功能封装成独立的模块，提高代码复用性。

示例代码

public class Person {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        } else {
            System.out.println("年龄必须为正数");
        }
    }

    public void displayInfo() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("张三", 25);
        person.setAge(-5); // 设置无效年龄，输出错误信息
        person.displayInfo(); // 输出：姓名：张三，年龄：25
    }
}

二、继承（Inheritance）

概念

继承是面向对象编程中的一种机制，它允许一个类（子类）继承另一个类（父类）的属性和方法。通过继承，子类可以复用父类的代码，并可以在子类中添加新的属性和方法，或重写父类的方法。

优点

• 代码复用：子类可以复用父类的属性和方法，减少重复代码。
• 易于扩展：可以在子类中添加新的属性和方法，或重写父类的方法，以实现代码的扩展。
• 提高可维护性：通过继承，可以将通用功能抽取到父类中，集中管理和维护，提高代码的可维护性。

示例代码

class Animal {
    public void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        myDog.makeSound(); // 输出：Bark
        myCat.makeSound(); // 输出：Meow
    }
}

三、多态（Polymorphism）

概念

多态是面向对象编程的一个重要特性，它允许对象以多种形式出现。多态主要通过方法重载（Overloading）和方法重写（Overriding）实现。通过多态，父类引用可以指向子类对象，并调用子类重写的方法。

优点

• 接口重用：通过多态，可以使用统一的接口来操作不同类型的对象，提高代码的重用性。
• 灵活性：通过多态，可以在运行时决定调用哪个子类的重写方法，提高代码的灵活性和扩展性。
• 提高可维护性：通过多态，可以将通用功能抽取到父类中，实现代码的集中管理和维护，提高代码的可维护性。

示例代码

interface Shape {
    double area();
}

class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

class Rectangle implements Shape {
    private double length;
    private double width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public double area() {
        return length * width;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape myCircle = new Circle(5.0);
        Shape myRectangle = new Rectangle(4.0, 6.0);
        System.out.println("Circle area: " + myCircle.area()); // 输出：Circle area: 78.53981633974483
        System.out.println("Rectangle area: " + myRectangle.area()); // 输出：Rectangle area: 24.0
    }
}

四、抽象（Abstraction）

概念

抽象是面向对象编程的基本特性之一，它通过抽象类和接口来实现。抽象类是不能实例化的类，它可以包含抽象方法和具体方法。接口是一种纯抽象的类，所有方法都是抽象的，接口定义了类应该具有的方法，而不实现这些方法。

优点

• 代码重用：通过抽象类，可以将通用功能抽取到父类中，提高代码的重用性。
• 接口隔离：通过接口，可以定义类应该具有的方法，实现接口隔离，提高代码的灵活性和扩展性。
• 提高可维护性：通过抽象类和接口，可以将通用功能和具体实现分离，实现代码的集中管理和维护，提高代码的可维护性。

示例代码

abstract class Vehicle {
    abstract void start();
}

class Car extends Vehicle {
    @Override
    void start() {
        System.out.println("Car is starting");
    }
}

class Bike extends Vehicle {
    @Override
    void start() {
        System.out.println("Bike is starting");
    }
}

interface Flyable {
    void fly();
}

class Airplane implements Flyable {
    @Override
    public void fly() {
        System.out.println("Airplane is flying");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle myCar = new Car();
        Vehicle myBike = new Bike();
        myCar.start(); // 输出：Car is starting
        myBike.start(); // 输出：Bike is starting

        Flyable myAirplane = new Airplane();
        myAirplane.fly(); // 输出：Airplane is flying
    }
}

总结

封装、继承、多态和抽象是面向对象编程的四大基本特性，通过学习和实践这些特性，可以更好地设计和实现面向对象的程序，提高代码的质量、可维护性和可扩展性。在实际开发中，合理运用这些特性，可以编写出更高效、灵活和健壮的代码。