白骑士的Java教学面向对象编程篇 3.4 封装、继承与多态

        欢迎继续学习Java编程的面向对象编程（OOP）篇！在前面的章节中，我们了解了类与对象、构造方法以及方法的基本概念。现在，我们将探讨面向对象编程的三大核心特性：封装、继承与多态。这三大特性是构建复杂软件系统的基础，它们使代码更加模块化、可维护、可扩展。通过学习这一节内容，你将掌握如何使用封装来保护数据，使用继承来重用代码，使用多态来实现灵活的对象行为。

封装

什么是封装

        封装是指将对象的属性和行为封装在一起，并提供对外访问的接口，同时隐藏内部实现细节。通过封装，可以保护对象的内部状态，防止外部代码直接访问和修改，从而提高代码的安全性和可维护性。

封装的实现

        封装的实现主要依赖于访问修饰符（如‘private‘、‘public‘、‘protected‘）和访问方法（如getter和setter方法）。

        示例：

public class Student {
    // 私有属性
    private String name;
    private int age;

    // 公共的getter方法
    public String getName() {
        return name;
    }

    // 公共的setter方法
    public void setName(String name) {
        this.name = name;
    }

    // 公共的getter方法
    public int getAge() {
        return age;
    }

    // 公共的setter方法
    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        } 

        else {
            System.out.println("Age must be positive.");
        }
    }
}

        使用封装：

public class Main {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("Alice");
        student.setAge(20);

        System.out.println("Name: " + student.getName());
        System.out.println("Age: " + student.getAge());
    }
}

        输出：

Name: Alice
Age: 20

继承

什么是继承

        继承是指一个类（子类）从另一个类（父类）继承属性和方法。继承使得子类能够重用父类的代码，并可以根据需要扩展或修改父类的行为。通过继承，可以提高代码的复用性和可维护性。

继承的实现

        在Java中，使用‘extends‘关键字来实现继承。

        示例：

// 父类
public class Animal {
    protected String name;

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

// 子类
public class Dog extends Animal {
    public void bark() {
        System.out.println(name + " is barking.");
    }
}

        使用继承：

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "Buddy";
        dog.eat(); // 调用父类的方法
        dog.bark(); // 调用子类的方法
    }
}

        输出：

Buddy is eating.
Buddy is barking.

方法重写

        在继承中，子类可以重写父类的方法，以提供特定的实现。方法重写使用‘@Override‘注解。

        示例：

public class Animal {
    public void makeSound() {
        System.out.println("Animal is making a sound.");
    }
}

public class Cat extends Animal {
    @Override

    public void makeSound() {
        System.out.println("Cat is meowing.");
    }
}

        使用方法重写：

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.makeSound(); // 调用子类重写的方法
    }
}

        输出：

Cat is meowing.

多态

什么是多态

        多态是指同一方法在不同对象中具有不同的表现形式。多态使得对象可以根据具体的实现类型，执行不同的行为。多态性通过方法重写和接口实现来实现。

多态的实现

        多态的实现可以通过父类引用指向子类对象来实现。

        示例：

public class Animal {
    public void makeSound() {
        System.out.println("Animal is making a sound.");
    }
}


public class Dog extends Animal {
    @Override

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


public class Cat extends Animal {
    @Override

    public void makeSound() {
        System.out.println("Cat is meowing.");
    }
}

        使用多态：

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.makeSound(); // 输出 Dog is barking.
        myCat.makeSound(); // 输出 Cat is meowing.
    }
}

接口与多态

        接口是多态的另一种实现方式。通过实现接口，不同的类可以提供不同的实现。

        示例：

public interface Shape {
    void draw();
}


public class Circle implements Shape {
    @Override

    public void draw() {
        System.out.println("Drawing a circle.");
    }
}


public class Rectangle implements Shape {
    @Override

    public void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

        使用接口实现多态：

public class Main {
    public static void main(String[] args) {
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();

        shape1.draw(); // 输出 Drawing a circle.
        shape2.draw(); // 输出 Drawing a rectangle.
    }
}

总结

        通过本篇博客，我们详细介绍了Java中的封装、继承与多态，这三大特性是面向对象编程的核心。封装通过访问修饰符和访问方法保护数据，提高代码的安全性和可维护性；继承通过重用代码和方法重写提高代码的复用性和扩展性；多态通过同一方法在不同对象中的不同表现形式提高代码的灵活性和可扩展性。掌握这些特性，你将能够编写更加模块化、可维护和可扩展的程序。在接下来的学习中，我们将进一步探讨面向对象编程中的抽象类和接口等高级特性，帮助你编写更加复杂和高效的应用程序。希望你能在这段学习旅程中不断进步，享受编程的乐趣！