Java的面向对象编程概念：封装、继承、多态和抽象
个人名片
🎓作者简介：java领域优质创作者
🌐个人主页：码农阿豪
📞工作室：新空间代码工作室（提供各种软件服务）
💌个人邮箱：[2435024119@qq.com]
📱个人微信：15279484656
🌐个人导航网站：www.forff.top
💡座右铭：总有人要赢。为什么不能是我呢？
- 专栏导航：
码农阿豪系列专栏导航
面试专栏：收集了java相关高频面试题，面试实战总结🍻🎉🖥️
Spring5系列专栏：整理了Spring5重要知识点与实战演练，有案例可直接使用🚀🔧💻
Redis专栏：Redis从零到一学习分享，经验总结，案例实战💐📝💡
全栈系列专栏：海纳百川有容乃大，可能你想要的东西里面都有🤸🌱🚀
目录
- Java的面向对象编程概念：封装、继承、多态和抽象
- 封装（Encapsulation）
- 继承（Inheritance）
- 多态（Polymorphism）
- 抽象（Abstraction）
- 封装、继承、多态和抽象的综合应用
Java的面向对象编程概念：封装、继承、多态和抽象
Java是一种面向对象的编程语言，强调使用对象和类来组织代码。面向对象编程（OOP）的四大基本原则是封装、继承、多态和抽象。下面将详细解释这四个概念，并提供相应的代码示例。
封装（Encapsulation）
封装是指将对象的属性和行为（即方法）包装在一个单独的单元（类）中，并通过访问控制来保护对象的内部状态。封装的主要目的是隐藏对象的内部实现细节，只暴露必要的接口给外部使用者。
代码示例：
public class Person { private String name; private int age; // 构造方法 public Person(String name, int age) { this.name = name; this.age = age; } // 获取姓名 public String getName() { return name; } // 设置姓名 public void setName(String name) { this.name = name; } // 获取年龄 public int getAge() { return age; } // 设置年龄 public void setAge(int age) { if (age > 0) { this.age = age; } else { System.out.println("年龄必须大于0"); } } // 显示个人信息 public void displayInfo() { System.out.println("姓名: " + name + ", 年龄: " + age); } }在上述代码中，name和age是Person类的私有属性，不能直接从类的外部访问。通过提供公共的getter和setter方法，可以控制对这些属性的访问和修改。这样可以保护对象的内部状态，防止不合理的修改。
继承（Inheritance）
继承是指一个类（子类）继承另一个类（父类）的属性和方法。通过继承，子类可以复用父类的代码，并扩展或修改父类的行为。继承实现了代码的重用和扩展，是面向对象编程的重要特性之一。
代码示例：
// 父类 public class Animal { protected String name; // 构造方法 public Animal(String name) { this.name = name; } // 发出声音 public void makeSound() { System.out.println("动物发出声音"); } // 显示信息 public void displayInfo() { System.out.println("动物的名字是: " + name); } } // 子类 public class Dog extends Animal { private String breed; // 构造方法 public Dog(String name, String breed) { super(name); // 调用父类的构造方法 this.breed = breed; } // 重写父类的方法 @Override public void makeSound() { System.out.println("狗叫：汪汪"); } // 显示信息 @Override public void displayInfo() { super.displayInfo(); // 调用父类的方法 System.out.println("狗的品种是: " + breed); } } public class TestInheritance { public static void main(String[] args) { Dog dog = new Dog("Buddy", "Golden Retriever"); dog.makeSound(); dog.displayInfo(); } }在上述代码中，Dog类继承了Animal类，并重写了makeSound和displayInfo方法。通过继承，Dog类可以复用Animal类的代码，并在此基础上增加自己的行为。
多态（Polymorphism）
多态是指同一个方法在不同对象中具有不同的实现。多态分为编译时多态（方法重载）和运行时多态（方法重写）。多态允许对象以多种形式出现，是面向对象编程的核心特性之一。
代码示例：
// 父类 public class Shape { public void draw() { System.out.println("绘制形状"); } } // 子类 public class Circle extends Shape { @Override public void draw() { System.out.println("绘制圆形"); } } public class Rectangle extends Shape { @Override public void draw() { System.out.println("绘制矩形"); } } public class TestPolymorphism { public static void main(String[] args) { Shape shape1 = new Circle(); Shape shape2 = new Rectangle(); shape1.draw(); // 调用Circle的draw方法 shape2.draw(); // 调用Rectangle的draw方法 } }在上述代码中，Circle和Rectangle类继承自Shape类，并重写了draw方法。通过多态，Shape类型的引用可以指向不同的子类对象，并调用对应子类的draw方法。
抽象（Abstraction）
抽象是指将对象的复杂实现细节隐藏起来，只暴露出简单的接口。抽象类和接口是Java中实现抽象的两种主要方式。抽象类是不能被实例化的类，通常包含抽象方法（没有方法体的方法），具体子类必须实现这些抽象方法。接口是一种更高级的抽象，规定了一组方法，但不包含任何实现。
抽象类示例：
// 抽象类 public abstract class Animal { protected String name; public Animal(String name) { this.name = name; } // 抽象方法 public abstract void makeSound(); // 普通方法 public void displayInfo() { System.out.println("动物的名字是: " + name); } } // 具体子类 public class Cat extends Animal { public Cat(String name) { super(name); } @Override public void makeSound() { System.out.println("猫叫：喵喵"); } } public class TestAbstraction { public static void main(String[] args) { Cat cat = new Cat("Kitty"); cat.makeSound(); cat.displayInfo(); } }在上述代码中，Animal是一个抽象类，包含一个抽象方法makeSound。Cat类继承Animal类，并实现了makeSound方法。
接口示例：
// 接口 public interface Vehicle { void start(); void stop(); } // 具体实现类 public class Car implements Vehicle { @Override public void start() { System.out.println("汽车启动"); } @Override public void stop() { System.out.println("汽车停止"); } } public class Bike implements Vehicle { @Override public void start() { System.out.println("自行车启动"); } @Override public void stop() { System.out.println("自行车停止"); } } public class TestInterface { public static void main(String[] args) { Vehicle car = new Car(); Vehicle bike = new Bike(); car.start(); car.stop(); bike.start(); bike.stop(); } }在上述代码中，Vehicle是一个接口，定义了start和stop方法。Car和Bike类实现了Vehicle接口，并提供了具体的实现。
封装、继承、多态和抽象的综合应用
在实际开发中，封装、继承、多态和抽象通常会结合使用，以实现复杂系统的设计。以下是一个综合应用的示例：
代码示例：
// 抽象类 public abstract class Employee { protected String name; protected double salary; public Employee(String name, double salary) { this.name = name; this.salary = salary; } public abstract void work(); public void displayInfo() { System.out.println("姓名: " + name + ", 薪水: " + salary); } } // 具体子类 public class Manager extends Employee { private double bonus; public Manager(String name, double salary, double bonus) { super(name, salary); this.bonus = bonus; } @Override public void work() { System.out.println("经理正在管理团队"); } @Override public void displayInfo() { super.displayInfo(); System.out.println("奖金: " + bonus); } } public class Developer extends Employee { private String programmingLanguage; public Developer(String name, double salary, String programmingLanguage) { super(name, salary); this.programmingLanguage = programmingLanguage; } @Override public void work() { System.out.println("开发人员正在编写代码"); } @Override public void displayInfo() { super.displayInfo(); System.out.println("编程语言: " + programmingLanguage); } } 结论 Java的封装、继承、多态和抽象是面向对象编程的四大基本原则，它们帮助我们编写可维护、可扩展和可重用的代码。通过封装，我们可以保护对象的内部状态；通过继承，我们可以实现代码重用；通过多态，我们可以灵活地调用不同对象的方法；通过抽象，我们可以隐藏复杂的实现细节，只暴露必要的接口。这些原则共同协作，使得Java成为一种强大而灵活的编程语言。
