感觉泛型和多态定义方法的话差不多啊

多态的话，我理解的是    父类接收子类对象，然后调用的话必须调用父类中有的方法，子类特有的无法调用。
泛型的话，我理解的是    <T>可以是任何类型，但是调用的话，也是不能调用某些类型特有的方法，比如String的 length()。

1. /*
   
2. 泛型方法
   
3. */
   
4. class GenericDemo3
   
5. {
   
6.         public static void main(String[] args)
   
7.         {
   
8.                 Demo d = new Demo();
   
9. 
   
10.                 d.show("ajslkdf");
    
11.                 d.show(new Integer(3));
    
12.         }
    
13. }
    
14. class Demo
    
15. {
    
16.         public <T> void show(T t)
    
17.         {
    
18.                 System.out.println("show:"+t);         //无法调用  t.length()
    
19.         }
    
20.         public <Q>void print(Q q)
    
21.         {        
    
22.                 System.out.println("print:"+q);
    
23.         }
    
24. }
    

复制代码

他们两个不就差不多了？
他俩的区别是什么？

什么时候用泛型？
什么时候用多态？





呵呵，可能自己这个想法有点另类吧，哈哈

个人认为多态和泛型没有什么关系。不知道楼主的构思和想法
对多态的看法：主要应该于子父类的继承以及接口中  要么继承，要么实现，而泛型跟这些好像联系不上...
多态的好处是出现大提高了程序的扩展性。
对泛型的看法：泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中， Java语言引入泛型的好处是安全。

在集合中使用泛型是比较常见的 List<T> Set<T> Map<K,V>

List<Integer> list = new List<Integer>();   //限定泛型以后集合成了具体类型, 就跟多态没什么关系了
for (Integer int : list)
{
    System.out.println(int);
}

刘学明　　　 发表于 2013-5-8 19:56
个人认为多态和泛型没有什么关系。不知道楼主的构思和想法
对多态的看法：主要应该于子父类的继承以及接口 ...

public <T> void show(T t)
        {
                System.out.println("show:"+t);   
        }

public void show(Object obj)
        {
                System.out.println("show:"+obj);     
        }

他们两个调用的话    show();//传什么都可以
他们两个不就一样了么？

表面上来看泛型和多态是相同，其实泛型是为了限制Object类这种多态的特性，特别是它带来的安全问题而产生的机制。
class MySet<T>
{
     public void show(T t)             //记住这里不要添加<T>，那是泛型的其他功能，造成的是该类和此方法将不再指向同一个泛型。
     {     System.out.println("show:" + t);
}}                    //上面这个是指定了泛型的；
class MyShow             //不添加泛型，直接使用Object类(即多态的特性)
{
     public void show(Object obj)
     {     System.out.println("show:" + obj);
}}   
当你在主函数创建这两个类时，泛型类可以对该类及其中的方法添加限制，比如:
MySet<String> ms = new MySet<String>();
那么通过 ms . show方法打印时将只能打印String类型。（你可以用代码测试下）
而普通类(Object的那个)就依然是什么都能够打印。

up.yfei 发表于 2013-5-8 20:15
public  void show(T t)
        {
                System.out.println("show:"+t);   

public <T> void show(T t)
        {
                System.out.println("show:"+t);   
        }

public void show(Object obj)  //  如果把Object改成别的呢 也就是说这里只有Object的时候才看起来是一样的？ 如果把Object换成其它引用 那这两个就完全不一样。。
他的应用不在这   可以看一下泛型和多态各自的作用和特点。
        {
                System.out.println("show:"+obj);     
        }

补充一点就是泛型更多的是用在处理类对象(存储多种不同的类，导致出现类型转换异常的情况。)
另外从上面可以看出泛型还有一点比多态强的地方(其实这功能也是Object类的，只不过是加了限制，让它变成可变的) :
在类、方法、接口中使用了泛型，那么在调用该方法等时定义了泛型，就将限制进入的对象(定Object，就什么都能装；定String，就将只能存储String类型)，
而使用多态特性的Object类就不行。（这样应该能理解吧，建议多用代码去测试下，加深自己的理解，当然也比较耗时间）