20200721-面向对象封装与继承

20200721-面向对象封装与继承

一、课堂笔记

封装：保护开一个出口以供使用
包：访问修饰符
public： 公共的
protected: 子类继承的时候使用 ；包级私有+子类默认修饰符 ：包级私有；当前类所在的包中可见
private：私有的；只有自己可见

static：修饰属性时：全类公用一个存储空间
普通属性：一个对象一个存储空间
修饰方法时：可以通过类名.方法名()调用
普通方法可以直接调用静态方法和普通方法
静态方法不能直接调用普通属性和静态属性
静态代码块：只在第一次访问该类时执行一次，且只执行一次
不能使用this和super、
静态不能定义局部变量，静态变量必须是成员变量

继承
继承时java中实现代码重用的重要手段之一。Java中只支持单根继承，即一个类只能有一个直接父类

继承：关键字extends 子类继承父类所有，父类私有的东西也继承了，只是看不到子类创建对象时，会先执行父类的构造方法，再执行子类的构造方法

二、代码

父类：宠物

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());
    }
}

子类：猫

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();
    }
}

测试类：猫

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();
    }
}