Java进阶封装、继承、多态、抽象
一、封装（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("年龄必须为正数");
}
}
public void displayInfo() {
System.out.println("姓名：" + name + "，年龄：" + age);
}
}
public class Main {
public static void main(String[] args) {
Person person = new Person("张三", 25);
person.setAge(-5); // 设置无效年龄，输出错误信息
person.displayInfo(); // 输出：姓名：张三，年龄：25
}
}
二、继承（Inheritance）
概念
继承是面向对象编程中的一种机制，它允许一个类（子类）继承另一个类（父类）的属性和方法。通过继承，子类可以复用父类的代码，并可以在子类中添加新的属性和方法，或重写父类的方法。
优点
- 代码复用：子类可以复用父类的属性和方法，减少重复代码。
- 易于扩展：可以在子类中添加新的属性和方法，或重写父类的方法，以实现代码的扩展。
- 提高可维护性：通过继承，可以将通用功能抽取到父类中，集中管理和维护，提高代码的可维护性。
示例代码
class Animal {
public void makeSound() {
System.out.println("Some generic animal sound");
}
}
class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Bark");
}
}
class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("Meow");
}
}
public class Main {
public static void main(String[] args) {
Animal myDog = new Dog();
Animal myCat = new Cat();
myDog.makeSound(); // 输出：Bark
myCat.makeSound(); // 输出：Meow
}
}
三、多态（Polymorphism）
概念
多态是面向对象编程的一个重要特性，它允许对象以多种形式出现。多态主要通过方法重载（Overloading）和方法重写（Overriding）实现。通过多态，父类引用可以指向子类对象，并调用子类重写的方法。
优点
- 接口重用：通过多态，可以使用统一的接口来操作不同类型的对象，提高代码的重用性。
- 灵活性：通过多态，可以在运行时决定调用哪个子类的重写方法，提高代码的灵活性和扩展性。
- 提高可维护性：通过多态，可以将通用功能抽取到父类中，实现代码的集中管理和维护，提高代码的可维护性。
示例代码
interface Shape {
double area();
}
class Circle implements Shape {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
@Override
public double area() {
return Math.PI * radius * radius;
}
}
class Rectangle implements Shape {
private double length;
private double width;
public Rectangle(double length, double width) {
this.length = length;
this.width = width;
}
@Override
public double area() {
return length * width;
}
}
public class Main {
public static void main(String[] args) {
Shape myCircle = new Circle(5.0);
Shape myRectangle = new Rectangle(4.0, 6.0);
System.out.println("Circle area: " + myCircle.area()); // 输出：Circle area: 78.53981633974483
System.out.println("Rectangle area: " + myRectangle.area()); // 输出：Rectangle area: 24.0
}
}
四、抽象（Abstraction）
概念
抽象是面向对象编程的基本特性之一，它通过抽象类和接口来实现。抽象类是不能实例化的类，它可以包含抽象方法和具体方法。接口是一种纯抽象的类，所有方法都是抽象的，接口定义了类应该具有的方法，而不实现这些方法。
优点
- 代码重用：通过抽象类，可以将通用功能抽取到父类中，提高代码的重用性。
- 接口隔离：通过接口，可以定义类应该具有的方法，实现接口隔离，提高代码的灵活性和扩展性。
- 提高可维护性：通过抽象类和接口，可以将通用功能和具体实现分离，实现代码的集中管理和维护，提高代码的可维护性。
示例代码
abstract class Vehicle {
abstract void start();
}
class Car extends Vehicle {
@Override
void start() {
System.out.println("Car is starting");
}
}
class Bike extends Vehicle {
@Override
void start() {
System.out.println("Bike is starting");
}
}
interface Flyable {
void fly();
}
class Airplane implements Flyable {
@Override
public void fly() {
System.out.println("Airplane is flying");
}
}
public class Main {
public static void main(String[] args) {
Vehicle myCar = new Car();
Vehicle myBike = new Bike();
myCar.start(); // 输出：Car is starting
myBike.start(); // 输出：Bike is starting
Flyable myAirplane = new Airplane();
myAirplane.fly(); // 输出：Airplane is flying
}
}
总结
封装、继承、多态和抽象是面向对象编程的四大基本特性，通过学习和实践这些特性，可以更好地设计和实现面向对象的程序，提高代码的质量、可维护性和可扩展性。在实际开发中，合理运用这些特性，可以编写出更高效、灵活和健壮的代码。
