java面向对象之封装-抽象-继承-组合-多态五种概念一网打尽

曾经在学习java面向对象时，你是否会为面向对象的封装-继承-抽象-多态-组合等各种概念搞得稀里糊涂，乃至反复阅读，背诵其相关概念，结果一段时间过后又还给了时间。。。
这种经历简直令人发指，让人无法忍受，难道就没有哪个地方能把它一次说清楚，老百姓看了以后纷纷醍醐灌顶，不再重蹈覆辙？？？答案就在本文，请各位耐心观看，也可无脑收藏，用时瞟一眼再次醍醐灌顶即可。

先引用一句祖师爷《java编程思想》的教诲：
有一条通用准则：使用继承表达行为的差异，使用组合表达状态的变化。
当你不知道该用继承还是组合的时候可以参考这句话。

封装是指将对象的属性和行为（即数据和方法）结合在一个独立的单元中，并隐藏对象的内部细节，只对外提供公共的访问方式。封装有助于保护对象内部的数据不被外部随意访问和修改，同时提高了代码的安全性和可维护性。

public class Person {  
    // 私有属性，封装了人的姓名和年龄  
    private String name;  
    private int age;  
  
    // 公共的构造方法，用于创建Person对象并初始化属性  
    public Person(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
  
    // 公共的getter方法，用于获取私有属性的值  
    public String getName() {  
        return name;  
    }  
  
    // 公共的setter方法，用于设置私有属性的值  
    public void setAge(int age) {  
        this.age = age;  
    }  
  
    // 公有的方法，描述人的行为  
    public void introduce() {  
        System.out.println("My name is " + name + " and I am " + age + " years old.");  
    }  
}  
  
public class Main {  
    public static void main(String[] args) {  
        Person person = new Person("Alice", 25);  
        person.introduce(); // 输出：My name is Alice and I am 25 years old.  
        // person.name = "Bob"; // 错误！不能直接访问私有属性  
        // System.out.println(person.name); // 错误！不能直接访问私有属性  
        person.setAge(26);  
        person.introduce(); // 输出：My name is Alice and I am 26 years old.  
    }  
}

抽象是指只展示对象的必要信息，而隐藏不必要的细节。在Java中，抽象类是一种不能被实例化的类，它通常包含抽象方法（没有实现的方法），这些抽象方法由子类来具体实现。抽象类和抽象方法主要用于定义接口和实现多态。

// 抽象类：动物
abstract class Animal {
    // 抽象方法，没有具体实现
    abstract void makeSound();
}

class Dog extends Animal {
    // 实现父类的抽象方法  
    @Override
    void makeSound() {
        System.out.println("The dog barks");
    }
}

// 子类：猫，实现动物的抽象方法  
class Cat extends Animal {
    // 实现父类的抽象方法  
    @Override
    void makeSound() {
        System.out.println("The cat meows");
    }
}

public class AbstractClassTest {
    public static void main(String[] args) {
        Animal myDog = new Dog(); // 多态：Animal引用指向Dog对象
        myDog.makeSound();
        Animal myCat = new Cat(); // 多态：Animal引用指向Cat对象
        myCat.makeSound();
    }
}

继承是指一个类（子类）可以继承另一个类（父类）的属性和方法，并可以添加或覆盖父类的属性和方法。继承允许我们创建分等级层次的类，减少了代码冗余，提高了代码的可重用性。
继承使得代码可以重用，同时能体现类与类之间的is-a关系

// 父类：动物  
class Animal {  
    void makeSound() {  
        System.out.println("The animal makes a sound");  
    }  
}  
  
// 子类：狗，继承自动物  
class Dog extends Animal {  
    // 覆盖父类的方法  
    @Override  
    void makeSound() {  
        System.out.println("The dog barks");  
    }  
  
    void wagTail() {  
        System.out.println("The dog wags its tail");  
    }  
}  
  
public class Main {  
    public static void main(String[] args) {  
        Dog dog = new Dog();  
        dog.makeSound(); // 输出：The dog barks  
        dog.wagTail(); // 输出：The dog wags its tail  
    }  
}

组合是将多个对象组合到一起，形成一个新的对象。组合体现的是has-a关系，即一个类中包含另一个类的对象。组合是一种强耦合关系，体现了严格的部分和整体的关系，部分和整体的生命周期一样。

// 组件类：轮子  
class Wheel {  
    void rotate() {  
        System.out.println("The wheel is rotating");  
    }  
}  
  
// 组合类：汽车，包含轮子对象  
class Car {  
    private Wheel wheel;  
  
    public Car() {  
        this.wheel = new Wheel();  
    }  
  
    void move() {  
        System.out.println("The car is moving");  
        wheel.rotate();  // 调用轮子对象的方法  
    }  
}  
  
public class Main {  
    public static void main(String[] args) {  
        Car car = new Car();  
        car.move();  // 调用汽车对象的方法，汽车对象内部会调用轮子对象的方法  
    }  
}

1. 更经典的例子，可以体现继承和组合结合的范例

// polymorphism/Transmogrify.java
// Dynamically changing the behavior of an object
// via composition (the "State" design pattern)
class Actor {
    public void act() {}
}

class HappyActor extends Actor {
    @Override
    public void act() {
        System.out.println("HappyActor");
    }
}

class SadActor extends Actor {
    @Override
    public void act() {
        System.out.println("SadActor");
    }
}

class Stage {
    private Actor actor = new HappyActor();
    
    public void change() {
        actor = new SadActor();
    }
    
    public void performPlay() {
        actor.act();
    }
}

public class Transmogrify {
    public static void main(String[] args) {
        Stage stage = new Stage();
        stage.performPlay();
        stage.change();
        stage.performPlay();
    }
}

输出：

HappyActor
SadActor

多态（Polymorphism）是面向对象编程的四大基本特性之一，其他三个是封装（Encapsulation）、继承（Inheritance）和抽象（Abstraction）。多态字面上理解就是“多种形态”，在Java中，多态指的是允许一个接口或父类引用指向其子类对象，并且在运行时能够自动调用实际指向对象的子类方法。

简单来说，多态就是同一个方法调用可以有不同的实现方式，具体实现取决于运行时对象的实际类型。Java通过方法重写（Override）和向上转型（Upcasting）来实现多态。

// 动物类，定义了一个makeSound方法  
class Animal {  
    void makeSound() {  
        System.out.println("The animal makes a sound");  
    }  
}  
  
// 狗类，继承自动物类并重写了makeSound方法  
class Dog extends Animal {  
    @Override  
    void makeSound() {  
        System.out.println("The dog barks");  
    }  
}  
  
// 测试类  
public class TestPolymorphism {  
    public static void main(String[] args) {  
        // 向上转型，父类引用指向子类对象  
        Animal animal = new Dog();  
          
        // 调用makeSound方法，实际执行的是Dog类的makeSound方法  
        animal.makeSound(); // 输出：The dog barks  
          
        // 如果我们有一个Animal类型的数组，我们也可以将不同类型的Animal对象加入其中  
        Animal[] animals = new Animal[2];  
        animals[0] = new Dog();  
        animals[1] = new Animal();  
          
        // 遍历数组并调用makeSound方法，每个对象会根据其实际类型调用相应的方法  
        for (Animal a : animals) {  
            a.makeSound();  
        }  
        // 输出：  
        // The dog barks  
        // The animal makes a sound  
    }  
}

觉得有用的点赞：）