面向对象的三大核心：封装、继承、多态。

看了视频后学会使用了，可是关于多态的定义，还是说不出来，理解不够深啊，求哪位同学给我详细讲讲多态的定义吧。

简单的说：相同类型的变量、调用同一个方法时候，呈现出多种不同的行为特征，这就是多态呗！

多态：
        (1)某一类事物的多种存在形态。
                **方法重载(静态多态)
                **方法重写(动态多态,对象多态)
        (2)对象多态的前提
                A：类与类(或接口)要有继承(或实现)关系。
                B：一定要有方法的重写。
                C：一定要有父类或者接口的引用指向子类的对象。Person p = new SuperMan();
                                                                                                                SuperMan sm = (SuperMan)p;
        (3)多态思想：可以指挥同一类型的一批对象做事情。多态的出现让我们复杂的问题简单化了。
                A：Animal Cat Dog
                        **method(Animal a){a.eat();}
        (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;

                        超人的例子：
                        person :谈生意();
                        SuperMan:谈生意();fly();

                        Person p = new SuperMan();//超人没变身之前就是普通人一个,只能调用Person里的方法
                        //在运行的时候发现有SuperMan这个子类继承了他,会去看里面是否有和你调用Person里相同的方法
                        //如果有运行就执行子类重写的方法(成员函数的特性,覆盖)
                        p.谈生意();

                        SuperMan sm= (SuperMan)p;//内裤外穿,变身超人
                        sm.谈生意();
                        sm.fly();
                        总结:无论是向上转型还是向下转型,变化的都是子类对象,绝对不能把父类对象强转为子类类型

以我个人的理解。主要是是四个方面
一、使用父类类型的引用指向子类的对象；
二、该引用只能调用父类中定义的方法和变量；
三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）
四、变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。
以下是一个很经典的例子：

1. class Father{   
   
2.     public void func1(){   
   
3.         func2();   
   
4.     }   
   
5.     //这是父类中的func2()方法，因为下面的子类中重写了该方法   
   
6.     //所以在父类类型的引用中调用时，这个方法将不再有效   
   
7.     //取而代之的是将调用子类中重写的func2()方法   
   
8.     public void func2(){   
   
9.         System.out.println("AAA");   
   
10.     }   
    
11. }   
    
12.    
    
13. class Child extends Father{   
    
14.     //func1(int i)是对func1()方法的一个重载，主要不是重写！  
    
15.     //由于在父类中没有定义这个方法，所以它不能被父类类型的引用调用   
    
16.     //所以在下面的main方法中child.func1(68)是不对的   
    
17.     public void func1(int i){   
    
18.         System.out.println("BBB");   
    
19.     }   
    
20.     //func2()重写了父类Father中的func2()方法   
    
21.     //如果父类类型的引用中调用了func2()方法，那么必然是子类中重写的这个方法   
    
22.     public void func2(){   
    
23.         System.out.println("CCC");   
    
24.     }   
    
25. }   
    
26.    
    
27. public class PolymorphismTest {   
    
28.     public static void main(String[] args) {   
    
29.         Father child = new Child();   
    
30.         child.func1();//打印结果将会是什么？   
    
31.         child.func1(68);  
    
32.     }   
    
33. }   

复制代码

子类Child继承了父类Father，并重载了父类的func1()方法，重写了父类的func2()方法。重载后的func1(int i)和func1()不再是同一个方法，由于父类中没有func1(int i)，那么，父类类型的引用child就不能调用func1(int i)方法。而子类重写了func2()方法，那么父类类型的引用child在调用该方法时将会调用子类中重写的func2()。

其输出的结果是很显然是"CCC"。

描述就是：同一类事物的多种体现形态。

代码上就是：父类引用指向子类对象。

多态好处是能够提高代码的后期扩展性，提高了代码的复用性。

1. <p><p>多态有两种体现：1>父类指向子类的对象
   
2.                 2>接口指向实现类的对象</p><p> </p><p>继承中多态的体现
   
3. public abstract class Animal {
   
4.         
   
5.         public abstract void eat();
   
6.         public  void run(){
   
7.                 System.out.println("走步");
   
8.         }
   
9.         public static void speak(){//静态方法
   
10.                 System.out.println("叫");
    
11.         }
    
12. }
    
13. public class Cat extends Animal{
    
14. 
    
15.         public void eat(){//重写父类的方法
    
16.                 System.out.println("猫吃鱼");
    
17.         }
    
18.         public void catchMouth(){//子类自己的方法
    
19.                 System.out.println("猫捉老鼠");
    
20.         }
    
21. }
    
22. public class Dog extends Animal{
    
23. 
    
24.         public void eat(){//重写父类的方法
    
25.                 System.out.println("狗啃骨头");
    
26.                
    
27.         }
    
28.         public void run(){//子类自己的方法
    
29.                 System.out.println("狗走步");
    
30.         }
    
31.         public static void speak(){//重写父类静态方法
    
32.                 System.out.println("狗叫");
    
33.         }
    
34. }
    
35. public class AnimalDemo {
    
36. 
    
37.         public static void main(String[] args) {
    
38.                
    
39.                 Animal a = new Cat();
    
40.                 a.eat();
    
41.                 a.run();
    
42.                
    
43.                
    
44.                
    
45.                 Animal a1 = new Dog();
    
46.                 a1.speak();        //调用静态方法，编译和运行都看左边
    
47.                 Dog d = new Dog();
    
48.                 d.run();//调用静态方法，编译和运行都看左边
    
49.     }
    
50. }</p></p>

复制代码

1. [code]接口中多态的体现
   
2. public interface Opertion{
   
3.         
   
4.         public  void add();
   
5.         public  void delet();
   
6.         public  void update();
   
7.         public  void select();
   
8. }
   
9. public class JDBC implements Opertion{
   
10. 
    
11.         public void add() {
    
12.                 System.out.println("添加操作");
    
13.                
    
14.         }
    
15.         public void delet() {
    
16.                 System.out.println("删除操作");
    
17.         }
    
18. 
    
19.         public void select() {
    
20.                 System.out.println("修改操作");
    
21.         }
    
22. 
    
23.         public void update() {
    
24.                 System.out.println("查询操作");
    
25.         }
    
26. }
    
27. public class Demo {
    
28.         
    
29.         public static void main(String[] args) {
    
30.                 Opertion o = new JDBC();
    
31.                 o.add();
    
32.                 o.delet();
    
33.                 o.update();
    
34.                 o.select();               
    
35.         }
    
36. }

复制代码

多态是面向对象程序设计的又一重要特性。
多态是允许程序中出现重名现象，java语言中有方法重载和成员覆盖两种多态表现形式。
方法重载：在一个类中，允许多个方法使用同一个名字，但方法的参数不同（包括个数和类型），完成的功能也不同。
成员覆盖：子类与父类允许拥有相同的变量名称，但数据类型不同，允许使用同样的方法，但是功能不同。
多态的特性使程序的抽象程度和简捷程度更高，有助于程序设计人员对程序的分组协同开发。

都说的那么复杂,让人家怎么理解?
简而言之,多态就是同种事物存在的多种状态
举个例子说,就像电脑主板存在很多接口,接口可以接,鼠标,U盘,无线网卡等等设备,这个时候,我们就可以说主板就属于多态了!
多态的好处就是提高代码的复用性和程序的扩展性.(就像主板,多功能,多实现)

讲的很详细啦，谢谢大家了

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。多态有两种表现形式：重载和覆盖首先说重载（overload），是发生在同一类中。与什么父类子类、继承毫无关系。      标识一个函数除了函数名外，还有函数的参数（个数和类型）。也就是说，一个类中可以有两个或更多的函数，叫同一个名字而他们的参数不同。      他们之间毫无关系，是不同的函数，只是可能他们的功能类似，所以才命名一样，增加可读性，仅此而已！        再说覆盖(override),是发生在子类中！也就是说必须有继承的情况下才有覆盖发生。    我们知道继承一个类，也就有了父类了全部方法，如果你感到哪个方法不爽，功能要变，那就把那个函数在子类中重新实现一遍。    这样再调用这个方法的时候，就是执行子类中的过程了。父类中的函数就被覆盖了

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。多态有两种表现形式：重载和覆盖首先说重载（overload），是发生在同一类中。与什么父类子类、继承毫无关系。      标识一个函数除了函数名外，还有函数的参数（个数和类型）。也就是说，一个类中可以有两个或更多的函数，叫同一个名字而他们的参数不同。      他们之间毫无关系，是不同的函数，只是可能他们的功能类似，所以才命名一样，增加可读性，仅此而已！        再说覆盖(override),是发生在子类中！也就是说必须有继承的情况下才有覆盖发生。    我们知道继承一个类，也就有了父类了全部方法，如果你感到哪个方法不爽，功能要变，那就把那个函数在子类中重新实现一遍。    这样再调用这个方法的时候，就是执行子类中的过程了。父类中的函数就被覆盖了