Java--集合之泛型

一、泛型定义

• Java泛型是 JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递
• 常见形式有泛型类、泛型接口、泛型方法。
• 语法：<T,...> T称为类型占位符，表示一种引用类型 (T也可以写为E K V)
• 好处：提高代码的重用性；防止类型转换异常，提高代码的安全性

二、泛型类

　　语法：类名<T>

package com.monv.generic;
/**
 * 泛型类
 * 语法：类名<T>
 * T是类型占位符，表示一种引用类型，如果编写多个用逗号隔开
 * @author Administrator
 *
 */
public class MyGeneric<T> {
    //使用泛型T
    //1.创建变量
    T t1;
    
    //2.泛型作为方法的参数
    public void show(T t){
   //这里只能创建变量 不能实例化 因为不知道T具体的类型是什么 不知道其构造方法是共有的还是私有的，有没有无参构造        
//        T t1 = new T(); 
        System.out.println(t);
    }
    //3.泛型作为方法的返回值
    public T getT(){
        return t1;
    }
}

--------------------------------------------------------
package com.monv.generic;

public class TestGeneric {
    public static void main(String[] args) {
        //使用泛型类来创建对象
        //注意：1.泛型只能是引用类型 2.不同泛型类型对象之间不能相互赋值
        MyGeneric<String> myGeneric = new MyGeneric<String>();
        myGeneric.t1 = "hello";
        myGeneric.show("java");
        String s1=myGeneric.getT();
        
        MyGeneric<Integer> myGeneric2 = new MyGeneric<Integer>();
        myGeneric2.t1 = 150;
        myGeneric2.show(300);
        myGeneric2.getT();
        
}

三、泛型接口

　　语法：接口名<T>

package com.monv.generic;
/**
 * 泛型接口
 * 语法：接口名<T>
 * 注意：不能使用泛型创建静态常量
 * @author Administrator
 *
 */

public interface MyInterface<T> {
    String name = "张三";
    
    T Service(T t);//抽象方法

}
--------------泛型接口实现方法1-------------------------------
package com.monv.generic;

public class MyInterfaceImpl implements MyInterface<String>{
    
    @Override
    public String Service(String t) {
        // TODO Auto-generated method stub
        System.out.println(t);
        return t;
    }
}
--------------泛型接口实现方法2-------------------------------
package com.monv.generic;
/**
 * 实现类也定义成泛型类
 */
public class MyInterfaceImpl2<T> implements MyInterface<T>{
    @Override
    public T Service(T t) {
        // TODO Auto-generated method stub
        System.out.println(t);
        return t;
    }
}
-------------------测试实例--------------------------------
package com.monv.generic;

public class TestGeneric {
    public static void main(String[] args) {
        //泛型接口
        MyInterfaceImpl myInterfaceImpl = new MyInterfaceImpl();
        myInterfaceImpl.Service("大家好！！");
        
        MyInterfaceImpl2<String> myInterfaceImpl2 = new MyInterfaceImpl2<String>();
        myInterfaceImpl2.Service("java世界！");
        
        MyInterfaceImpl2<Integer> myInterfaceImpl3 = new MyInterfaceImpl2<Integer>();
        myInterfaceImpl3.Service(200);

    }
}

四、泛型方法

　　语法：<T>方法返回值类型

package com.monv.generic;
/**
 * 泛型方法
 * 语法：<T>方法返回值类型
 */
public class MyGenericMethod {
    //泛型方法   T作为方法的返回类型
    public <T> T show(T t){
        System.out.println("泛型方法 "+t);
        return t;
    }
}--------------测试实例--------------------------------
package com.monv.generic;

public class TestGeneric {
    public static void main(String[] args) {
        //泛型方法  类型不需要传递，类型由传递的值的类型来决定
        MyGenericMethod myGenericMethod = new MyGenericMethod();
        myGenericMethod.show("Hello World");
        myGenericMethod.show(205);
        myGenericMethod.show(3.415);
    }
}

五、泛型集合

概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致。

特点：编译时即可检查，而非运行时抛出异常

访问时不必类型转换(拆箱)。

不同泛型之间引用不能相互赋值，泛型不存在多态

package com.monv.generic;

public class Student {
    String name;
    Integer age;
    
    public Student() {
        // TODO Auto-generated constructor stub
    }       
    
    public Student(String name, Integer age) {
        super();
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    
}
-----------------------------------------------------------
package com.monv.generic;

import java.util.ArrayList;
import java.util.Iterator;public class Demo {
    public static void main(String[] args) {
        //ArrayList 也是泛型类 在用的时候没有传递类型 默认的是Object类 可以Add任何类型的数据
        ArrayList arrayList = new ArrayList();
        arrayList.add("XXX");
        arrayList.add("YYY");
        arrayList.add(10);
        arrayList.add(30);
        //arrayList2 在创建的时候传递了类型为 String 所以在Add的时候只能添加String型的数据
        ArrayList<String> arrayList2 = new ArrayList<String>();
        arrayList2.add("XXX");
        arrayList2.add("YYY");
//        arrayList2.add(10);
        for (String string : arrayList2) {
            System.out.println(string);
        }
        
        ArrayList<Student> arrayList3 = new ArrayList<Student>();
        Student s1 = new Student("小乐", 18);
        Student s2 = new Student("小明", 19);
        Student s3 = new Student("小花", 19);
        arrayList3.add(s1);
        arrayList3.add(s2);
        arrayList3.add(s3);
//        arrayList3.add("111");//只能添加Student类型的 添加String类型的就会报错
        
        Iterator<Student> it = arrayList3.iterator();
        while(it.hasNext()){
            Student str = it.next();
            System.out.println(str.toString());
        }
        
    }
}