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
4000
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