详解Java封装、继承、多态

Java是一种非常流行的面向对象编程语言，其中最核心的概念就是封装、继承和多态。在使用Java进行开发过程中，掌握这三个概念是非常重要的。本文将详细讲解Java封装、继承、多态的含义、原理、应用和示例，以帮助读者加深对这三个概念的理解。

什么是封装

封装是面向对象编程的一个重要原则，它是指将数据和对数据的操作封装在一个类中，并且对外部隐藏类的细节。

在Java中，通过使用访问修饰符（public、protected、private）来实现对类中数据和方法的访问控制。对于被封装的数据，我们通常使用public方法（getter和setter方法）来访问和修改。这样，我们可以有效地保护数据的安全性，并且避免程序出现错误。

示例

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

在上面的示例中，我们定义了一个Person类，并把name和age属性都设为了私有的（即被封装起来了）。为了访问和修改这两个属性，我们定义了名为getName()和getAge()的共有方法（即getter方法），以及setName()和setAge()方法（即setter方法）。这样，外部代码就可以通过调用这些方法来访问和修改这两个属性。

什么是继承

继承是面向对象编程中的另一个重要概念，它允许我们创建新的类，并且在已有类的基础上进行扩展。在Java中，用关键字extends来表示继承关系。

子类从父类继承了所有的非私有属性和方法，并且可以在自己的类中加入新的属性和方法。这种“父类-子类”的继承关系，使得代码的复用度更高，并且方便了我们进行类的扩展和维护。

示例

public class Animal {
    protected String name;
    protected int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

public class Dog extends Animal {
    private String breed;

    public Dog(String name, int age, String breed) {
        super(name, age);
        this.breed = breed;
    }

    public String getBreed() {
        return breed;
    }

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

在上面的示例中，我们定义了两个类：Animal和Dog。Animal是父类，Dog是子类。在父类Animal中，我们定义了name和age两个属性，以及eat()方法。在子类Dog中，我们加入了breed属性，并定义了bark()方法。由于Dog类继承了Animal类，所以Dog类中也可以使用name和age属性，以及eat()方法，而且可以通过bark()方法实现新的功能。

什么是多态

多态是Java中面向对象编程的又一重要概念，它允许我们在不同的对象上执行同一操作，从而实现更高的灵活性和可维护性。在Java中，多态包括两种类型：编译时多态（也称为静态多态）和运行时多态（也称为动态多态）。

编译时多态是指通过方法的重载实现多态机制，也就是在同一个类中定义多个同名方法，但它们的参数列表不同。这样在调用这些同名方法时，根据传入的参数的类型和数量，编译器会自动匹配并选择相应的方法去执行。

运行时多态则是通过方法的覆盖实现多态机制，也就是在子类中重写父类中的某个方法，当调用这个方法时，根据对象的实际类型，动态地选择相应的方法去执行。

示例

public class Shape {
    public void draw() {
        System.out.println("I'm a shape.");
    }
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("I'm a circle.");
    }
}

public class Square extends Shape {
    @Override
    public void draw() {
        System.out.println("I'm a square.");
    }
}

public class Client {
    public static void main(String[] args) {
        Shape s1 = new Circle();
        Shape s2 = new Square();
        s1.draw(); // 输出 "I'm a circle."
        s2.draw(); // 输出 "I'm a square."
    }
}

在上面的示例中，我们定义了三个类：Shape、Circle和Square，并且让Circle和Square分别继承了Shape。在Shape类中，我们定义了draw()方法，表示绘制图形的操作。在Circle和Square类中，我们分别重写了draw()方法，实现了不同的绘图操作。在Client类中，我们定义了两个Shape类型的变量s1和s2，并分别赋值为Circle和Square对象。由于这两个对象的实际类型（即Circle和Square）不同，所以在调用s1.draw()和s2.draw()方法时，动态地选择了不同的方法去执行。这就是Java中的运行时多态。