多态

1.

class X {
	Y b = new Y();
	X() {
		System.out.print("X");
	}
}


class Y {
	Y() {
		System.out.print("Y");
	}
}


//测试类
public class Z extends X{
	Y y = new Y();
	Z() {
//		super();
		System.out.print("Z");
	}
	public static void main(String[] args) {
		new Z(); 
				//YXYZ

进父类 打印出y x    进子类  打印出 y z  
1.子类继承父类，程序执行的过程中先加载用父类（即x类）
2.java程序执行时先加载全局变量（即父类里面的y类）

}
}
2final的用法:
  final可以修类,该类不能继承
  fianl可以修饰成员方法,该方法不能被重写
  final可以变量(成员/局部变量),这个时候变量就变成了一个常量!(常用)（所以不能再被修改）
    常量的分类:
  字面值常量:
  "hello",'A',100....
  自定义常量:
  final int num = 10 ;
3.子类将父类中的方法覆盖掉,篡改了父类中方法.有时候可能不想子类去重写父类中 方法,java就提供了一个关键字:
  final:最终的,终态的!(表示:无法更改的)

class F{
	final public void show(){
		System.out.println("这是绝密文件，任何人都不能更改");
	}
}
class S extends F{
//	public void show(){
	//	System.out.println("我想更改。。。");
	//}//若不注释掉，会报错，因为不允许更改
}
public class ExtendsDemo2 {
	public static void main(String[] args) {
		S s = new S();
		s.show();//输出：这是绝密文件，任何人都不能更改
	}
}

4.多态：指的是一个事物,在不同时刻状态的一个体现!
水:固态,气态,液态;
  Dog d = new Dog();//创建了一个狗类的对象
Animal a = new Dog();狗是一个动物
  = new cat();
  4.1多态的前提条件
  1)必须有继承关系
  2)继承一个类的同时,子类中必须有方法重写(使用子类中的方法去覆盖父类中的方法)
  动物类:吃和睡的功能,子类重写父类的方法的原因:使用子类中有具体的功能..
  3)父类的引用指向子类对象
  继承的时候:使用子类的:Zi z = new Zi() ;
  Fu f = new Zi() ;将f代表的父类引用指向堆内存的子类的对象!
  向上转型!
 4.2多态的成员访问特点
                        成员变量:
  编译看左,运行看左!
  非静态成员方法:
  编译看左,运行看右
  子类中的方法会覆盖掉父类中的方法
  静态的成员方法:
  编译看左边,运行看左边
  (静态和类有关系)
 
  构造方法:始终是给对象进行初始化的!..
 4.3多态的弊端
                      子类只能使用父类的功能:不能使用子类中特有的功能!
要想使用子类具体功能
  1)创建子类对象
  2)向下转型:将父类的引用强制转换为子类对象
  Fu f = new Zi() ;向上转型
                         Zi z = (Zi)(f) ;//向下转型

class Father{
	public void show()	{
		System.out.println("show Father...");
	}
}
class Son extends Father{
	public void method(){
		System.out.println("method Son...");
	}
	
	public void show(){
		System.out.println("show Son.....");
	}
}
public class DuotaiDemo2 {
public static void main(String[] args) {
	Father f = new Son();
	f.show();
	
	//f.method();method()是子类特有的功能
	//向下转型
	Son s = (Son)f;
	s.method();
	s.show();
}

}

猫狗案例多态版
class Animal3{
	public void eat(){
		System.out.println("饿了就吃饭");
	}
}
class Cat3 extends Animal3{
	public void eat(){
		System.out.println("猫吃鱼");
	}
	public void playGame(){
		System.out.println("猫玩游戏");
	}
}
class Dog3 extends Animal3{
	public void eat(){
		System.out.println("狗吃骨头");
	}
	public void lookDoor(){
		System.out.println("狗看门");
	}
}


public class CatandDog {
	public static void main(String[] args) {
		Animal3 a = new Cat3();
		a.eat();
		//向下转型
		Cat3 c3 = (Cat3)a;
		c3.eat();
		c3.playGame();
	}
}

 4.4多态的好处


提高了代码的维护性(由继承保证)
  提高了代码的扩展性(由多态的保证)

class Fu{
	public int num = 20;
	public Fu(){}
	public void show(){
		System.out.println("show Fu");
	}
	static void method(){
		System.out.println("method Fu");
	}
}
class Zi extends Fu{
	int num = 20;
	public Zi(){}
	public void show(){
		System.out.println("show  Zi");
	}
	public static void method() {
		System.out.println("show method");
	}
}


public class DuotaiDemo {
	public static void main(String[] args) {
		Fu f = new Zi();//父类引用指向子类对象
		System.out.println(f.num);//非静态方法  编译看左  运行看右   20
		f.show();//   show zi
		f.method();//静态方法 编译看左 运行看左  method Fu
	}
}class Animal{
	public void eat(){
		System.out.println("eat");
	}
	public void sleep(){
		System.out.println("sleep");
	}
}
class Cat extends Animal{
	public void eat(){
		System.out.println("猫吃鱼。。。");
	}
	public void sleep(){
		System.out.println("猫趴着睡觉");
	}
}
class Dog extends Animal{
	public void eat(){
		System.out.println("狗吃骨头");
	}
	public void sleep(){
		System.out.println("狗躺着睡觉");
	}
}
//动物工具类
class AnimalTool{
	private AnimalTool(){}
	public static void useAnimal(Animal a){//因为静态方法不需要被实例化 直接传参数
		a.eat();
		a.sleep();
	}
}
//测试类
public class DuotaiDemo1 {
public static void main(String[] args) {
	Cat c1 = new Cat();
	Cat c2 = new Cat();
	Cat c3 = new Cat();
	AnimalTool.useAnimal(c1);
	AnimalTool.useAnimal(c2);
	AnimalTool.useAnimal(c3);
	
}


}