Java 面向对象概述原理： 多态、Object类，转型（8）

Java 面向对象概述原理： 多态、Object类，转型（8）

http://docs.oracle.com/javase/tutorial/java/IandI/override.html

Java 面向对象概述原理：

Java中多态性的体现、前提、好处、弊端、应用：

1，多态的体现：
    父类的引用指向了自己的子类对象。
    父类的引用也可以接收自己的子类对象。
2，多态的前提：
    必须是类与类之间有关系。要么继承，要么实现。
    通常还有一个前提：存在覆盖。

3，多态的好处：
    多态的出现大大的提高程序的扩展性。

4，多态的弊端：
    提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5，多态的应用
　　6，多态的出现代码中的特点(多态使用的注意事项)

/*
动物，
猫，狗。
*/

abstract class Animal
{
    abstract void eat();

}

class Cat extends Animal
{
    public void eat()
    {
        System.out.println("吃鱼");
    }
    public void catchMouse()
    {
        System.out.println("抓老鼠");
    }
}


class Dog extends Animal
{
    public void eat()
    {
        System.out.println("吃骨头");
    }
    public void kanJia()
    {
        System.out.println("看家");
    }
}


class Pig extends Animal
{
    public void eat()
    {
        System.out.println("饲料");
    }
    public void gongDi()
    {
        System.out.println("拱地");
    }
}

//-----------------------------------------


class DuoTaiDemo 
{
    public static void main(String[] args) 
    {
        //Cat c = new Cat();
        //c.eat();

        //Dog d = new Dog();
        //d.eat();
        //Cat c = new Cat();
        /*
        Cat c1 = new Cat();
        function(c1);

        function(new Dog());
        function(new Pig());
        */

        //Animal c = new Cat();
        //c.eat();

        
        function(new Cat());
        function(new Dog());
        function(new Pig());
        

        
    }
    public static void function(Animal a)//Animal a = new Cat();
    {
        a.eat();
        //a.catchMouse();
    }
    /*
    public static void function(Cat c)//
    {
        c.eat();
    }
    public static void function(Dog d)
    {
        d.eat();
    }

    public static void function(Pig p)
    {
        p.eat();
    }
    */

}

多态的转型：

两种类型的类型转换

　　（1）向上类型转换（Upcast）：将子类型转换为父类型。

　　对于向上的类型转换，不需要显示指定，即不需要加上前面的小括号和父类类型名。

　　（2）向下类型转换（Downcast）：将父类型转换为子类型。

　　对于向下的类型转换，必须要显式指定，即必须要使用强制类型转换

多态示例代码

public class PolyTest
{
    public static void main(String[] args)
    {
        
        //向上类型转换
        Cat cat = new Cat();
        Animal animal = cat;
        animal.sing();

                
        //向下类型转换
        Animal a = new Cat();
        Cat c = (Cat)a;
        c.sing();
        c.eat();


        //编译错误
        //用父类引用调用父类不存在的方法
        //Animal a1 = new Cat();
        //a1.eat();
        
        //编译错误
        //向下类型转换时只能转向指向的对象类型        
        //Animal a2 = new Cat();
        //Cat c2 = (Dog)a2;
        


    }
}
class Animal
{
    public void sing()
    {
        System.out.println("Animal is singing!");
    }
}
class Dog extends Animal
{
    public void sing()
    {
        System.out.println("Dog is singing!");
    }
}
class Cat extends Animal
{
    public void sing()
    {
        System.out.println("Cat is singing!");
    }
    public void eat()
    {
        System.out.println("Cat is eating!");
    }
}

第二个问题：如何使用子类特有方法。
*/

/*
动物，
猫，狗。
*/

class Cat extends Animal
{
    public void eat()
    {
        System.out.println("吃鱼");
    }
    public void catchMouse()
    {
        System.out.println("抓老鼠");
    }
}


class Dog extends Animal
{
    public void eat()
    {
        System.out.println("吃骨头");
    }
    public void kanJia()
    {
        System.out.println("看家");
    }
}


class Pig extends Animal
{
    public void eat()
    {
        System.out.println("饲料");
    }
    public void gongDi()
    {
        System.out.println("拱地");
    }
}

//-----------------------------------------


class DuoTaiDemo2 
{
    public static void main(String[] args) 
    {
        //Animal a = new Cat();//类型提升。 向上转型。
        //a.eat();

        //如果想要调用猫的特有方法时，如何操作？
        //强制将父类的引用。转成子类类型。向下转型。
        ///Cat c = (Cat)a;
        //c.catchMouse();
        //千万不要出现这样的操作，就是将父类对象转成子类类型。
        //我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。
        //多态自始至终都是子类对象在做着变化。
//        Animal a = new Animal();
//        Cat c = (Cat)a;
        

        /*
        毕姥爷 x = new 毕老师();

        x.讲课();

        毕老师 y = (毕老师)x;


        y.看电影();
        */
        function(new Dog());
        function(new Cat());


    }
    public static void function(Animal a)//Animal a = new Cat();
    {
        a.eat();
        /*
        if(a instanceof Animal)
        {
            System.out.println("haha");
        }
        else 
        */
        if(a instanceof Cat)
        {
            Cat c = (Cat)a;
            c.catchMouse();
        }
        else if(a instanceof Dog)
        {
            Dog c = (Dog)a;
            c.kanJia();
        }


        /*
        instanceof : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)  
        */
    
    }
    


}

/*
基础班学生：
    学习，睡觉。
高级班学生：
    学习，睡觉。

可以将这两类事物进行抽取。

*/

abstract class Student
{
    public abstract void study();
    public void sleep()
    {
        System.out.println("躺着睡");
    }
}

class DoStudent
{
    
    public void doSome(Student stu)
    {
        stu.study();
        stu.sleep();
    }
    
}

class BaseStudent extends Student
{
    public void study()
    {
        System.out.println("base study");
    }
    public void sleep()
    {
         System.out.println("坐着睡");
    }
}

class AdvStudent extends Student
{
    public void study()
    {
        System.out.println(" adv study");
    }
}




class  DuoTaiDemo3
{
    public static void main(String[] args) 
    {

        DoStudent ds = new DoStudent();
        ds.doSome(new BaseStudent());
        ds.doSome(new AdvStudent());

        
//        BaseStudent bs = new BaseStudent();
//        bs.study();
//        bs.sleep();
//        AdvStudent as = new AdvStudent();
//        as.study();
//        as.sleep();
    }

}

/*
在多态中成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。


在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类)。


在多态中，静态成员函数的特点：
无论编译和运行，都参考做左边。


*/

class Fu
{
    static int num = 5;
    void method1()
    {
        System.out.println("fu method_1");
    }
    void method2()
    {
        System.out.println("fu method_2");
    }
    static void method4()
    {
        System.out.println("fu method_4");
    }
}


class Zi extends Fu
{
    static int num = 8;
    void method1()
    {
        System.out.println("zi method_1");
    }
    void method3()
    {
        System.out.println("zi method_3");
    }

    static void method4()
    {
        System.out.println("zi method_4");
    }
}
class  DuoTaiDemo4
{
    public static void main(String[] args) 
    {
        
//        Fu f = new Zi();
//
//        System.out.println(f.num);
//
//        Zi z = new Zi();
//        System.out.println(z.num);

        //f.method1();
        //f.method2();
        //f.method3();

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

        Zi z = new Zi();
        z.method4();

    
        



//        Zi z = new Zi();
//        z.method1();
//        z.method2();
//        z.method3();
    }
}    

/*
需求：
电脑运行实例，
电脑运行基于主板。
*/


interface PCI
{
    public void open();
    public void close();
}

class MainBoard
{
    public void run()
    {
        System.out.println("mainboard run ");
    }
    public void usePCI(PCI p)//PCI p = new NetCard()//接口型引用指向自己的子类对象。
    {
        if(p!=null)
        {
            p.open();
            p.close();
            
        }
    }
}


class NetCard implements PCI
{
    public void open()
    {
        System.out.println("netcard open");
    }
    public void close()
    {
        System.out.println("netcard close");
        method();
    }
    
}
class SoundCard implements PCI
{
    public void open()
    {
        System.out.println("SoundCard open");
    }
    public void close()
    {
        System.out.println("SoundCard close");
    }
}
/*
class MainBoard
{
    public void run()
    {
        System.out.println("mainboard run");
    }
    public void useNetCard(NetCard c)
    {
        c.open();
        c.close();
    }
}

class NetCard
{
    public void open()
    {
        System.out.println("netcard open");
    }
    public void close()
    {
        System.out.println("netcard close");
    }
}
*/

class DuoTaiDemo5 
{
    public static void main(String[] args) 
    {
        MainBoard mb = new MainBoard();
        mb.run();
        mb.usePCI(null);
        mb.usePCI(new NetCard());
        mb.usePCI(new SoundCard());
        
    }
}

参考博客：

http://www.cnblogs.com/mengdd/archive/2012/12/25/2832288.html

http://www.cnblogs.com/jack204/archive/2012/10/29/2745150.html

多态的概念：

• 　　多态==晚绑定。
• 　　不要把函数重载理解为多态。因为多态是一种运行期的行为，不是编译期的行为。
• 　　多态：父类型的引用可以指向子类型的对象。比如 Parent p = new Child();　
• 　　当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的该同名方法。
• 　　
• 　　（注意此处，静态static方法属于特殊情况，静态方法只能继承，不能重写Override，如果子类中定义了同名同形式的静态方法，它对父类方法只起到隐藏的作用。调用的时候用谁的引用，则调用谁的版本。）

　　如果想要调用子类中有而父类中没有的方法，需要进行强制类型转换，如上面的例子中，将p转换为子类Child类型的引用。

　　因为当用父类的引用指向子类的对象，用父类引用调用方法时，找不到父类中不存在的方法。这时候需要进行向下的类型转换，将父类引用转换为子类引用。     

/*
多态：可以理解为事物存在的多种体现形态。

人：男人，女人

动物：猫，狗。

猫 x = new 猫();

动物 x = new 猫();

1，多态的体现
    父类的引用指向了自己的子类对象。
    父类的引用也可以接收自己的子类对象。
2，多态的前提
    必须是类与类之间有关系。要么继承，要么实现。
    通常还有一个前提：存在覆盖。

3，多态的好处
    多态的出现大大的提高程序的扩展性。

4，多态的弊端：
    提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5，多态的应用



*/

/*
动物，
猫，狗。
*/

abstract class Animal
{
    abstract void eat();

}

class Cat extends Animal
{
    public void eat()
    {
        System.out.println("吃鱼");
    }
    public void catchMouse()
    {
        System.out.println("抓老鼠");
    }
}


class Dog extends Animal
{
    public void eat()
    {
        System.out.println("吃骨头");
    }
    public void kanJia()
    {
        System.out.println("看家");
    }
}


class Pig extends Animal
{
    public void eat()
    {
        System.out.println("饲料");
    }
    public void gongDi()
    {
        System.out.println("拱地");
    }
}

//-----------------------------------------


class DuoTaiDemo 
{
    public static void main(String[] args) 
    {
        //Cat c = new Cat();
        //c.eat();

        //Dog d = new Dog();
        //d.eat();
        //Cat c = new Cat();
        /*
        Cat c1 = new Cat();
        function(c1);

        function(new Dog());
        function(new Pig());
        */

        //Animal c = new Cat();
        //c.eat();

        
        function(new Cat());
        function(new Dog());
        function(new Pig());
        

        
    }
    public static void function(Animal a)//Animal a = new Cat();
    {
        a.eat();
        //a.catchMouse();
    }
    /*
    public static void function(Cat c)//
    {
        c.eat();
    }
    public static void function(Dog d)
    {
        d.eat();
    }

    public static void function(Pig p)
    {
        p.eat();
    }
    */

}

什么是多态:

1. 面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。
2. 多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
3. 实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
4. 多态的作用：消除类型之间的耦合关系。
5. 现实中，关于多态的例子不胜枚举。比方说按下 F1 键这个动作，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；如果当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。

多态存在的三个必要条件，要求大家做梦时都能背出来！

• 多态存在的三个必要条件
• 一、要有继承；
• 二、要有重写；
• 三、父类引用指向子类对象。

 

多态的好处：

1.可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。
2.可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。
3.接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法，computeArea()以及computeVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。
4.灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。
5.简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

Java中多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载。

Java中的多态：

abstract class 动物
{
    abstract void eat();
}

class Dog extends 动物
{
    public void eat()
    {
        //骨头;
    }
}

class 猫 extends 动物
{
    public void eat()
    {
        //吃鱼；
    }
}

class 猪 extends 动物
{
    public void eat()
    {
        //饲料；
    }
}

class Demo
{
    public void method(动物 x)//new Dog(); new 猫();
    {
        x.eat();
    }
    /*
    public void  method(猫 x)
    {
        x.eat();
    }
    public void  method(Dog x)
    {
        x.eat();
    }
    public void  method(猪 x)
    {
        x.eat();
    }
    */
}

class Main
{
    public static void main(String[] args)
    {
        Demo d = new Demo();
        d.method(new Dog());
        d.method(new 猫());
    }
}



动物 x = new 猫（）；
//猫 x = new 猫（）；

一。表现：
父类或者接口的引用指向了或者接收了自己的子类对象。

二。前提：
1，类与类之间要有关系。继承，实现。
2，通常都会有覆盖。

三。好处：
预先定义的程序可以运行后期程序的内容。
增强了程序的扩展性。

四。弊端：
虽然可以预先使用，但是只能访问父类中已有的功能，运行的是后期子类的功能内容。
不能预先使用子类中定义的特有功能。

五。多态的注意事项：
在代码中。
对于成员函数：Fu f = new Zi(); f.method();
编译时期：看左边。
运行时期：看右边。
因为成员函数有一个覆盖操作。
    毕姥爷和毕老师的故事。

    
对于非私有的实例变量，
静态变量，静态方法。

编译和运行都看左边。

老师要求记住结论。有空闲时间，就想想为什么？

六。转型。
子类对象被父类引用：子类对象在向上转型。
将指向子类对象的父类应用转换成子类类型引用：向下转型。

毕姥爷和毕老师的故事。
class 毕姥爷
{}

class 毕老师 extends 毕姥爷
{}

毕姥爷 ly = new 毕老师();//毕老师向上转型为了毕姥爷。向上转型

毕老师 ls = (毕老师)ly; //将代表毕老师对象的父类引用ly强制转换成了毕老师类型。向下转型。



七。应用
电脑使用。主板运行。

class MainBoard
{
    public void run()
    {
        //主板运行;
    }
    public void usePCI(PCI p)//PCI p = new NetCard();
    {
        if(p!=null)
        {
            p.open();
            p.close();
        }
    }
}


//为了提高主板功能的扩展性。
//定义了规则。让后期的出现的功能板块，只要覆盖该规则，就可以被这个主板使用。
interface PCI
{
    void open();
    void close();
}




class MainDemo
{
    public static void main(String[] args)
    {
        MainBoard mb = new MainBoard();
        mb.run();
        mb.usePCI(null);
        mb.usePCI(new NetCard());



    }
}


class NetCard implements PCI
{
    public void open(){}
    public void close(){}
}


Object:是java中所有对象的直接或者间接的父类。
    它里面的方法都所有对象都具备的。
    常见方法：
    boolean equals(Object obj):用于比较两个对象是否相同。
    String toString(): 获取对象的字符串表现形式 类名@哈希值  
        getClass().getName()+"@"+Integer.toHexString(hashCode());
    Class getClass():获取正在运行的对象所属的字节码文件的对象。也就是说如果Demo d = new Demo();
                d.getClass():获取的就是d执行的对象所属的字节码文件Demo.class对象。
    
    通常在自定义对象时，因为对象中都有自己特有的描述，
    所以都会建立对象自身的特有比较方法，或者字符串表现形式。
    也就是说，会覆盖Object中的方法。


/*
Demo d1 = new Demo();
Demo d2 = new Demo();
d1.getClass() ==  d2.getClass();
*/


class Demo //extends Object
{
    public String toString()
    {
        this.getClass().getName()+"#"+Integer.toHexString(this.hashCode());
    }
}
    

class Fu
{
    void show(){System.out.println("fu show");}
}
class Zi extends Fu
{
    void function()
    {
        super.show();
        //this.show();
    }
    void show(){System.out.println("zi show");}
}




















/*

class Computer
{
    private MainBoard mb;

    Computer()
    {
        mb = new MainBoard();
    }
    public void play()
    {
        mb.run();
    }
}
*/