java封装继承多态代码(java封装继承多态的理解)

封装

封装是Java中面向对象特性的一个重要概念，指的是隐藏对象的属性和方法，只对外部提供访问接口，避免了外部直接访问对象内部数据，从而保证了对象数据的安全性和完整性。

在Java中实现封装的方式是通过访问修饰符来限制属性和方法的访问范围，常用的访问修饰符有public、private、protected和默认访问。

例如：

public class Person {
    private String name;
    private int age;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    public int getAge() {
        return age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("张三");
        person.setAge(18);
        
        System.out.println(person.getName());
        System.out.println(person.getAge());
    }
}

在上面的代码中，Person类中的name和age属性被声明为private，只能通过公共的setName、getName、setAge和getAge方法来进行操作，从而保证了对象数据的安全性。

继承

继承是面向对象编程中的一种重要特性，可以使得子类从父类中继承属性和方法，避免了重复的定义和实现，提高了代码的可复用性和可维护性。

在Java中，我们可以通过extends关键字来实现继承。例如：

public class Animal {
    private String name;
    private int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void eat() {
        System.out.println(name + "正在吃东西");
    }
}

public class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age); // 调用父类的构造方法进行属性初始化
    }
    
    public void wang() {
        System.out.println("汪汪汪");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("旺财", 3);
        dog.eat();
        dog.wang();
    }
}

在上面的代码中，Dog类继承了Animal类，从而拥有了Animal类的属性和方法，同时在Dog类中定义了自己的wang()方法。通过继承可以减少代码的冗余，提高代码的复用度。

多态

多态是面向对象编程中一个重要的概念，指的是同一类型的对象在不同的状态下表现出不同的行为。在Java中，多态包括方法的重载和方法的覆盖两种形式。

方法的重载指的是在同一个类中定义多个方法，它们的方法名相同但参数类型或参数个数不同，编译器会根据参数的类型和个数自动选择相适应的方法。例如：

public class Main {
    public void print(int a) {
        System.out.println("输入的整数为：" + a);
    }
    
    public void print(double b) {
        System.out.println("输入的浮点数为：" + b);
    }
    
    public static void main(String[] args) {
        Main main = new Main();
        main.print(1);
        main.print(1.0);
    }
}

在上面的代码中，由于参数类型不同，print()方法会根据参数的类型自动选择调用相应的方法，从而实现了方法的重载。

方法的覆盖指的是子类重写父类的方法，从而使得同一类型的对象在不同的状态下表现出不同的行为。例如：

public class Animal {
    public void eat() {
        System.out.println("动物正在吃东西");
    }
}

public class Dog extends Animal {
    public void eat() {
        System.out.println("狗正在啃骨头");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();
        animal.eat();
        dog.eat();
    }
}

在上面的代码中，由于Dog类重写了Animal类的eat()方法，所以通过同一类型的对象Dog和Animal调用eat()方法时表现出不同的行为。这就是多态的表现。