java基础--泛型

Posted 2020-10-14 周无极

一. 泛型概念的提出（为什么需要泛型）？

首先，我们看下下面这段简短的代码: 

  public class GenericTest {

     public static void main(String[] args) {
        List list = new ArrayList();
        list.add("qqyumidi");
         list.add("corn");
         list.add(100);
       for (int i = 0; i < list.size(); i++) {
            String name = (String) list.get(i); // 1
           System.out.println("name:" + name);
       }
    }
 }

在如上的编码过程中，我们发现主要存在两个问题：

1.当我们将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。

2.因此，//1处取出集合元素时需要人为的强制类型转化到具体的目标类型，且很容易出现“java.lang.ClassCastException”异常。

二.什么是泛型？

     泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此       时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

三.泛型的使用

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法 

3.1  泛型类

  T Type 表示类型。
  K V 分别代表键值中的Key Value。
  E 代表Element。

注意：
    1、泛型只能使用引用类型，不能基本类型
    2、在泛型类里，泛型声明时字母不能使用 静态属性|静态方法上，在泛型方法上可以声明在方法上

package com.zwj.fanxing;
/**
 * 泛型类:声明时使用泛型
 * 字母：
 *  T  Type 表示类型。 
    K V 分别代表键值中的Key Value。 
    E 代表Element。 
 使用时确定类型
 注意：
 1、泛型只能使用引用类型，不能基本类型
 2、泛型声明时字母不能使用 静态属性|静态方法上
 * @author Administrator
 *
 * @param <T>
 */
public class Student<T1,T2> {
    private T1 javaScore;
    private T2 oracleScore;
    
    //泛型声明时不能使用 静态属性|静态方法上
    //private static T1 test;
    
    
    public T1 getJavaScore() {
        return javaScore;
    }




    public void setJavaScore(T1 javaScore) {
        this.javaScore = javaScore;
    }




    public T2 getOracleScore() {
        return oracleScore;
    }




    public void setOracleScore(T2 oracleScore) {
        this.oracleScore = oracleScore;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        //使用时指定类型(引用类型)
        Student<String,Integer> stu = new Student<String,Integer> ();
        //1、安全：类型检查
        stu.setJavaScore("优秀");
        //2、省心:类型转换
        int it =stu.getOracleScore(); //自动拆箱
    }

}

Student<T1,T2> 泛型类:声明时使用泛型

 

3.2 泛型接口、

package com.zwj.fanxing;
/**
 * 接口中 泛型字母只能使用在方法中，不能使用在全局常量中
 * @author Administrator
 *
 * @param <T>
 */
public interface Comparator<T> {
    void compare(T t);    
}

Comparator 接口中 泛型字母只能使用在方法中，不能使用在全局常量中

package com.zwj.fanxing;
/**
 * 泛型接口:与继承同理
 * 重写方法随父类而定
 *
 * @param <T>
 */
public interface package com.zwj.fanxing;
/**
 * 泛型接口:与继承同理
 * 重写方法随父类而定
 *
 * @param <T>
 */
public interface Comparable<T> {
    void compare(T t);
}

//声明子类指定具体类型
class Comp implements Comparable<Integer>{

    @Override
    public void compare(Integer t) {
        // TODO Auto-generated method stub
        
    }
    
}

//擦除
class Comp1 implements Comparable{

    @Override
    public void compare(Object t) {
        // TODO Auto-generated method stub
        
    }
     
}
//父类擦除，子类泛型
class Comp2<T> implements Comparable{

    @Override
    public void compare(Object t) {
        // TODO Auto-generated method stub
        
    }
     
}
//子类泛型>=父类泛型
class Comp3<T> implements Comparable<T>{

    @Override
    public void compare(T t) {
        // TODO Auto-generated method stub
        
    }
     
}
//父类泛型，子类擦除 错误{
    void compare(T t);
}

//声明子类指定具体类型
class Comp implements Comparable<Integer>{

    @Override
    public void compare(Integer t) {
        // TODO Auto-generated method stub
        
    }
    
}

//擦除
class Comp1 implements Comparable{

    @Override
    public void compare(Object t) {
        // TODO Auto-generated method stub
        
    }
     
}
//父类擦除，子类泛型
class Comp2<T> implements Comparable{

    @Override
    public void compare(Object t) {
        // TODO Auto-generated method stub
        
    }
     
}
//子类泛型>=父类泛型
class Comp3<T> implements Comparable<T>{

    @Override
    public void compare(T t) {
        // TODO Auto-generated method stub
        
    }
     
}
//父类泛型，子类擦除 错误

Comparable 泛型接口:与继承

 

 

 

3.3泛型方法 

 注：只能访问对象的信息，不能修改信息

package com.zwj.fanxing;
import java.io.Closeable;
import java.io.IOException;

/**
 * 泛型方法 <> 返回类型前面
 * 只能访问对象的信息，不能修改信息
 * @author Administrator
 *
 */
public class TestMethod {

    /**
     * @param args
     */
    public static void main(String[] args) {
        test("a"); //T -->String
    }
    //泛型方法
    public static <T> void test(T a){        
        System.out.println(a);
    }
    // extends <=
    public static <T extends Closeable> void test(T... a){        
        for(T temp:a){
            try {
                if(null!=temp){
                    temp.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

TestMethod 泛型方法 <> 返回类型前面