博客

Java之封装、继承、多态的概念

  • Post category:Java

Java 是一种面向对象的编程语言，其中封装、继承和多态是面向对象编程的三个基本概念。下面从这三个方面详细讲解。

封装

封装指的是将对象的状态或行为视为私有数据，并通过提供公共方法来保证外部代码不能直接访问和修改内部数据。封装的目的是为了保护类的数据，防止外部代码对其进行不当的修改。

举个例子，我们有一个表示用户的类 UserInfo，其中包含用户的姓名、身份证号码、年龄等信息。我们可以通过 private 关键字将属性设为私有，防止外部代码直接修改它们，而是通过公共的 get/set 方法来访问和修改数据。下面是示例代码：

public class UserInfo {
    private String name;
    private String idCard;
    private int age;

    public UserInfo(String name, String idCard, int age) {
        this.name = name;
        this.idCard = idCard;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public String getIdCard() {
        return idCard;
    }

    public void setIdCard(String idCard) {
        this.idCard = idCard;
    }

    public int getAge() {
        return age;
    }

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

在上面的代码中，属性 name、idCard 和 age 都被声明为 private，而对应的 get/set 方法是公共的，这样外部代码就只能通过这些方法来访问和修改数据，而不能直接修改属性值。

继承

继承指的是一个类可以派生出另一个类，从而继承了父类的属性和方法。子类可以在继承的基础上增加新的属性和方法，也可以重写父类的方法来改变其行为。

举个例子，我们有一个表示动物的类 Animal，其中包含方法 eat() 和 sleep()。我们可以通过 extends 关键字来派生出一个表示猫的类 Cat，在 Cat 类中然后扩展新的方法和属性。下面是示例代码：

public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }

    public void sleep() {
        System.out.println("Animal is sleeping");
    }
}

public class Cat extends Animal {
    public void meow() {
        System.out.println("Cat is meowing");
    }

    @Override
    public void sleep() {
        System.out.println("Cat is sleeping");
    }
}

在上面的代码中，Cat 类继承自 Animal 类，因此它也拥有了 eat() 和 sleep() 这两个方法。同时，Cat 类也添加了一个新的方法 meow()，以及重写了父类的 sleep() 方法。这样，我们就可以通过 Cat 类创建出新的对象，并调用它自身的方法和从父类继承来的方法。比如：

Cat cat = new Cat();
cat.eat();  // 输出 "Animal is eating"
cat.sleep(); // 输出 "Cat is sleeping"
cat.meow();  // 输出 "Cat is meowing"

多态

多态指的是不同的对象可以使用相同的方法，并根据实际对象的类型来执行不同的行为。在 Java 中，多态实现的基础就是继承和方法的重写。

举个例子，我们假设有一个表示图形的类 Shape，其中有个方法 calculateArea() 用于计算图形的面积。我们可以创建一个用于表示矩形的子类 Rectangle 和 用于表示圆形的子类 Circle，它们都重写了 calculateArea() 方法。下面是示例代码：

public class Shape {
    public double calculateArea() {
        return 0;
    }
}

public class Rectangle extends Shape {
    private double length;
    private double width;

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

    @Override
    public double calculateArea() {
        return length * width;
    }
}

public class Circle extends Shape {
    private double radius;

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

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

在上面的代码中，我们创建了一个表示图形的类 Shape，以及两个子类 Rectangle 和 Circle，它们都继承自 Shape 类，并重写了 calculateArea() 方法。这样，我们就可以通过多态来使用相同的方法了。比如：

Shape shape1 = new Rectangle(10, 5);
System.out.println("矩形面积为：" + shape1.calculateArea());

Shape shape2 = new Circle(5);
System.out.println("圆形面积为：" + shape2.calculateArea());

在上面的代码中，我们创建了一个 Shape 对象 shape1 和一个 Shape 对象 shape2，但是它们分别指向了一个 Rectangle 对象和一个 Circle 对象。由于这两个子类都重写了 calculateArea() 方法，并根据实际对象的类型来执行不同的行为，shape1.calculateArea() 输出的是矩形的面积，而 shape2.calculateArea() 输出的是圆形的面积。这就是多态的应用。

Tags: