JAVA封装，继承，多态详解

Java的三大特性为封装，继承，多态。

封装

       封装是 JAVA 面向对象的特点的表现，封装是一种信息隐蔽技术。它有两个含义：即把对象的全部属性和全部服务结合在一起，形成一个不可分割的独立单位；以及尽可能隐藏对象的内部结构。也就是说，如果我们使用了封装技术的话，别人就只能用我们做出来的东西而看不见我们做的这个东西的内部结构了。

package pojo.demo01;

public abstract class Pet {
    private String name;//名字
    private int health; //健康值
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getHealth() {
        return health;
    }
    public void setHealth(int health) {
        this.health = health;
    }

    //吃东西的方法
    public abstract void eat();
}

以下提供get(),set()方法和eat()吃东西方法，外部类去调用时只知道方法并不知道内部怎么实现的。

继承

         继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

 示例

package pojo.demo01;

public class Dog extends Pet{
    //重写父类的吃东西的方法
    public  void eat(){
        //健康值加15
        System.out.println("狗狗");
        System.out.println("健康值为："+this.getHealth());
        this.setHealth(this.getHealth()+15);
        System.out.println("汪汪汪~骨头不错哦,健康值+15");
        System.out.println("吃完健康值为："+this.getHealth());
    };
}

代码中Dog类继承了上面Pet类，具有了Pet宠物类中的get()和set()方法，并且子类继承之后还可以重写父类的方法。

多态

       所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

Pet a = dog
Pet b = cat
Pet c = pig
        这里所表现的的就是多态。dog、cat、pig都是pet的子类，我们只是通过酒这一个父类就能够引用不同的子类，这就是多态——我们只有在运行的时候(喝的时候)才会知道引用变量所指向的具体实例对象。所以多态能让子类对象调用同一个父类传参方法而不需要写每个子类都写一个具体的父类方法。多态就是: 同一个引用类型，使用不同的实例而执行不同操作。

package pojo.demo01;

public class Lady {
    private String name;//名字
    public String getName() {
        return name;
    }

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

    //构造方法
    public Lady(String name) {
        this.name = name;
    }

    //养宠物的方法
    //以父类作为方法的参数,实现多态
    public void feed(Pet pet){

        pet.eat();
    }
}

package pojo.demo01;

public abstract class Pet {
    private String name;//名字
    private int health; //健康值
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getHealth() {
        return health;
    }
    public void setHealth(int health) {
        this.health = health;
    }

    //吃东西的方法
    public abstract void eat();
}

     

import pojo.demo01.Cat;
import pojo.demo01.Dog;
import pojo.demo01.Lady;

public class Demo01 {
    public static void main(String[] args) {
        //创建一个小主人
        Lady l1 = new Lady("lily");
        //创建两个宠物,属于小主人的宠物
        Dog d = new Dog();
        d.setName("大黄");
        d.setHealth(60);

        Cat c = new Cat();
        c.setName("蓝猫");
        c.setHealth(50);

        //小主人喂养小狗
        l1.feed(d);

        //小主人喂养小猫
        l1.feed(c);

    }
}

多态也可以分为向上转型和向下转型，根据具体的需要来转变状态，装为父对象可以作为形参直接调用父类中的方法，并把自己作为参数，JVM会根据实参来确定调用的子类方法，如果需要调用子类特有的private私有属性和方法，需要强制转型成子类对象，实参与某子类对象不符时不能强制转型，需要用instanceof方法来判断是类型是否一致在强制转型。

public class TestInstanceof {
    public static void main(String[] args) {
        //向上转型
        Pet p = new Dog();
        //向下转型
        Cat c = (Cat)p;//p的实参为Dog类，不能转成Cat()类。
    }
}

借助instanceof来实现向下转型。

public class TestInstanceof {
    public static void main(String[] args) {
        //向上转型
        Pet p = new Dog();
        //判断p是否是Dog类型
        if(p instanceof Dog){
            //如果是,我们就能转换
            Dog d = (Dog)p;
        }else if(p instanceof Cat){
            //向下转型
            Cat c = (Cat)p;
        }
    }
}