Java面向对象编程（封装/继承/多态）实例解析

什么是面向对象编程？

面向对象编程（Object-oriented Programming）简称 OOP，是一种将现实世界中的事物抽象成为计算机程序中的对象的编程思想，它强调类、对象、封装、继承、多态等概念，使得程序易于维护、扩展和重用。

在Java中，面向对象编程是一种很重要的编程范式，Java的基础类库（Java API）就是以面向对象的方式构建的。

封装

封装是指将对象的属性（数据）和行为（方法）封装在一个类中，并对外提供公共的访问方式。这样可以保证类内部的数据不被外部直接访问和修改，只能通过类内部提供的接口来访问和修改。

封装的优点有：

1. 隐藏了实现细节，使得对象的内部状态对于外部不可见。
2. 提高了代码复用性和维护性，对象内部的修改不会影响到外部代码。
3. 提高了代码的安全性，防止了外部错误修改对象的内部状态。

下面是一个封装的示例：

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

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

    public String getName() {
        return this.name;
    }

    public void setAge(int age) {
        if(age < 0 || age > 100) {
            throw new IllegalArgumentException("Invalid age");
        }
        this.age = age;
    }

    public int getAge() {
        return this.age;
    }
}

在这个示例中，我们创建了一个Person类，它有两个私有属性name和age，通过public的setter和getter方法来访问和修改这些属性。由于属性是私有的，所以只能通过公共的接口来访问和修改属性。这样就保证了Person类外部不能直接访问和修改它的属性，从而提高了代码的安全性和可维护性。

继承

继承是指子类继承父类的属性和方法，从而可以对父类的属性和方法进行扩展和修改。子类可以直接使用父类中的属性和方法，而不需要重新编写代码。

继承的优点有：

1. 提高了代码的重用性，减少了重复编写的代码。
2. 简化了代码的维护，所有的公共属性和方法都在父类中定义，方便修改和扩展。
3. 增加了代码的灵活性和可扩展性，子类可以根据自己的需要对父类进行扩展和修改。

下面是一个继承的示例：

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

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

public class Cat extends Animal {
    public void meow() {
        System.out.println("Cat is meowing");
    }
}

在这个示例中，我们创建了一个Animal类，它有一个eat()方法。然后创建了一个Dog类和一个Cat类，它们都继承自Animal类，并分别添加了自己的bark()和meow()方法。由于Dog和Cat类都是Animal类的子类，所以它们都可以使用Animal类中定义的eat()方法，而不需要重新编写代码。这样就提高了代码的重用性和可扩展性。

多态

多态是指同一种类型的对象，在不同的情况下，表现出不同的行为和状态。在Java中，多态经常和继承一起使用，通过子类对父类的方法进行重载和重写，实现多态的效果。

多态的优点有：

1. 提高了代码的灵活性和可扩展性，可以根据不同的需求使用不同的子类对象来处理。
2. 降低了代码的耦合性，父类可以定义通用的方法，子类可以根据需要对方法进行重载和重写。

下面是一个多态的示例：

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

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

public class Square extends Shape {
    public void draw() {
        System.out.println("Drawing a square");
    }
}

public class Test {
    public static void main(String[] args) {
        Shape s = new Circle();
        s.draw();

        s = new Square();
        s.draw();
    }
}

在这个示例中，我们创建了一个Shape类和两个子类Circle和Square，它们都重写了Shape类中的draw()方法。然后在Test类中，我们创建了一个Shape类型的对象s，并使用它来调用不同的draw()方法。由于Circle和Square都是Shape类的子类，所以它们可以被赋值给Shape类型的变量s。通过这种方式，我们可以根据不同的需求使用不同的子类对象来处理，实现了多态的效果。