java多态

//多态描述：同一个对象在不同时刻表现的不同状态
比如：
    猫是猫,猫是动物
    水（液态，固态，气态）
多态的前提：
    1.要有继承关系
    2.要有关系重写（多态通过方法的重写来体现）
    3.要有父类引用指向子类对象
      父 f=new 子();    
栗子： 
public class 多态的前提 {
//    1.要有继承关系
//    2.要有关系重写（多态通过方法的重写来体现）
//    3.要有父类引用指向子类对象
//      父 f=new 子(); 
	public static void main(String[] args) {
		fu f=new zi();
	}
}
class fu{
	public void show() {
		System.out.println("父亲的show方法");
	}
}
class zi extends fu{
	public void show() {
		System.out.println("儿子的show方法");
	}
}


//多态中的成员访问特点
   1.成员变量
     子类对象不可以访问父类的成员变量
     编译看左边，运行看左边
   2.构造方法
     创建子类对象时，访问父类的构造方法，对父类的数据进行初始化
   3.成员方法
     编译看左边，运行看右边
   4.静态方法 
     编译看左边，运行看左边（静态和类相关所以静态方法的重写算不上重写，访问还是左边） 
结论：由于成员方法存在方法重写，所以它运行看右边。
栗子：
package 多态;
//1.成员变量
//子类对象不可以访问父类的成员变量
//编译看左边，运行看左边
//2.构造方法
//创建子类对象时，访问父类的构造方法，对父类的数据进行初始化
//3.成员方法

class fu1{
	int num=100;
	public void show() {
		System.out.println("父亲的show方法");
	}
	public static void function() {
		System.out.println("父亲的function方法");
	}
}
class zi1 extends fu1{
	int num=10;
	int num2=200;
	public void show() {
		System.out.println("儿子的show方法");
	}
	public void method() {
		System.out.println("儿子的method方法");
	}
	
	public static void function() {
		System.out.println("儿子的function方法");
	}
}

public class 多态的成员访问特点 {
	public static void main(String[] args) {
		fu1 f=new zi1();
		
		//1.成员变量
		System.out.println(f.num);
		System.out.println(fnum2);	//子类对象不可以访问父类的成员变量,编译看左边，运行看左边
		//2.成员方法
		f.show();//成员方法编译看左边，运行看右边，所以输出“儿子的show方法”。
		f.method();	//子类对象不可以访问父类的成员变量,编译看左边，运行看右边
		//3.静态方法
		f.function();// 编译看左边，运行看左边（静态和类相关所以静态方法的重写算不上重写，访问还是左边） 
	}
}

//多态的好处
1.提高了代码的维护性
2.提高了代码的扩展性
栗子：
//以下是多态的扩展性
class 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 cat extends animal{
	public void eat() {
		System.out.println("猫吃小鱼");
	}
	public void sleep() {
		System.out.println("猫睡在床上");
	}	
}

public class 多态的好处 {
	public static void main(String[] args) {
		//养一只猫
		cat c1=new cat();
		c1.eat();
		c1.sleep();
		//再养着一只
		cat c2=new cat();
		c2.eat();
		c2.sleep();
		//养第三只
		cat c3=new cat();
		c3.eat();
		c3.sleep();
		//上面这种方法很麻烦，每一个方法调用时都要写一遍。所以就有了下面这种
		//要先写下边这个useCat方法
		//然后养一只猫
		System.out.println("**************************************我是分割线");
		cat c4=new cat();
		//调用useCat方法
		animalTool.useCat(c4);//输出结果是和其余三只猫一样的
		//可是这样我们每养一个新的动物都要写一次工具类，很麻烦，所以就修改了了动物工具类animalTool里的方法,
	    //我们用修改过得方法养一只猫
		System.out.println("**************************************我是分割线");
		animal a=new cat();
	    animalTool.useAnimal(a);
	    //再养一只狗
		animal a2=new dog();
	    animalTool.useAnimal(a2);
	}
}
//这是一个针对动物操作的工具类
class animalTool{
	public static void useCat(cat c) {//参数是cat类，所以实参需要是一个
	c.eat();
	c.sleep();
}
	//修改如下，这样只要是动物就可以使用这个方法，使用方法如上调用
	public static void useAnimal(animal a) {//参数是cat类，所以实参需要是一个
	a.eat();
	a.sleep();
}	
}