java面向对象特性（封装、继承、多态、抽象）

面向对象特性（封装、继承、多态、抽象）

一、封装

1. 定义

封装是指将对象的属性和行为（方法）捆绑在一起，并对外部隐藏对象的具体实现细节，仅提供一些公共的方法来访问和操作这些属性。简单来说，就是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。

2. 优点

• 数据安全性：可以防止外部代码随意访问和修改对象的内部数据，避免因不合理的操作导致数据的不一致性或错误。
• 可维护性：封装使得代码结构更加清晰，当内部实现发生变化时，只要对外接口不变，就不会影响到使用该对象的其他代码。

3. 示例代码

class Person {
    // 私有属性，外部无法直接访问
    private String name;
    private int age;

    // 公共的访问方法（getter）
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // 公共的修改方法（setter）
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        if (age >= 0) {
            this.age = age;
        } else {
            System.out.println("年龄不能为负数");
        }
    }
}

public class EncapsulationExample {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("张三");
        person.setAge(20);
        System.out.println(person.getName() + " 年龄是 " + person.getAge());
    }
}

二、继承

1. 定义

继承是指一个类（子类、派生类）可以继承另一个类（父类、基类）的属性和方法，从而实现代码的复用和扩展。子类可以拥有父类的所有非私有成员，并且可以在此基础上添加自己的新成员或重写父类的方法。

2. 优点

• 代码复用：避免了重复编写相同的代码，提高了开发效率。
• 可扩展性：子类可以在父类的基础上进行功能的扩展，使得代码更具灵活性。

3. 示例代码

// 父类
class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " 正在吃东西");
    }
}

// 子类
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    public void bark() {
        System.out.println(name + " 正在汪汪叫");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Dog dog = new Dog("旺财");
        dog.eat();
        dog.bark();
    }
}

三、多态

1. 定义

多态是指同一个方法调用可以根据对象的不同类型而表现出不同的行为。多态的实现需要满足三个条件：继承、方法重写和父类引用指向子类对象。

2. 优点

• 可替换性：可以在不修改原有代码的情况下，替换不同的子类对象，增强了代码的灵活性和可维护性。
• 可扩展性：可以方便地添加新的子类，而不会影响到原有代码的运行。

3. 示例代码

// 父类
class Shape {
    public void draw() {
        System.out.println("绘制图形");
    }
}

// 子类
class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Shape circle = new Circle();
        Shape rectangle = new Rectangle();

        circle.draw();
        rectangle.draw();
    }
}

四、抽象

1. 定义

抽象是指从具体的事物中提取出共同的特征和行为，形成一个抽象的概念。在Java中，抽象通过抽象类和抽象方法来实现。抽象类是一种不能被实例化的类，它可以包含抽象方法和具体方法；抽象方法是一种没有具体实现的方法，需要子类来实现。

2. 优点

• 提高代码的可维护性和可扩展性：抽象类和抽象方法为子类提供了一个统一的接口和规范，使得子类可以专注于具体的实现细节。
• 代码复用：抽象类可以包含一些通用的方法，这些方法可以被子类继承和复用。

3. 示例代码

// 抽象类
abstract class Vehicle {
    // 抽象方法
    public abstract void start();

    // 具体方法
    public void stop() {
        System.out.println("车辆停止");
    }
}

// 子类
class Car extends Vehicle {
    @Override
    public void start() {
        System.out.println("汽车启动");
    }
}

public class AbstractionExample {
    public static void main(String[] args) {
        Car car = new Car();
        car.start();
        car.stop();
    }
}

综上所述，封装、继承、多态和抽象是面向对象编程的四大核心特性，它们相互配合，使得代码更加安全、可维护、可扩展和可复用。