Java中多态定义是什么？特点是什么？为什么要用多态？

Java中多态定义是发送消息给某个对象，让该对象自行决定响应何种行为。
通过将子类对象引用赋值给父类对象引用变量来实现动态方法调用。
java 的这种机制遵循一个原则：当父类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在父类中定义过的，也就是说被子类覆盖的方法。

举例：人在工作上不同的表现行为，在餐厅是服务员，在学校是老师，即在不同的地方做出不同的表现行为。

代码实现：

1. 
   
2. 
   
3. /**
   
4. * Person
   
5. * @author Administrator
   
6. *
   
7. */
   
8. 
   
9. public abstract class Person extends Object {
   
10.         public void working() {
    
11.                
    
12.         }
    
13. }
    
14. 
    
15. /**
    
16. * Teacher
    
17. * @author Administrator
    
18. *
    
19. */
    
20. public class Teacher extends Person{
    
21.        
    
22.         @Override
    
23.         public void working() {
    
24.                 System.out.println("开始教书！");
    
25.         }
    
26. }
    
27. 
    
28. /**
    
29. * Waiter
    
30. * @author Administrator
    
31. *
    
32. */
    
33. public class Waiter extends Person{
    
34.         @Override
    
35.         public void working() {
    
36.                 System.out.println("开始接待客人！");
    
37.         }
    
38.        
    
39.         public static void main(String[] args) {
    
40.                 Person teacher = new Teacher();
    
41.                 Person waiter = new Waiter();
    
42.                 working(teacher);//开始开始教书
    
43.                 working(waiter); //输出开始接待客人
    
44.                
    
45.         }
    
46.        
    
47.         public static void working(Person person) {
    
48.                 person.working();
    
49.         }
    
50. }
    
51. 
    

复制代码

上面的代码提现了人在不同的工作环境不同的表现，假如public static void working(Person person) 是你的上级领导调用你的方法，他不需要知道你是做什么工作的，你自己知道做什么，做出什么响应，即让该对象自行决定响应何种行为。

多态条件：
1:继承
2:重写
3:父类引用指向字类对象

我们为什么要多态呢，在程序的可维护性和可扩展性大大的提供，本是一物，只是在不同的环境做出不同的响应，我们程序没有必要为不同的环境编写不同的方法，具体的响应又具体的环境类去实现。

刘海涛 发表于 2011-12-6 09:48
Java中多态定义是发送消息给某个对象，让该对象自行决定响应何种行为。
通过将子类对象引用赋值给父类对象 ...

恩恩 写的很清楚 谢谢

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

人：男人，女人

动物：猫，狗。

猫 x = new 猫();

动物 x = new 猫();

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

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

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

5，多态的应用

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




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

/*
动物，
猫，狗。
*/

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 类型(类类型 接口类型)  
                */
       
        }
       


}