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

说明

曾经在学习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中,抽象类是一种不能被实例化的类,它通常包含抽象方法(没有实现的方法),这些抽象方法由子类来具体实现。抽象类和抽象方法主要用于定义接口和实现多态。

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关系

java 复制代码
// 父类:动物  
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关系,即一个类中包含另一个类的对象。组合是一种强耦合关系,体现了严格的部分和整体的关系,部分和整体的生命周期一样。

  1. 例子1
java 复制代码
// 组件类:轮子  
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. 更经典的例子,可以体现继承和组合结合的范例
java 复制代码
// 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();
    }
}

输出:

bash 复制代码
HappyActor
SadActor

多态

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

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

java 复制代码
// 动物类,定义了一个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  
    }  
}

觉得有用的点赞:)

嘿嘿嘿