封装、继承、多态的理解

前言

在介绍之前，先把后续案例中经常出现的权限修饰符总结一下：

在Java中，权限修饰符用于控制类、方法和变量的访问级别。

常用权限修饰符有以下几种：

public：公共访问修饰符，可以被任何类、方法和变量访问。

private：私有访问修饰符，只能被当前类内部的方法和变量访问。

protected：受保护的访问修饰符，只能被当前类内部的方法和变量、子类及同一包内的其他类访问。

default（默认）：当没有声明任何访问修饰符时，使用默认访问修饰符，只能被同一包内的其他类访问。

面向对象三大特性

1、封装

可以将封装理解成是一种保护数据的机制，它隐藏了内部成员的状态，将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问，提高了数据的安全性和代码复用率。

案例分析：

假设我们有一个名为Person的类，它包含姓名和年龄两个成员变量。

如果直接让外界访问这些成员变量，则可能出现数据安全性问题。为此，我们应该使用private修饰符将这些成员变量标记为私有，通过设置公共方法提供外界对它们的间接访问。

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) { // 构造方法
        this.name = name;
        this.age = age;
    }

    public String getName() { // 访问name属性
        return this.name;
    }

    public void setName(String name) { // 修改name属性
        this.name = name;
    }

    public int getAge() { // 访问age属性
        return this.age;
    }

    public void setAge(int age) { // 修改age属性
        this.age = age;
    }
}

在上述代码中，我们将name和age成员变量都标记为私有。外部方法只能使用内部提供的get和set方法访问它们。

public class Test {
    public static void main(String[] args) {
        Person p = new Person("Tom", 18);
        System.out.println(p.getName() + " is " + p.getAge() + " years old.");
        p.setAge(20); // 修改年龄为20
        System.out.println(p.getName() + " is " + p.getAge() + " years old.");
    }
}

2、继承

继承是类与类之间的关系，指的是子类可以从父类继承属性和方法的能力。可以使得子类具有父类的非私有特征，也可以在子类中重写方法，以及追加属性和特有方法。

继承关系通过 extends 关键字进行声明，不支持多继承，但支持多层继承。意思是一个类不能同时继承多个类，但这个类所继承的类又可以继承另一个类，是儿子-爸爸-爷爷之间的关系。

案例分析：

假设现在有一个名为动物类Animal，它定义了动物的共同属性和方法

public class Animal {
    protected String name; // 动物的名称
    
    public Animal(String name) { // 构造方法
        this.name = name;
    }
    
    public void move() { // 移动方法
        System.out.println(this.name + " is moving.");
    }
}

我们可以根据需求创建一个具体动物类，例如狗类Dog。

这时候我们只需要声明一个Dog类，然后使用extends关键字指定它的父类为Animal，这样它就拥有了动物类Animal的属性和方法。

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    public void bark() {
        System.out.println(this.name + " is barking.");
    }
}

在上述代码中，我们使用了super关键字调用父类的构造方法，并且新增了一个bark（叫）方法。现在，Dog类已经成为Animal类的子类，并且可以使用Animal类的方法和属性。我们可以创建一个Dog对象并调用它的move()方法，从而观察是否继承了Animal类的方法。

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog("Jack");
        dog.move(); // 调用父类中的move方法
        dog.bark();
    }
}

3、多态

多态指的是子类可以具备父类相同的特性，但每个子类在不同情况下，可以表现出不同的行为。

多态的存在有以下前提：

（1）要有继承或实现关系

（2）要有方法的重写

（3）要有父类引用指向子类对象

案例分析：

还是动物类，定义了动物的属性和方法，现在我们需要根据不同的动物，实现不同的行为。

public class Animal {
    private String name;
    private int age;

    public Animal() {    //无参构造
    }

    public Animal(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) {
        this.age = age;
    }

    public void eat() {    //成员方法
        System.out.println("动物吃东西");
    }
}

创建一个猫类，继承动物类，并且重写父类中的eat方法

public class Cat extends Animal {

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {    //方法重写，猫吃鱼
        System.out.println("猫吃鱼");
    }
}

再创建一个狗类，同样继承动物类，重写父类中的方法

public class Dog extends Animal {

    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

测试类

public class AnimalDemo {
    public static void main(String[] args) {
        //创建猫类对象进行测试
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();

        a = new Cat("加菲", 5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();
    }
}