Java封装继承多态的理解

一、封装

封装是面向对象编程中的重要概念之一，它使得对象的属性与行为被保护在对象内部，只能通过对象提供的接口来访问。

Java中实现封装的方式是使用访问控制修饰符：public、private、protected以及default。其中，public修饰的属性和方法可以被任意访问，private修饰的属性和方法只能被本类访问，protected修饰的属性和方法可以被本类以及子类访问，default修饰的属性和方法只能被同一个包中的类访问。

public class Test {
    private String name;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return this.name;
    }
}

在上面的例子中，我们使用private修饰了Test类的name属性，使用public修饰了setName和getName方法，通过setName和getName方法来设置和获取对象的name属性，隔离了对象内部属性与外部访问的细节，实现了封装。

二、继承

继承是面向对象编程中的另一个重要概念，它允许我们创建一个新的类，作为若干个已有类的衍生版本，重新定义这些类的属性和方法，使得这些新类具备了原有类的功能，同时还能够附加上自己的特殊功能。

在Java中，可以使用extends关键字来继承一个已有的类。实现继承需要注意以下几点：

• 子类可以访问父类中的public和protected属性和方法，但是不能访问父类的private属性和方法。
• Java不支持多重继承，即一个类不能同时继承多个类。
• Java中所有的类都继承自Object类，在Java中，如果一个类没有显式地继承其他类，那么这个类就是继承了Object类。

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

public class Dog extends Animal {
    public void bark() {
        System.out.println("Dog barking..");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // Animal eating..
        dog.bark(); // Dog barking..
    }
}

在上面的例子中，我们定义了一个基类Animal和一个子类Dog，Dog继承了Animal的属性和方法，在Test类中创建了Dog对象，调用eat方法和bark方法。

三、多态

多态是面向对象编程中的又一个重要概念，它允许一个对象变量引用不同的实现，即同一个对象在不同时刻有不同的外部表现形式。

在Java中，实现多态的方式有两种：方法重载和方法覆盖。

方法重载是指在一个类中定义多个具有相同名称但参数不同的方法，通过参数类型和个数的不同来进行区分。

public class Test {
    public void print(String s) {
        System.out.println("print String: " + s);
    }
    
    public void print(int i) {
        System.out.println("print int: " + i);
    }
    
    public void print(double d) {
        System.out.println("print double: " + d);
    }
    
    public static void main(String[] args) {
        Test t = new Test();
        t.print("Hello"); // print String: Hello
        t.print(123); // print int: 123
        t.print(3.14); // print double: 3.14
    }
}

在上面的例子中，我们定义了三个重载的print方法，分别接收String、int和double类型的参数。在main方法中，我们通过传递不同类型的参数来调用不同的方法，实现了方法重载的多态。

方法覆盖是指子类定义了一个与父类具有相同名称、形参列表和返回值类型的方法，通过不同的实现来覆盖父类的方法实现。

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

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

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.eat(); // Dog eating bones..
    }
}

在上面的例子中，我们定义了一个基类Animal和一个子类Dog，Dog覆盖了Animal的eat方法，在Test类中创建了一个Animal对象，但是指向了Dog的实例，调用eat方法，输出Dog eating bones..。