20200721-Encapsulación y herencia orientadas a objetos

20200721-Encapsulación y herencia orientadas a objetos

1. Notas de clase

Encapsulación: proteger una salida para su uso
Paquete: modificador de acceso
público: público
protegido: usado cuando las subclases heredan; privado a nivel de paquete + modificador predeterminado de subclase: privado a nivel de paquete;
privado es visible en el paquete donde se encuentra la clase actual : Privado; visible solo para ti

static: al modificar atributos: un espacio de almacenamiento para todas las clases
Atributos comunes: un espacio de almacenamiento para un objeto
Al modificar métodos: puede llamar a través del nombre de la clase nombre del método ()
Los métodos normales pueden llamar directamente a métodos estáticos y a los métodos normales los métodos
estáticos no pueden llamar directamente a common Propiedades y propiedades
estáticas Bloque de código estático: se ejecuta solo una vez cuando se accede a la clase por primera vez, y solo una vez.
No se pueden usar ni este ni super. El
estático no puede definir variables locales y las variables estáticas deben ser variables miembro

Herencia
Uno de los medios importantes para implementar la reutilización de código en Java durante la herencia. Java solo admite la herencia de raíz única, es decir, una clase solo puede tener una clase principal directa

Herencia: la palabra clave extiende subclase hereda toda la clase principal, y las cosas privadas de la clase principal también se heredan, pero cuando la subclase crea un objeto, primero ejecutará el método de construcción de la clase principal y luego ejecutará el método de construcción de la subclase

Segundo, el código

Categoría de padres: mascota

public class Pet {
    
    
    private String name;
    private int health;
    private  int love;
    int a;
    //除了我包以外，除非继承我才能看到
    protected  int b;

    //如果没有无参构造，继承会直接报错
    public Pet() {
    
    
        System.out.println("父类无参构造");
    }

    public Pet(String name, int health, int love) {
    
    
        System.out.println("父类有参构造");
        this.name = name;
        setHealth(health);
        setLove(love);
    }

    public String getName() {
    
    
        return name;
    }

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

    public int getHealth() {
    
    

        return health;
    }

    public void setHealth(int health) {
    
    

        if(health<0 || health>100) {
    
    
            System.out.println("健康值的范围在0~100之间");
            System.out.println("赋的值不满足，强行赋默认值60");
            health = 60;
        }
        this.health = health;
        System.out.println("健康值是："+health);
    }

    public int getLove() {
    
    
        return love;
    }

    public void setLove(int love) {
    
    
        if(love<0 || love>100) {
    
    
            System.out.println("爱心值的范围在0~100之间");
            System.out.println("赋的值不满足，强行赋默认值60");
            love = 60;
        }
        this.love = love;
        System.out.println("爱心值是："+love);
    }

    public void show(){
    
    
        System.out.println("宠物的自白");
        System.out.println("我叫"+getName()+"，健康值是："+getHealth()
                +"，和主人的亲密度"+getLove());
    }
}

Subcategoría: gato

public class Cat extends Pet{
    
    
    public Cat() {
    
    

        System.out.println("子类无参构造");
    }

    public Cat(String name, int health, int love) {
    
    
        super(name,health,love);//super关键字指代父类对象，私有类一样除外
        //这里直接有参构造，但是没有逻辑
        System.out.println("子类有参构造");
    }

    public void show(){
    
    
        super.show();
    }
}

Categoría de prueba: gato

public class TestCat {
    
    
    public static void main(String[] args) {
    
    
        /*//无参构造方法也都是继承过来的，父类是object
        Cat c = new Cat();
        c.setName("加菲");
        c.setHealth(123);
        c.setLove(45);
        c.show();
        Pet p=new Pet("miaomiao",12312,123);
        c.show();*/
        //走父类的无参构造，目的，用来构建对象，创建对象的功能是从object拿过来的
        Cat cat=new Cat("miaomiao",90,70);
        cat.show();
    }
}