Java多态的理解

多态(polymorphism)

  1. 编译时多态:方法的重载
  2. 运行时多态:程序运行时系统根据调用该方法的实例的类型来决定调用哪个方法被称为运行时多态

上述描述认为方法的重载也是多态的一种表现,不过多态主要是指运行时多态。

运行时多态

  1. 多态的定义:指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)
  2. 实现多态的技术:动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。
  3. 多态的作用:消除类型之间的耦合关系。
  4. 多态产生的必要条件:要有继承、要有重写、父类引用指向子类对象。
  5. 方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现,重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写(Overriding)。子类的对象使用这个方法时,将调用子类中的定义,对它而言,父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法,它们或有不同的参数个数或有不同的参数类型,则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。
  6. 多态的好处:

  • 可替换性(substitutability):多态对已存在代码具有可替换性。
  • 可扩充性(extensibility):多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性,以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。
  • 接口性(interface-ability):多态是超类通过方法签名,向子类提供了一个共同接口,由子类来完善或者覆盖它而实现的。
  • 灵活性(flexibility):它在应用中体现了灵活多样的操作,提高了使用效率。
  • 简化性(simplicity):多态简化对应用软件的代码编写和修改过程,尤其在处理大量对象的运算和操作时,这个特点尤为突出和重要。

public class A {

	public String show(D obj) {
		return ("A and D");
	}
	
	public String show(A obj) {
		return ("A and A ");
	}
}

public class B extends A{

	public String show(B obj) {
		return ("B and B");
	}

public class C extends B{

}


public class D extends B{

}


public class Test {

	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(a1.show(b));
		System.out.println(a1.show(c));
		System.out.println(a1.show(d));
		System.out.println(a2.show(b));
		System.out.println(a2.show(c));
		System.out.println(a2.show(d));
		System.out.println(b.show(b));
		System.out.println(b.show(c));
		System.out.println(b.show(d));
	}
}

这里涉及方法调用的优先问题 ,优先级由高到低依次为:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)

当超类对象的引用变量引用子类对象时,被引用对象的类型决定了调用谁的成员方法而不是由引用变量的类型所决定,但是这个被调用的方法必须是在超类中定义过的,也就是被子类覆盖的方法。 (但是如果强制把超类转换成子类的话,就可以调用子类中新添加而超类没有的方法了)

对于第一个:

a1是A类的一个实例化对象,所以this指向A,然后查找this.show(b),由于没有这个方法,所以到super.show(b),但是由于A类没有超类了,所以到this.show(super b),由于b的超类是A,所以相当于this.show(A),然后在A类中查找到了这个方法,于是输出A and A。

对于第二个:

同样,a1是A类的实例化对象,所以this指向A,然后在A类中查找this.show(C)方法,由于没有这个方法,所以到了super.show(C),由于A类的超类里面找,但是A没有超类,所以到了this.show(super C),由于C的超类是B所以在A类里面查找this.show(B)方法,也没找到,然后B也有超类,就是A,所以查找this.show(A),找到了,于是输出A and A;

对于第三个:

同样,a1是A类的实例化对象,所以this指向A,然后在A类中找到this.show(D)方法,找到了,所以就输出A and D;

对于第四个:

a2是B类的引用对象,类型为A,所以this指向A类,然后在A类里面找this.show(B)方法,没有找到,所以到了super.show(B),由于A类没有超类,所以到了this.show(super B),B的超类是A,即super B = A,所以执行方法this。show(A),在A方法里面找show(A),找到了,但是由于a2是一个类B的引用对象,而B类里面覆盖了A类的show(A)方法,所以最终执行的是B类里面的show(A)方法,即输出B and A;

对于第五个:

a2是B类的引用对象,类型为A,所以this指向A类,然后在A类里面找this.show(C)方法,没有找到,所以到了super.show(C)方法,由于A类没有超类,所以到了this.show(super C),C的超类是B,所以在A类里面找show(B),同样没有找到,发现B还有超类,即A,所以还继续在A类里面找show(A)方法,找到了,但是由于a2是一个类B的引用对象,而B类里面覆盖了A类的show(A)方法,所以最终执行的是B类里面的show(A)方法,即输出B and A;

对于第六个:

a2是B类的引用对象,类型为A,所以this指向A类,然后在A类里面找this.show(D)方法,找到了,但是由于a2是一个类B的引用对象,所以在B类里面查找有没有覆盖show(D)方法,没有,所以执行的是A类里面的show(D)方法,即输出A and D;

对于第七个:

b是B类的一个实例化对象,首相执行this.show(B),在B类里面找show(B)方法,找到了,直接输出B and B;

对于第八个:

b是B类的一个实例化对象,首相执行this.show(C),在B类里面找show(C)方法,没有找到,所以到了super.show(c),B的超类是A,所以在A类中找show(C)方法,没有找到,于是到了this.show(super C),C的超类是B,所以在B类中找show(B)方法,找到了,所以执行B类中的show(B)方法输出B and B;

对于第九个:

b是B类的一个实例化对象,首先执行this.show(D),在B类里面找show(D)方法,没有找到,于是到了super.show(D),B的超类是A类,所以在A类里面找show(D)方法,找到了,输出A and D;


public class A {    
    public int a = 0;
    public void fun(){
        System.out.println("-----A-----");
    }
}

public class B extends A{
    public int a = 1;
    public void fun(){
        System.out.println("-----B-----");
    }

public static void main(String[] args){
        A classA = new B();     
        System.out.println(classA.a);
        classA.fun();
    }   
}

输出结果为:


java中变量不能重写,可按如下口诀记忆:

   变量多态看左边,方法多态看右边,静态多态看左边。



猜你喜欢

转载自blog.csdn.net/wulibabywenyu/article/details/79659384
0条评论
添加一条新回复