Java面向对象（封装，static,继承）

Java有三大特性：封装、继承、多态。

今天作者将下封装和继承。

封装顾名思义就是将一段代码装起来，类似于装进一个盒子，并留出一个出口来方便使用。

这样做的好处就是能够是我们的属性在赋值时能够更加规范化，同时在我们进行操作时免除不必要的判断，因为我们的判断已经写

到setter方法里面了。

步骤一：新建实体类，并生成属性。

    private int a;
    private int b;
    private String c;

步骤二：创建setter/getter方法。

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public int getB() {
        return b;
    }

    public void setB(int b) {
        this.b = b;
    }

    public String getC() {
        return c;
    }

    public void setC(String c) {
        this.c = c;
    }

注：此时如果我们要对数据进行操作的一般都写在setter方法里面。

如：

    public int getB() {
        return b;
    }

    public void setB(int b) {
        this.b = b;
        if (b>0){
            System.out.println(b+"大于0");
        }
    }

我们将判断写在这里，就可以减少在方法调用中的判断，更为方便。

这里我们就产生了不同的访问修饰符带来的不同访问权限的问题。

Java中共有4中访问修饰符，他们是：public private protected 默认访问修饰符

     public     公共的：全工程可见
     protected  子类继承的时候使用；包及私有+子类可见

     private       私有的：只有自己可见
     默认       当前类所在的包中可见及私有可见

 

继承是Java中另一特性，继承即子类可以继承父类的属性和方法

继承关键字 extends 子类可以继承父类的所有

我们先写一个父类：

public class Pet {
    private String name;
    private int health;
    private int love;

    public Pet() {
    }

    public Pet(String name, int health, int 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) {
            health = 60;
            System.out.println("健康值应该在0~100之间，默认60");
        }
        this.health = health;
    }

    public int getLove() {
        return love;
    }

    public void setLove(int love) {
        if (love < 0 || love > 100) {
            System.out.println("亲密度应该在0~100之间，默认60");
            love = 60;
        }
        this.love = love;
    }
    public  void show(){
        System.out.println("宠物的自白：");
        System.out.println("我叫"+name+",健康值是："+health+"，和主人的亲密度："+
                love);
    }

我们定义一个Pet的宠物父类，其中我们有姓名，亲密度，健康值的属性

此时我们定义一个Bird类取继承Pet类

public class Bird extends Pet {

    public Bird(){
    }

    public Bird(String name, int health, int love) {
    }

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

}

在未赋值的情况下依旧能够调用父类里面的方法：输出结果

宠物的自白：
我叫null,健康值是：0，和主人的亲密度：0

此外在继承中有其他一些机制如：

    父类私有的东西也继承了，只是看不到
    子类创建对象时，会先执行父类的无参构造方法，
    在执行子类的无参构造方法。
    如果要在子类调用父类有参构造方法用super(...);

这里我们就要谈到静态 static

     父类中的私有变量或者方法通过static 进行定义如：

    private static String name;
    private static int health;
    private static int love;

此时子类虽然继承了父类的属性，但是我们用不了这个属性，你在调用的时候也看不到这个属性的内容。