简述Java封装与多态

本人小白一枚，欢迎大家一起讨论学习，如有错误，还望大家指教。

封装：是指隐藏对象的属性和实现细节，仅对外提供公有的访问方式。
好处：

• 将变化隔离
• 便于使用
• 提高重用性
• 提高安全性

封装原则：
1、将不需要对外提供的内容隐藏起来。
2、把属性都隐藏，提供公有方法对其访问。
多态
封装、继承、多态是面向对象的三大特征。
多态就是指同一行为，具有不同的表现形式。
多态在代码中的体现就是：父类引用指向子类对象，父类的引用也可以指向本类对象。
父类名称 对象 = new 子类名称();
接口名称 对象 = new 实现类名称();
要想实现多态，必须类与类之间有继承，要么是实现。
多态的好处：多态的出现大大的提高了程序的扩展性。
多态的弊端：只能使用父类的引用访问父类中的成员。
多态中成员函数的特点：
在编译时期，参阅引用型变量所属的类是否有调用的方法，如果有，编译通过，如果没有，编译失败。
在运行时期，参阅对象所属的类是否有调用的方法。
总结：成员函数在多态调用时，编译看左边，运行看右边。
多态中成员变量的特点：（在程序编写中，是不可能遇到的，一般会出现在面试题中）
无论是编译还是运行，都参考左边（引用型变量所属的类）

public class Demo {
    public static void main(String[] args) {
        Fu fu = new Zi();
        Zi zi = new Zi();
        fu.method();
        System.out.println(fu.num);
        System.out.println(zi.num);
    }
}

abstract class Fu {
    int num = 5;
    public abstract void method();
}

class Zi extends Fu {
    int num = 8;

    @Override
    public void method() {
        System.out.println("Zi类中的方法");
    }
}

打印结果：

多态中静态成员函数的特点：（通常出现在面试题中）
静态方法可以使用方法名调用，但这种方法不推荐。
无论在编译和运行中，都参考在左边

public class StaticDemo {
    public static void main(String[] args) {
        Fu fu1 = new Fu();
        fu1.method();
        Fu fu2 = new Zi();
        fu2.method();
        Zi zi1 = new Zi();
        zi1.method();
    }
}

class Fu {
    public static void method() {
        System.out.println("Fu中的方法");
    }
}

class Zi extends Fu {
    public static void method() {
        System.out.println("Zi中的方法");
    }
}

引用类型转换
多态的转型分为向上转型与向下转型两种：
向上转型：多态本身是子类类型向父类类型转换的过程，这个过程是默认的。
当父类引用指向一个子类对象时，便是向上转型。

父类类型  变量名  = new  子类类型(); 

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

子类类型  变量名  = (子类类型)父类变量名;

为什么要转型
当使用多态调用方法时，首先先检查父类中是否有该方法，如果没有，编译失败。也就是说，不能调用子类拥有，而父类没有拥有的方法，编译无法通过。所以，想要调用子类特有的方法时，必须做向下转型。

public class Test {
    public static void main(String[] args) {
        //向上转型
        Animal animal = new Cat();
        animal.eat();

        //向下转型
        Cat cat = (Cat)animal;
        cat.catchMouse();

        //会报出类型转换异常（ClassCastException）
        Dog dog = (Dog)animal;
    }
}

abstract class Animal {
    abstract void eat();
}

class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("吃鱼");
    }

    public void catchMouse() {
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("吃骨头");
    }

    public void watchHouse() {
        System.out.println("看家");
    }
}

打印结果

针对于上面这种情况，Java提供了instanceof关键字给引用变量做类型校验。
如果变量属于该类型，返回true。如果变量不属于该数据类型，返回false。所以我们在转换之前，可以做一个判断，以避免发生该异常发生。

if （animal  instanceof Cat） {
     Cat  c =  (Cat)animal;
     c.catchMouse();
} else if (animal instanceof Dog) {
    Dog d = (Dog)animal;
    d.watchHouse();
}