【JAVA 基础 第（10）课】面向对象三大特征（封装、继承、多态）

目录

封装示例

继承示例

多态示例

---

封装示例

 class Student {
    //private 只能在 Student 类内部访问
    private String name;
    private int age;

     public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
            this.age = age;
    }
}

public class EncapsulationExample {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("王城");
        student.setAge(20);
        System.out.println("姓名: " + student.getName() + ", 年龄: " + student.getAge());
    }
}

• Student类将 name 和 age 属性声明为 private（私有），外部类不能直接访问这些属性。
• 通过提供 getName、setName、getAge、setAge 等公有的方法（也就是对外的接口）来间接操作这些私有属性，这样可以对属性的访问和修改进行控制，体现了封装特性。

继承示例

// 定义父类，动物类
class Animal {
    public void eat() {
        System.out.println("动物吃饭");
    }
}

// 定义子类；狗继承动物类
class Dog extends Animal {
    public void wangwangwang() {
        System.out.println("汪汪汪");
    }
}

public class Test{
    public static void main(String[] args) {
        Dog dog= new Dog ();
        dog.eat();  
        dog.wangwangwang(); 

        // 多态，父类引用指向子类对象
        Animal animal = new Cat();  
        animal.eat();  

    }
}

• Dog类通过 extends 关键字继承了 Animal 类，这样  Dog 类就自动拥有了 Animal 类中的 eat 方法，体现了代码复用的继承特性。
• 同时 Dog 类还可以定义自己特有的  wangwangwang 方法，来丰富自身的行为。

多态示例

// 定义形状抽象类
abstract class Shape {
    // 抽象方法，计算面积，由具体的子类去实现
    public abstract double getArea();
}

// 定义圆形类，实现形状抽象类
class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

// 定义矩形类，实现形状抽象类
class Rectangle implements Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    @Override
    public double getArea() {
        return width * height;
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Shape shape1 = new Circle(3.0);
        Shape shape2 = new Rectangle(4.0, 5.0);

        System.out.println("圆形面积: " + shape1.getArea());
        System.out.println("矩形面积: " + shape2.getArea());

        // 可以将不同形状的对象放入数组统一处理
        Shape[] shapes = new Shape[2];
        shapes[0] = shape1;
        shapes[1] = shape2;
        for (Shape shape : shapes) {
            System.out.println("形状面积: " + shape.getArea());
        }
    }
}

• 首先定义了抽象类 Shape，有抽象方法 getArea，然后 Circle 类和 Rectangle 类都实现了 Shape 类，并各自按照自己的规则重写了 getArea 方法。
• 在 main 方法中，可以用 Shape 类型的变量去引用 Circle 或 Rectangle 的对象，当调用 getArea 方法时，会根据对象的实际类型（是 Circle 还是 Rectangle）来执行相应的重写后的 getArea 方法，体现了多态性。这种特性使得代码在处理不同类型但具有相同行为抽象（这里都是计算面积）的对象时更加灵活和方便，比如可以方便地将不同形状对象放入一个数组统一处理等。