9.java基础-多态

多态

某一个事物，在不同时刻表现出来的不同状态。
Cat可以是猫,同时Cat也是动物。

多态的好处

A:提高了代码的维护性(继承保证)

B:提高了代码的扩展性(由多态保证)

多态的前提

1.有继承关系

2.有方法重写

3.有父类引用指向子类对象

多态成员访问特点

☆成员变量:编译看左边，运行看左边。

☆成员方法:编译看左边，运行看右边。

由于成员方法存在方法重写，所以它运行看右边。
由于成员方法存在方法重写，所以它运行看右边。

构造方法

创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。

package study.多态;

/*
	多态：同一个对象(事物)，在不同时刻体现出来的不同状态。
	举例：
		猫是猫，猫是动物。
		水(液体，固体，气态)。
		
	多态的前提：
		A:要有继承关系。
		B:要有方法重写。
			其实没有也是可以的，但是如果没有这个就没有意义。
				动物 d = new 猫();
				d.show();
				动物 d = new 狗();
				d.show();
		C:要有父类引用指向子类对象。
			父 f =  new 子();
			
	用代码体现一下多态。

*/
class Fu {
    public int num = 100;

    public void show() {
        System.out.println("show Fu");
    }

    public static void function() {
        System.out.println("function Fu");
    }
}

class Zi extends Fu {
    public int num = 1000;
    public int num2 = 200;

    public void show() {
        System.out.println("show Zi");
    }

    public void method() {
        System.out.println("method zi");
    }

    public static void function() {
        System.out.println("function Zi");
    }
}

class DuoTaiDemo {
    public static void main(String[] args) {
        Fu f = new Fu();
        Fu f2 = new Zi();
        Zi z = new Zi();

        /***
         * 成员变量
         */
        //100
        System.out.println(f.num);
        //100
        System.out.println(f2.num);
        //1000
        System.out.println(z.num);

        /***
         * 成员方法
         */
        //show Fu
        f.show();
        //show Zi
        f2.show();
        //show Zi
        z.show();

    }
}

多态的弊端:不能使用子类的特有功能。

class Fu {
	public void show() {
		System.out.println("show fu");
	}
}

class Zi extends Fu {
	public void show() {
		System.out.println("show zi");
	}
	
	public void method() {
		System.out.println("method zi");
	}

}

class DuoTaiDemo3 {
	public static void main(String[] args) {
		//测试
		Fu f = new Zi();
		
		//打印show zi 原因:编译看左边 运行看右边。
		f.show();
		
		//无法调用子类的method方法
		f.method();
	}
}

如何使用子类的特有功能:向下转型

多态的弊端：
不能使用子类的特有功能。
我就想使用子类的特有功能?行不行?
行! 怎么用呢?

A:创建子类对象调用方法即可。(可以，但是很多时候不合理。而且，太占内存了)

Zi z = new Zi();

​B:把父类的引用强制转换为子类的引用。(向下转型)

	Fu f = new Zi();
	Zi z = (Zi)f;

在我们平时的开发中并不会出现上述向下转型的情景。想想我们在Service层开发时,需要被外部调用的方法都声明在Service接口内,不需要被外部调用的方法可以写在Service接口的具体实现内。

class Fu {
	public void show() {
		System.out.println("show fu");
	}
}

class Zi extends Fu {
	public void show() {
		System.out.println("show zi");
	}
	
	public void method() {
		System.out.println("method zi");
	}

}

class DuoTaiDemo4 {
	public static void main(String[] args) {
		//测试 编译看左边运行看右边
		Fu f = new Zi();
		f.show();
		//无法调用
		f.method();
		
		//创建子类对象
		Zi z1 = new Zi();
		z1.show();
		z1.method();
		
		//由于f指向的实际是1个Zi对象
		//因此可以对Zi对象进行强转
		Zi z2 = (Zi)f;
		z2.show();
		z2.method();
	}
}

多态练习

/*
	看程序写结果:先判断有没有问题，如果没有，写出结果
*/
class Fu {
	public void show() {
		System.out.println("fu show");
	}
}

class Zi extends Fu {
	public void show() {
		System.out.println("zi show");
	}

	public void method() {
		System.out.println("zi method");
	}
}

class DuoTaiTest3 {
	public static void main(String[] args) {
		Fu f = new Zi();
		
		f.method();//找不到符号
		
		f.show();//zi show
	}
}

package netty.bytebuf;

/*
	看程序写结果:先判断有没有问题，如果没有，写出结果
	
	多态的成员访问特点：
		方法：编译看左边，运行看右边。
		
	继承的时候：
		子类中有和父类中一样的方法，叫重写。
		子类中没有父亲中出现过的方法，方法就被继承过来了。
*/
class A {
	public void show() {
		show2();
	}
	public void show2() {
		System.out.println("我");
	}
}
class B extends A {
	/*
	public void show() {
		show2();
	}
	*/

	public void show2() {
		System.out.println("爱");
	}
}
class C extends B {
	public void show() {
		super.show();
	}
	public void show2() {
		System.out.println("你");
	}
}
public class DuoTaiTest4 {
	public static void main(String[] args) {
		A a = new B();
		//由于B没有show方法,所以B在A中找show方法
		//执行show2()，先在本类中找,找到了就调用打印爱

		a.show();
		//C有show方法,调用show方法 执行super.show() 找到B的show方法
		//B的show方法是从A继承来的,C执行show2()，先在本类C中找,找到了就调用打印你
		B b = new C();
		b.show();
	}
}


爱你

package netty.bytebuf;

/*
	看程序写结果:先判断有没有问题，如果没有，写出结果
	
	多态的成员访问特点：
		方法：编译看左边，运行看右边。
		
	继承的时候：
		子类中有和父类中一样的方法，叫重写。
		子类中没有父亲中出现过的方法，方法就被继承过来了。
*/
class A {
	public void show() {
		show2();
	}
	public void show2() {
		System.out.println("我");
	}
}
class B extends A {
	//这是和上个例子不同的地方
	public void show() {
		show2();
	}
	public void show2() {
		System.out.println("爱");
	}
}
class C extends B {
	public void show() {
		super.show();
	}
	public void show2() {
		System.out.print("你");
	}
}
public class DuoTaiTest4 {
	public static void main(String[] args) {
		A a = new B();
		//由于B没有show方法,所以B在A中找show方法
		//执行show2()，先在本类中找,找到了就调用打印爱

		a.show();
		//C有show方法,调用show方法 执行super.show() 找到B的show方法
		//B的show方法是从A继承来的,C执行show2()，先在本类C中找,找到了就调用打印你
		B b = new C();
		b.show();
	}
}
爱你