泛型

package com.bjsxt.gen02;

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();
            }
        }
    }
}

package com.bjsxt.gen02;
/**
 * 泛型类:声明时使用泛型
 * 字母：
 * 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(); //自动拆箱
    }

}

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

package com.bjsxt.gen03;
/**
 * 父类为泛型类
 * 1、属性
 * 2、方法
 * 
 * 要么同时擦除，要么子类大于等于父类的类型,
 * 不能子类擦除，父类泛型
 * 1、属性类型
 *  父类中，随父类而定
 *  子类中，随子类而定
 * 2、方法重写:
 *  随父类而定
 * 
 * 
 * @author Administrator
 *
 * @param <T>
 */
public abstract class Father<T,T1> {
    T name;
    public abstract void test(T t);
}
/**
 * 子类声明时指定具体类型
 * 属性类型为具体类型
 * 方法同理
 */
class Child1 extends Father<String,Integer>{
    String t2;
    @Override
    public void test(String t) {
    }    
}
/**
 * 子类为泛型类 ,类型在使用时确定
 * @author Administrator
 *
 */
class Child2<T1,T,T3> extends Father<T,T1>{
    T1 t2;

    @Override
    public void test(T t) {
        
    }
}
/**
 * 子类为泛型类，父类不指定类型 ,泛型的擦除，使用Object替换
 */
class Child3<T1,T2> extends Father{
    T1 name2;
    @Override
    public void test(Object t) {
        // TODO Auto-generated method stub        
    }
}
/**
 * 子类与父类同时擦除
 */
class Child4 extends Father{
    String name;    
    @Override
    public void test(Object t) {
        
    }
}
/**
 *错误:子类擦除，父类使用泛型
class Child5 extends Father<T,T1>{
    String name;    
    @Override
    public void test(T t) {
        
    }
*/

package com.bjsxt.gen03;
/**
 * 泛型接口:与继承同理
 * 重写方法随父类而定
 *
 * @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
        
    }
     
}
//父类泛型，子类擦除 错误

package com.bjsxt.gen03;
/**
*泛型的擦除
*1、继承|实现声明 不指定类型
*2、使用时 不指定类型 
*统一Object 对待 
*1、编译器警告 消除使用Object
*2、不完全等同于Object ,编译不会类型检查
 * @author Administrator
 *
 * @param <T>
 */
public class Student<T> {
    private T javaScore;
    private T oracleScore;
    
    //泛型声明时不能使用 静态属性|静态方法上
    //private static T1 test;
    
    
    public T getJavaScore() {
        return javaScore;
    }




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




    public T getOracleScore() {
        return oracleScore;
    }




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

    /**
     * @param args
     */
    public static void main(String[] args) {
        Student stu1 = new Student(); 
        //消除警告 使用 Object
        Student<Object> stu = new Student<Object>(); 
        //stu.setJavaScore("af"); //以Object对待
        
        test(stu1); //stu1 相当于Object 但是不完全等同Object
        //擦除，不会类型检查
        //test(stu);
        test1(stu1);
        test1(stu);
        
    }
    
    public static  void test(Student<Integer> a){
        
    }
    public static  void test1(Student<?> a){
        
    }
    }

package com.bjsxt.gen04;

public class Fruit {

}
class Apple extends Fruit{
    
}

package com.bjsxt.gen04;
/**
 * 多态的两种形式
 * @author Administrator
 *
 */
public class FruitApp {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Fruit f =new Apple();
        test(new Apple());
    }
    //形参使用多态
    public static void test(Fruit f){
        
    }
    //返回类型使用多态
    public static Fruit  test2(){
        return new Apple();
    }

}

package com.bjsxt.gen04;
//泛型类
public class A<T> {

}

 

package com.bjsxt.gen04;
/**
 * 泛型没有多态
 * @author Administrator
 *
 */
public class App {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //A<Fruit> f = new A<Apple>();
        A<Fruit> f =new A<Fruit>();
        //test(new A<Apple>());
    }
    //形参使用多态
    public static void test(A<Fruit> f){
        
    }
    //返回类型使用多态
    public static A<Fruit>  test2(){
        //return (A<Fruit>)(new A<Apple>());
        return null;
    }
}

如果想使用怎么办

package com.bjsxt.gen04;
/**
 * 通配符
 * ?类型不定，使用时确定类型
 * ?使用:声明类型|声明方法上，不能声明类或使用时
 * ? extends : <= 上限  指定类型 子类或自身
 * ? super :>=下限   指定类型 为自身或父类
 * @author Administrator
 *
 */
public class Student<T> {
    T score;
    
    
    
    
    public static void main(String[] args) {
        //只能在声明的时候使用

        Student<?> stu = new Student<String>();
        test(new Student<Integer>());
        
        test2(new Student<Apple>());
        //test3(new Student<Apple>()); //泛型没有多态        
        
        //test4(new Student<Apple>()); //<
         stu  = new Student<Fruit>();;
        //test4(stu); //使用时确定类型
        test4(new Student<Object>());
        test4(new Student<Fruit>());
        
    }
    
    public static void test(Student<?> stu){
        
    }
    public static void test3(Student<Fruit> stu){
        
    }
    // <=
    public static void test2(Student<? extends Fruit> stu){
        
    }
    //>=
    public static void test4(Student<? super Fruit> stu){
        
    }
    
}

 

 

package com.bjsxt.gen04;

public class Bjsxt <T>{
 T stu ;
 
 
 public static void main(String[] args) {
     //泛型的嵌套 
     Bjsxt<Student<String>> room =new  Bjsxt<Student<String>>();
     //从外到内拆分
     room.stu = new Student<String>();
     Student<String> stu = room.stu;
     String score =stu.score;
     System.out.println(score);
}
}

 

 

package com.bjsxt.gen04;
/**
 * 没有泛型数组
 * 声明可以使用，但是创建失败
 * @author Administrator
 *
 */
public class Array {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Integer[]  arr = new Integer[4]; 
        //Student<String>[] arr2 = new Student<String>[10];
        Student<?>[] arr2 = new Student[10];
        
        MyArrayList<String> strList =new MyArrayList<String>();
        strList.add(0, "a");
        String elem =strList.getElem(0);
        System.out.println(elem);
        
        
    
        
    }

}
class MyArrayList<E>{
    //E[] cap =new E[10]; 没有泛型数组
    Object[] cap = new Object[10];
    
    public void add(int idx,E e){
        cap[idx] =e;
    }
    
    
    @SuppressWarnings("unchecked")
    public E[] getAll(){
        return (E[]) cap;
    }
    @SuppressWarnings("unchecked")
    public E getElem(int idx){
        return (E) cap[idx];
    }
}

 

 

 

package com.bjsxt.gen04;

import java.util.ArrayList;
import java.util.List;

/**
 * 1.7中使用泛型，声明一次类型即可
 * 在使用|创建时不用指定类型
 * @author Administrator
 *
 */
public class Test7 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        List<String>  arrList= new ArrayList<String>();
        //List<String>  arrList2= new ArrayList<>();
    }

}