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关系，即一个类中包含另一个类的对象。组合是一种强耦合关系，体现了严格的部分和整体的关系，部分和整体的生命周期一样。
- 例子1
// 组件类：轮子
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(); // 调用汽车对象的方法，汽车对象内部会调用轮子对象的方法
}
}
- 更经典的例子，可以体现继承和组合结合的范例
// 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
}
}
觉得有用的点赞：）
嘿嘿嘿
