javaSE基础-多态基础认识

经典体现多态代码语句：Fu fu = new Zi();
多态的体现：
父类的引用指向了自己的子类对象
父类的引用也可以接受自己的子类对象
多态的前提：
必须是类与类之间有关系，要么继承，要么实现
存在覆盖
多态的好处：
多态的出现大大的提高程序的扩展性
弊端：
提高了扩展性，但是只能使用父类的引用访问父类中的成员
多态中成员函数（非静态）的特点：
编译时期：参阅引用型变量所属的类中是否有调用的方法，有则编译成功，否则编译失败
运行时期：参阅对象所属的类中是否有调用的方法
简单总结：Fu fu = new Zi();成员函数在多态调用时，编译看左边，运行看右边

示例代码：

abstract class Animal{
    abstract void eat();
}

class Cat extends Animal{
    public void eat(){
        System.out.println("吃鱼");
    }
    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal{
    public void eat(){
        System.out.println("啃骨头");
    }
    public void hanjiao(){
        System.out.println("旺旺");
    }
}

class Pig extends Animal{
    public void eat(){
        System.out.println("吃食");
    }
    public void gong(){
        System.out.println("拱地");
    }
}

public class Duotai{
    public static void main(String[] args) {
        Cat cat = new Cat();
        function(cat);
        Dog dog = new Dog();
        function(dog);
        Pig pig = new Pig();
        function(pig);
        /**父类的引用指向了自己的子类对象
         * 	父类的引用也可以接受自己的子类对象
         * */
        Animal ani = new Cat(); //类型提升（向上转型）
        ani.eat();
    }
    /**多态方式*/
    public static void function(Animal ani){
    	ani.eat();
    }
    
    /**因为Animal ani = new Cat(); 所以下边的方法可以被上边的function()替代*/
//    public static void function(Cat cat){
//    	cat.eat();
//    }
//
//    public static void function(Dog dog){
//    	dog.eat();
//    }
//    
//    public static void function(Pig pig){
//    	pig.eat();
//    }
}
}

面试点：多态中，成员变量的特点
无论编译和运行，都参考左边 （引用型变量所属的类）
静态成员函数的特点：
无论编译和运行，都参考左边

package com.zy.jczyw.testcase;

class Fu{
   int num = 5;
   void method1() {
	   System.out.println("fu_method_1");
   }
   void method2() {
	   System.out.println("fu_method_2");
   }
   
   static void method4() {
	   System.out.println("fu_method_4");
   }
}

class Zi extends Fu{
	int num = 8;
	void method1() {
		System.out.println("zi_method_1");
	}
	void method3() {
		System.out.println("zi_method_3");
	}
	static void method4() {
	   System.out.println("zi_method_4");
   }
}
public class Duotai{
    public static void main(String[] args) {
    	Zi z = new Zi();
    	z.method1(); //打印 zi_method_1
    	z.method2(); //打印 fu_method_2
    	z.method3(); //打印 zi_method_3
    	
    	Fu f = new Zi();
    	f.method1(); //打印 zi_method_1  子类复写了method1()
    	f.method2(); //打印 fu_method_2
    	//没有f.method3()  因为编译时虚拟机未产生对象 new Zi(); 所以只有左边Fu类的方法 
    	
    	System.out.println(f.num); //5
    	System.out.println(z.num); //8
    	
    	f.method4(); //打印 fu_method_4
    	z.method4(); //打印 fu_method_5
    }
}

public class demo {

    public static void main(String[] args) {
//        A a = new B();
//        a.test();
//        a.testAOnly();
//        System.out.println(a.i);

        B b = new B();
//        System.out.println(b.i);  //子类拥对父类的私有变量具有拥有权 但是不具有使用权。debugger时b对象拥有i属性
    }

}

class A{

    private int i = 1;

    {
        System.out.println("A类代码块");
    }

    static {
        System.out.println("A类静态方法");
    }

    public A(){
        System.out.println("A类无参构造方法");
    }

    public void test(){
        System.out.println("A类test方法");
    }

    public void testAOnly(){
        System.out.println("A类testAOnly方法");
    }
}

class B extends A{

    {
        System.out.println("B类代码块");
    }

    static {
        System.out.println("B类静态方法");
    }

    public B(){
        System.out.println("B类无参构造方法");
    }

    public void testBOnly(){
        System.out.println("B类testBOnly方法");
    }

}

/**
A类静态方法
B类静态方法
A类代码块
A类无参构造方法
B类代码块
B类无参构造方法
*/

这篇文章讲的很好，可以参考一下https://www.cnblogs.com/chenssy/p/3372798.html

class A {
    public String show(D obj) {
        return ("A类传入D对象");
    }

    public String show(A obj) {
        return ("A类传入A对象");
    }

}

class B extends A{
    public String show(B obj){
        return ("B类传入B对象");
    }

    public String show(A obj){
        return ("B类传入A对象");
    }
}

class C extends B{

}

class D extends B{

}

public class demo {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();

        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));
    }
}

作者： chenssy
出处： http://www.cnblogs.com/chenssy/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。