黑马程序员----------面向对象三大特性之多态

                         ----------------------android培训、java培训、期待与您交流！ ----------------------

           面向对象的继承其实也是为了多态奠定了基础条件，多态其实也不难理解，面向对象既然是由现实生活，那么我们可以想想平时的水，水其实有几种形式，当水的温度低于0度时，它就成了冰，也就是固态，当它蒸发了的时候，就成了水蒸气，算是气态了，那么像这样一个事物有多样的形态，在java中也就称之为多态。
  

 (1)某一类事物的多种存在形态。

        **方法重载(静态多态)

        **方法重写(动态多态,对象多态)

    (2)对象多态的前提

        A：类与类(或接口)要有继承(或实现)关系。

        B：一定要有方法的重写。

        C：一定要有父类或者接口的引用指向子类的对象。

    (3)多态思想：可以指挥同一类型的一批对象做事情。多态的出现让我们复杂的问题简单化了。

        A：Animal Cat Dog

            **method(Animal a){a.eat();}

        B：同学们吃饭

        C：士兵打仗(抬枪，瞄准，射击)。

    (4)多态中成员的特点：(我们只研究特殊的，就是说名字一样的东西)

        Fu f = new Zi();

        A：成员变量：编译和运行都看Fu。

        B：非静态方法：编译看Fu，运行看Zi。

        C：静态方法：编译和运行都看Fu。

       

        举例：    动物的例子：
            向上转型
            Animal a = new Cat();
            a.eat();
            //a.catchMouse();

            向下转型
            Cat c = (Cat)a;
            c.eat();
            c.catchMouse();

            //向上转型
            Animal a = new Dog();
            //向下转型 转换异常
            //Cat c = (Cat)a;
            Dog d = (Dog)a;

            孔爹的例子：
            孔爹:教课(Java)
            孔子:教课(论语),看小说(),打游戏()。

            孔爹 k = new 孔子();//穿上他爹衣服,就跟着去了
            k.教课(论语)。
            //k.看小说();

            孔子 kz = (孔子)k;//把衣服脱了
            kz.教课(论语);
            kz.看小说();
            kz.打游戏();

下面写两个多态的具体代码。

//final class Fu {//错误: 无法从最终Fu进行继承

class Fu {
	//public final void show(){//错误: Zi中的show()无法覆盖Fu中的show()   被覆盖的方法为final
	public final void show(){
		System.out.println("一夫一妻制");
	}
}

class Zi extends Fu{
	final int num;
	/*
		扩展： 如果final修饰的变量没有默认值，可以在构造方法中给num 赋值一次
	*/
	public Zi(){
		num = 20;
	}

	public void show(){
		System.out.println("一夫多妻制");
	}
}

class FinalDemo {
	public static void main(String[] args)	{
		Zi z = new Zi();
		z.show();

		//z.num = 30;//错误: 无法为最终变量num分配值
		//System.out.println(z.num);
	}
}

   
-多态的成员特点(成员变量)
-多态的成员特点(成员变量图解)
    | 编译看左边的父类
    | 执行看左边的父类
    | 只有创建对象， 才能调用构造方法
    /*
    多态的成员
        成员变量
            编译看左边的父类，执行看左边的父类

class Fu {
	int num = 10;
}

class Zi extends Fu {
	int num = 20;
	int num2 = 30;
}

class DuoTaiDemo2 {
	public static void main(String[] args)	{
		
		//Zi z = new Zi();
		//System.out.println(z.num);

		//Fu f = new Fu();
		//System.out.println(f.num);

		//多态的方式
		Fu f2 = new Zi();
		System.out.println(f2.num);// 错误: 找不到符号  位置: 类型为Fu的变量 f2
		//System.out.println(f2.num2);
	}
}

多态的成员特点(成员方法)
    | 编译看左边的父类
    | 执行看右边的子类
    /*
    多态的成员
        成员方法：
            编译看左边的父类
            执行看右边的子类
*/

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

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

class DuoTaiDemo3 {
    public static void main(String[] args)    {
        //Fu f = new Fu();
        //f.show();

        //Zi z = new Zi();
        //z.show();

        //多态的方式
        Fu f2 = new Zi();
        f2.show();
    }
}

多态的成员特点(静态方法)
    | 编译看左边的父类
    | 执行看左边的父类
    | 静态是随着类的加载而存在，对象还没有创建，所以调用的时候，使用的Fu中的静态方法
    /*
    多态的特点
        静态方法
        编辑看左边的父类
        执行看左边的父类

    关于多态的特点的总结：

        成员方法执行看右边，其他都看左边.

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

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

class DuoTaiDemo4 {
	public static void main(String[] args)	{
		//Fu f = new Fu();
		//f.show();
		//Fu.show();

		//Zi z = new Zi();
		//z.show();
		//Zi.show();

		//多态的方式
		Fu f2 = new Zi();
		f2.show();
		//Fu.show();
		/*
			在调用静态show方法的时候，对象可能还没有创建出来，
			所以，当前的静态方法可以通过类名.方法名来调用
			这个show方法  Fu.show(); 
			当前的f2.show();中的f2 它Fu类型,它可以通过Fu.show()来调用，效果是等价的


		*/

	}
}

多态的好处
    | 提高了程序的扩展性
    /*
    好处和作用：
        多态的存在提高了程序的扩展性和后期可维护性
        
        后期可维护性(父类Person 来完成的)

    多态的弊端：
        父类不能访问子类特有方法

class Person {
	public void eat(){
		System.out.println("吃饭");
	}
	public void sleep(){
		System.out.println("睡觉");
	}
}

class Girl extends Person {
	public void eat(){
		System.out.println("女生 吃饭少");
	}
	public void sleep(){
		System.out.println("女生 睡觉早");
	}
	public void goShopping(){
		System.out.println("带着男朋友逛商场");
	}
}

class Boy extends Person{
	public void eat(){
		System.out.println("男生 吃饭多");
	}
	public void sleep(){
		System.out.println("男生 睡觉晚");
	}
}

class Other extends Person{
	public void eat(){
		System.out.println("other 吃饭");
	}
	public void sleep(){
		System.out.println("other 睡觉");
	}
}


class DuoTaiDemo5 {
	public static void main(String[] args)	{
		/*
		Girl g = new Girl();
		g.eat();
		g.sleep();

		Girl g2 = new Girl();
		g2.eat();
		g2.sleep();
		*/
		Girl g3 = new Girl();
		girlMethod(g3);

		Boy b = new Boy();
		boyMethod(b);

		Other o = new Other();
		otherMethod(o);

		//------------------------
		//多态的方式
		Person g4 = new Girl();
		personMethod(g4);

		Person b2 = new Boy();
		personMethod(b2);

		Person o2 = new Other();
		personMethod(o2);

		//------------------------
		//多态的弊端
		Girl g5 = new Girl();
		g5.goShopping();

		Person g6 = new Girl();
		g6.goShopping();


	}

	//多态方式的方法
	public static void personMethod( Person p ){
		p.eat();
		p.sleep();
	}

	//其他人方法
	public static void otherMethod( Other o ){
		o.eat();
		o.sleep();
	}

	//男生方法
	public static void boyMethod( Boy b ){
		b.eat();
		b.sleep();
	}

	//女生方法
	public static void girlMethod( Girl g ){
		g.eat();
		g.sleep();
	}
}

多态的弊端
    | 父类不能访问子类特有方法

多态的案例(向上转型、向下转型)
    | 向上转型: 提高了程序的扩展性  
        Person g = new Girl();
    | 向下转型：为了使用子类的特有方法
        Girl girl = (Girl)g;
    /*
    多态的案例
        向上转型: 提高了程序的扩展性
        
        Person p = new UltraMan();
        子类 转型 父类使用
        小   -->    大        隐式转换  自动类型提升
        
        //--------------------------------------------------

        向下转型: 为了使用子类的特有方法

        UltraMan ultra = (UltraMan)p;
        父类 强转 子类使用
        大   --->   小        强制转换

    案例： 奥特曼打小怪兽

    人： name , 吃饭eat()
    奥特曼: name , 吃饭eat() ,打架fight()
*/

class Person {
	String name = "成龙";
	public void eat(){
		System.out.println("成龙 吃饭");
	}
}

class UltraMan extends Person{
	//特有方法
	public void fight(){
		System.out.println("奥特曼打小怪兽");
	}
}

class DuoTaiDemo6 {
	public static void main(String[] args)	{
		Person p = new UltraMan();//向上转型
		System.out.println(p.name);
		p.eat();

		UltraMan ultra = (UltraMan)p;//向下转型
		ultra.fight();

	}
}

                       ----------------------android培训、java培训、期待与您交流！ ----------------------