java学习笔记之—多态



一、父类引用指向子类对象：

父类引用指向子类对象时，注意以下几点：
1、实例化一个没有名字的子类对象，然后向上转型为父类的父类的引用，先去调用子类重写的方法，子类没有重写就再去调用父类的方法。
2、只能调用父类中定义过的方法和变量（父类中没有定义过调用的时候要报错）
3、专属于子类的成员变量，在子类方法中被访问时，这时候通过父类引用还是可以调用子类重写的的方法
4、覆盖private方法虽然编译器不会报错但是也不会按照我们所期望的执行
5、覆盖变量后，调用的成员变量与我们所期望的不一样
6、静态方法的行为不具有多态性，因为静态方法是与类，而非是对单个对象相关联的。

class Son extends Super{
	int fo=2;//不是应该引用我吗？
	String s="子类专属的变量用在子类重写的方法中，利用父类引用可以调用该方法";
public void f(int i){
		System.out.println(s);
	}
void f(){
	System.out.println("不是应该调用子类方法的吗？");
}
static void g(){
	 System.out.println("子类静态方法");
}
}
public class Super {
	int fo=1;//覆盖变量后，调用的成员变量与我们所期望的不一样，调用的是父类的成员变量
     private void f(){
		System.out.println("父类方法访问权限为private时，调用父类方法");
	}
     void f(int i){
    	 System.out.println("子类的f(i)方法");
     }
     static void g(){
    	 System.out.println("父类静态方法");
     }
	public static void main(String[] args) {
		Super s1=new Son();
		s1.f(1);
		s1.f();//private方法对导出类是屏蔽的，所以覆盖private方法虽然编译器不会报错
		//但是也不会按照我们所期望的执行
		System.out.println("覆盖变量结果，fo="+s1.fo);
		s1.g();//调用的是父类的静态方法
	}
}

运行结果：
子类专属的变量用在子类重写的方法中，利用父类引用可以调用该方法
父类方法访问权限为private时，调用父类方法
覆盖变量结果，fo=1
父类静态方法

二、多态：

多态存在的条件：
一、要有继承；
二、要有重写；注意不是重载
三、父类引用指向子类对象。实例化一个没有名字的子类对象，然后向上转型为父类的父类的引用
只能调用父类中定义过的方法和变量（父类中没有定义过调用的时候要报错）

class A {
	public String show(D obj){
		return("A and D");
	}
	public String show(A obj){
		return("A and A");
	}
}
class B extends A{
	public String show(B obj){
		return("B and B");
	}
	public String show(A obj){
		return("B and A");
	}
}
class C extends B{	
}
class D extends B{
}
public class T1 {
	public static void main(String[] args) {
        A a2 = new B();  
        B b = new B();  
        C c = new C();   
        D d = new D();
        /*方法调用的优先级
         1、this.show(O)
         2、super.show(O)
         3、this.show((super)O)、
         4、super.show((super)O) */       
        System.out.println(a2.show(b));
        /*
         1、this.show(b)=a2.show(b)在A类里找show(b)方法，A类里没有show(b)方法
         2、super.show(b)=?A类没有super类
         3、this.show((super)b)=a2.show(a),在A类中有show(a)方法
         4、a2引用指向的是B对象，且B类中有对A类中的show(a)方法重载，所以最终调用的是B类中的
         show(a)方法
                      第4步中
                      父类引用指向子类对象，先去调用子类重写的方法，子类没有重写就再去调用父类的方法。                                     
         */
        System.out.println(a2.show(c));
        /*
         1、this.show(c)=a2.show(c)在A类里找show(c)方法，A类里没有show(c)方法
         2、super.show(c)=?A类没有super类
         3、this.show((super)c)=a2.show(b),在A类中有show(a)方法
                       接下来同上一输出
         4、this.show(b)=a2.show(b)在A类里找show(b)方法，A类里没有show(b)方法
         5、super.show(b)=?A类没有super类
         6、this.show((super)b)=a2.show(a),在A类中有show(a)方法
         7、a2引用指向的是B对象，且B类中有对A类中的show(a)方法重载，所以最终调用的是B类中的
         show(a)方法
         */
        System.out.println(a2.show(d));
        /*
         this.show(d)=a2.show(d)在A类里找show(d)方法,A类中有show(d)方法
                       因为B类中没有重载A类的show(d)方法，所以最终执行的是A类中的show(d)方法
         */
        System.out.println(b.show(b));
        System.out.println(b.show(c));      
        System.out.println(b.show(d));
        /*
         1、this.show(d)=b.show(d),在B类中找show(d)方法，找不到。
         2、super.show(d)=a.show(d),在A类中找show(d)方法，找到后调用A类的show(d)
         */
	}
}

运行结果：
B and A
B and A
A and D
B and B
B and B
A and D