Java基础--- 封装、继承、多态、抽象

在 Java 中，封装、继承、多态和抽象是面向对象编程（OOP）的四个基本特性。以下是对每个特性的解释和代码示例：

1. 封装 (Encapsulation)

封装是将对象的状态（属性）和行为（方法）组合在一起，并限制对某些组件的访问。通过使用访问修饰符（如 private、protected 和 public）来控制访问。

示例代码：

class Person {
    private String name; // 私有属性

    // 公有构造器
    public Person(String name) {
        this.name = name;
    }

    // 公有方法用于获取属性
    public String getName() {
        return name;
    }

    // 公有方法用于设置属性
    public void setName(String name) {
        this.name = name;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice");
        System.out.println(person.getName()); // 输出: Alice
        person.setName("Bob");
        System.out.println(person.getName()); // 输出: Bob
    }
}

2. 继承 (Inheritance)

继承是一个类可以继承另一个类的属性和方法。子类可以扩展或重写父类的功能。

示例代码：

class Animal {
    public void speak() {
        System.out.println("Animal speaks");
    }
}

// Dog 类继承 Animal 类
class Dog extends Animal {
    @Override
    public void speak() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.speak(); // 输出: Dog barks
    }
}

3. 多态 (Polymorphism)

多态是指同一个方法调用可以根据对象的不同而表现出不同的行为。主要通过方法重载（同一类中）和方法重写（子类中）实现。

示例代码：

class Animal {
    public void speak() {
        System.out.println("Animal speaks");
    }
}

class Cat extends Animal {
    @Override
    public void speak() {
        System.out.println("Cat meows");
    }
}

class Dog extends Animal {
    @Override
    public void speak() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal;

        myAnimal = new Cat();
        myAnimal.speak(); // 输出: Cat meows

        myAnimal = new Dog();
        myAnimal.speak(); // 输出: Dog barks
    }
}

4. 抽象 (Abstraction)

抽象是指只关注对象的外部特征而忽略内部细节。可以通过抽象类和接口来实现。

示例代码：

abstract class Shape {
    abstract void draw(); // 抽象方法，没有实现
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a Circle");
    }
}

class Square extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a Square");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape1 = new Circle();
        Shape shape2 = new Square();

        shape1.draw(); // 输出: Drawing a Circle
        shape2.draw(); // 输出: Drawing a Square
    }
}

总结

• 封装：通过访问修饰符保护对象的状态。
• 继承：允许一个类获取另一个类的属性和方法。
• 多态：同一操作作用于不同对象时，表现出不同的行为。
• 抽象：只暴露必要的特征，隐藏不必要的实现细节。

这些特性使得 Java 成为一种强大的面向对象编程语言，能够提高代码的可重用性、可维护性和可扩展性。