不看后悔之Java入门篇：探秘面向对象编程之魂——封装、继承与多态的深度剖析

引言

“掌握三大特性，洞悉Java面向对象设计精髓”
面向对象编程（OOP）是现代软件开发的核心理念之一。在Java世界里，封装、继承和多态构成了这一强大范式的基石，让开发者能够以更符合现实世界模型的方式构建复杂系统。本篇博客将深入浅出地介绍这三大特性及其在实际编程中的应用。

---

一、封装（Encapsulation）

1. 封装的概念

封装是隐藏对象内部实现细节，并通过公共接口对外提供访问的一种机制。在Java中，我们通过类来封装数据（属性）和对这些数据的操作（方法）。

public class Car {
    private String brand; // 私有变量，外部无法直接访问
    private int year;

    public void setBrand(String brand) { // 提供设置品牌的方法
        this.brand = brand;
    }

    public String getBrand() { // 提供获取品牌的方法
        return this.brand;
    }
}

2. 封装的优势

• 数据保护：私有成员变量确保了数据的安全性。
• 代码清晰：通过公有的getter和setter方法明确控制数据的读取和修改。
• 易维护：可以随时改变内部实现而不影响客户端代码。

二、继承（Inheritance）

1. 继承的概念

继承是一种允许子类（派生类）从父类（基类）继承状态和行为的机制，从而减少重复代码并支持层次化结构的设计。

public class SportsCar extends Car {
    private boolean convertible;

    public boolean isConvertible() {
        return convertible;
    }

    public void setConvertible(boolean convertible) {
        this.convertible = convertible;
    }
}

在这个例子中，SportsCar 类继承自 Car 类，因此自动获得了 Car 的所有属性和方法，并在此基础上添加了自身的特色属性 convertible。

2. 继承的特点

• 代码复用：子类可以直接使用父类定义的功能。
• 扩展功能：子类可以通过重写（Override）父类的方法或添加新的方法来扩展功能。
• 类型兼容性：一个子类的对象可以被当作其父类类型的变量引用。

三、多态（Polymorphism）

1. 多态的含义

多态意味着同一个接口可以有不同的实现方式，或者同一种行为可以在不同的上下文中表现出不同的形式。主要体现在：

• 方法重写（Runtime Polymorphism）：子类可以覆盖父类的方法，使得调用该方法时表现不同行为。
• 接口实现（Static Polymorphism）：类可以通过实现多个接口，实现相同的接口方法但具有不同的实现内容。

2. 多态的应用

public interface Animal {
    void makeSound();
}

public class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

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

// 示例
public static void main(String[] args) {
    Animal myPet1 = new Dog(); 
    Animal myPet2 = new Cat();

    myPet1.makeSound(); // 输出 "Woof!"
    myPet2.makeSound(); // 输出 "Meow!"
}

在这个示例中，尽管myPet1 和 myPet2 被声明为 Animal 类型，但因为实现了多态，它们可以根据具体实例调用各自对应的方法。

四、思考

1.子类如何调用父类的方法？

在Java中，子类可以通过以下两种方式调用父类的方法：

1. 隐式调用：
   当子类没有覆盖父类的某个方法时，子类对象在调用该方法时，会自动调用父类中的同名方法。例如：

   class Parent {
       public void display() {
           System.out.println("Parent's display method");
       }
   }
   
   class Child extends Parent {
       // 子类未定义display方法
   }
   
   public class Main {
       public static void main(String[] args) {
           Child child = new Child();
           child.display();  // 这里会调用父类Parent的display方法
       }
   }
   

2. 显式调用：
   如果子类重写了父类的方法，并且需要在子类中调用被覆盖前的父类方法，可以使用super关键字显式调用父类的方法。

   class Parent {
       public void display() {
           System.out.println("Parent's display method");
       }
   }
   
   class Child extends Parent {
       @Override
       public void display() {
           super.display(); // 显式调用父类的display方法
           System.out.println("Child's additional processing");
       }
   }
   
   public class Main {
       public static void main(String[] args) {
           Child child = new Child();
           child.display();  // 首先执行父类的display方法，然后执行子类的附加逻辑
       }
   }
   

在上述代码示例中，当子类Child通过super.display()调用display方法时，它明确指定了调用的是父类Parent的display方法。如果子类没有提供与父类同名的方法，则默认情况下就是隐式地调用了父类的方法。

2.如果一个类调用子类的某个重写父类的方法，那是调用子类的还是父类的?

在Java中，如果一个类实例化的是子类对象，并且子类重写了父类的方法，那么调用该方法时会执行子类重写后的方法。

例如：

public class Parent {
    public void display() {
        System.out.println("Parent's display method");
    }
}

public class Child extends Parent {
    @Override
    public void display() {
        System.out.println("Child's display method");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建Child类的对象，但实际上赋值给Parent类型的引用
        Parent parentRef = new Child();

        // 调用display方法
        parentRef.display();
        
        // 输出结果将是："Child's display method"
    }
}

在这个例子中，尽管我们通过Parent类型的引用parentRef来调用display()方法，但由于实际指向的对象是Child类的实例，因此执行的是子类Child中重写后的display()方法。这就是Java面向对象编程中的多态特性。

3.如果子类和父类都有构造方法，执行流程会是什么样的?

在Java中，当创建一个子类对象时，如果子类和父类都有构造方法，那么构造方法的执行流程遵循以下规则：

1. 先执行父类构造方法：

   • 创建子类对象时，首先会调用父类的构造方法来初始化父类的部分。如果子类没有显式调用父类的构造方法（即使用super()），编译器会自动插入一个对父类无参数构造方法的调用。
   • 如果父类没有无参数构造方法，且子类没有显式调用任何父类构造方法，则编译错误。此时必须在子类构造方法中通过super(...)形式明确调用父类的一个构造方法。

2. 然后执行子类构造方法：

   • 在父类构造方法执行完毕后，开始执行子类自身的构造方法，用于初始化子类特有的属性或执行特定逻辑。

例如：

public class Parent {
    public Parent() {
        System.out.println("Parent constructor");
    }
}

public class Child extends Parent {
    public Child() {
        super(); // 这句可以省略，因为编译器会默认添加
        System.out.println("Child constructor");
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
    }
}

运行上述代码，输出顺序如下：

Parent constructor
Child constructor

这说明在实例化子类Child对象时，先执行了父类Parent的构造方法，接着执行了子类Child自己的构造方法。

小结

面向对象的三大特性——封装、继承和多态，共同构建了Java语言强大的面向对象编程体系。理解并熟练运用它们，不仅能帮助你编写出更具组织性和可扩展性的代码，更能让你在解决实际问题时游刃有余，成为驾驭Java技术的高手。随着实践的积累，你会发现这些特性贯穿于整个软件开发生命周期，极大地提升了程序设计的艺术性与实用性。