Java多态理解

class Father
{
    String father = "father";
    public void show(){
            System.out.println("Father is show()");
    }
    public void show1(){
            System.out.println("Father  show1111()");
    }
}
class Son extends Father
{
    String father = "son";
    String son = "子类特有的";
    //重写了父类方法
    public void show(){
            System.out.println("Son is show()");
    }
    //重载父类的方法，但对于父类，是一个新增加的功能
    public void show(int i){
        System.out.println("Son is show() again");
    }
}
//    测试多态性
class ExtendsDemo
{
    public static void main(String []args){
            
        Father f = new Father();//
        Father s = new Son();//创建一个父类引用指向子类对象
        Son son = new Son();//
        f.show();//父亲访问自己的方法
        s.show();//由于父类引用指向了子类对象，子类又对父类的show()方法进行了重写，故访问子类的方法
        //s.show(1);//show(int i)由于是子类新增加的功能，父类并不知道，所以不能调用，会编译不过
        s.show1();//子类并没有重写父类show1()方法，故会去调用父类的方法show1()
        System.out.println("Father f :"+f.father);//调用父类属性
        System.out.println("Father s :"+s.father);//调用父类属性
         System.out.println("Father s:"+f.son);//为子类Son新增加的属性，父类不能调用，编译不过
    }
}
/*运行结果：
        Father is show()
        Son is show()
        Father  show1111()
        Father f :father
        Father s :father
*/
    
/*
    多态的三个必要条件：
         1.继承   2.重写   3.父类引用指向子类对象。
    总结：
    
        一、使用父类类型的引用指向子类的对象；

        二、该引用只能调用父类中已经定义的方法和变量；

        三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用） 
                动态绑定是指”在执行期间（而非编译期间）“判断所引用对象的实际类型，根据实际的类型调用其相应的方法。

        四、变量不会被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在调用时，还是会调用父类的变量
        
*/

 　　接口中的多态：

　　　　

interface Inter
{
        public void show();
        String inter = "inter";
}
class ClassA implements Inter
{
        public void show(){
            System.out.println("ClassA is show() ");
        }
        public void run(){
            System.out.println("Class A running ,,,");
        }
        String inter = "classA";
        String classA = "aaaaa";
}
class ClassB extends ClassA
{
        
    public void show(){
        System.out.println("ClassB is show()");
    }
    String inter = "bbbbb";
}
public class InterfaceDemo 
{
    
    public static void main(String[] args){

        Inter interA = new ClassA();
        Inter interB = new ClassB();

        interA.show();
        interB.show();
        //interA.run();//报错，访问不到实现类新增加的方法;
        System.out.println(interA.inter);
        System.out.println(interB.inter);
        //System.out.println(interA.classA);//报错，访问不到实现类新增加的成员变量;
    }
}
/*
    运行结果：
        ClassA is show()
        ClassB is show()
        inter
        inter
*/