1. class duotaiDemo
   
2. 
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 //Animal p = new Pig
   
7.                 //function()
   
8. 
   
9.                 //Pig p = new Pig();
   
10.                 //function(p);
    
11. 
    
12.                 //function(new Dog());
    
13.                 Animal c = new Dog();
    
14.                 function(new Cat());
    
15.                 function(new Dog());
    
16.                 function(new Pig());
    
17. 
    
18. 
    
19. 
    
20.         }
    
21. 
    
22.         
    
23.         public static void function(Animal a)
    
24.         {
    
25.                 a.eat();
    
26.         }

复制代码

问题:这代码里面的类:function(Animal a)
,Animal是参数类型,就是引用数据类型..但是a是啥类型呢?
为什么主函数里面的function(new Pig)等等,他们作为一次性的匿名对象,是以什么样的形式传进类funciton的呢?

Animal a = new Cat();
a 本身是 new 出来的 Cat() 实例，但是被当成 Animal 来使用，
Cat 独有的方法（Animal没有的）没办法调用，
Animal 有的方法会从 Cat() 里调用，就是如果被重写了会调用重写的方法

    首先，Animal是类类型吧。
    关于function方法传参问题，我的理解是：每一个方法，如果有形式参数，其被调用过程中都有一个传参的过程。如本题将会先做：Animal a = new Cat();这个过程。
像本例中的function(Animal a),这里a只是一个形式参数，当调用function方法时，如function(new Cat());在内存中会先将这个Cat的匿名对象赋值给Animal a，即：
Animal a = new Cat();这样就是父类的引用变量接收了子类对象。

public static void function(Animal a)的参数是Animal类型的对象，即调用function方法是可以要传给他Animal类型的对象，接着a引用就会指向这个对象，方法内部就可以操作a。
例：function（new Animal());  //new一个Animal类的对象传给function方法。a 引用指向new出来的对象。（即相当于：Animal a = new Animal();）

多态的意思就是父类引用指向了子类对象，即：Animal a = new Cat(); //调用a.eat()时，实际调用的是Cat类（子类）重写的eat方法。
function(new Cat()); 是简写方式,完全等同与：Cat c = new Cat();   function(c);   (比较发现第一种方式没有在桟空间建立引用节约了内存空间)

a其实就是一个对象 前面的Animal就是类型 所以a就是Animal类型的对象

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

多态，是面向对象的程序设计语言最核心的特征。封装性、继承性都比较简单，所以这里只对多态做一个小小的笔记。。。

1、什么是多态？

多态意味着一个对象可以多重特征，可以在特定的情况下，表现出不同的状态，从而应对不同的属性和方法。在Java中，多态的实现指的是使用同一个实现接口，以实现不同的对象实例。

例如，我们定义一个Parent类，再定义一个getName()方法返回一个字符串，定义一个形参为Parent类型的成员方法doSomething(Parent obj)，在这个方法中调用obj.getName()。然后再定义两个类A和B，都从Parent类继承而来，在子类中重写getName()方法。最后在main方法中创建一个Parent类的对象objP，调用objP.doSomething()方法并向其传递class A，和class B 的引用。观察输出结果。

[java] view plaincopyprint?

• class Parent  
• {  
•     private String name = "parent";  
•       
•     public String getName()  
•     {  
•         return this.name;  
•     }  
•     public void doSomething(Parent obj)  
•     {  
•         //输出类名  
•         System.out.println(obj.getName());  
•     }  
•       
•     public static void main(String[] args)  
•     {  
•         Parent objP = new Parent();  
•          
•         objP.doSomething(new A()); // 传递A的引用，则调用的是A类的getName方法  
•         objP.doSomething(new B()); // 传递B的引用，则调用的是B类的getName方法  
•     }  
• }  
•   
• class A extends Parent  
• {  
•     private String name = "class A";  
•       
•     //@重写getName()方法  
•     public String getName()  
•     {  
•         return this.name;  
•     }  
• }  
•   
• class B extends Parent  
• {  
•     private String name = "class B";  
•       
•     //@重写getName()方法  
•     public String getName()  
•     {  
•         return this.name;  
•     }  
• }  
  

可见，父类的doSomething方法多态地调用了我们传递的对象的getName方法，而不是Parent类本身的getName方法。

2、Java中的接口

Java中的接口，是一系列方法的声明。一个接口只有方法的特征，而没有方法的实现。这些方法可以从别处通过特定的类来实现。在Java中，用关键字interface来声明一个接口。

用接口实现多态的实例：

[java] view plaincopyprint?

• interface Name  
• {  
•     //只声明，不实现  
•     public String getName();  
• }  
•   
• class A implements Name  
• {  
•     private String name = "class A";  
•       
•     //实现getName方法  
•     public String getName()  
•     {  
•         return name;  
•     }  
• }  
•   
• class B implements Name  
• {  
•     private String name = "class B";  
•       
•     //实现getName方法  
•     public String getName()  
•     {  
•         return name;  
•     }  
•       
•     public static void main(String[] args)  
•     {  
•         Name obj = new A();  
•         System.out.println(obj.getName());  
•     }  
• }  
  

可以看到，打印出了类A的名字class A。

楼主你好，如果问题已解决请将帖子状态修改为提问结束，
如果未解决请继续追问，谢谢合作
修改方法请看解释帖：http://bbs.itheima.com/thread-89313-1-1.html

起猿 发表于 2013-10-29 23:04
多态，是面向对象的程序设计语言最核心的特征。封装性、继承性都比较简单，所以这里只对多态做一个小小的笔 ...

师兄,子类继承父类
子类就有了父类的方法
那子类中和父类参数列表不同的同名函数不算重载?
那是什么?
还有,父类中的私有方法,子类继承了吗?
我很迷惑....

父类的私有成员（变量和方法），只能被子类覆盖，无法被继承。