Java_泛型

泛型

定义类、接口、方法时、同时声明了一个或多个类型变量（如：）称为泛型类、泛型接口、泛型方法、他们统称为泛型。

   
  public class Test1{
       public static void main(String []args)
       {
          // 目标：认识泛型
          ArrayList list = new ArrayList();
          list.add("java1");
          list.add("java2");
          list.add("java3");
          list.add("java4");
          //list.add(new Cat());利用强制类型转换
         for(int i=0;i<list.size();i++)
         {
             String e = (String) list.get(i);
             System.out.println(e);
         }     


        System.out.println("-------------------------------");
             ArrayList<String> list1 = new ArrayList<String> ();
             ArrayList<String> list1 = new ArrayList<>();//JDK 1.7开始，后面的数据类型可以不声明
             list1.add("java1");
             list1.add("java2");
             list1.add("java3");
             //list1.add(new Cat()); //报错格式不符
             for(int i=0;i<list.size();i++)
             {
                String e = list1.get(i);
                System.out.println(e);
             }
             
       }
  }
  class Cat{
  }
  

作用：泛型提供了在编译阶段约束所能操作的数据类型，并自动进行检查的能力！这样可以避免强制类型转换，及其可能出现的异常。

泛型的本质 ：把具体的数据类型作为参数传给类型变量。

自定义泛型类 、自定义泛型接口、自定义泛型方法

泛型类

 修饰符 class 类名<类型变量，类型变量，...>{
 }

public class ArrayList<E>{
...
}

    
    public class Test{
        public static void main(String []args)
        {
             //目标：掌握泛型类的定义和使用。
             MyArrayList list = new MyArrayList<>();
             list.add("java1");
             list.add("java2");
             list.add("java3");
             String ele = list.get(1);
             System.out.println(ele);

       MyClass2<Cat,String > c2  = new MyClass2<>();
             
        }
    }

   
   public class MyArrayList<E>
   {
     private Object [] arr = new Object[10];
     private int size;//记录当前位置
     
       public boolean add(E e)
       {
         arr[size++] = e;
        return true;
        
       }
       public E get(int index)
       {
          return reutrn (E) arr[index];
       }
   }

   泛型类的 两种类型
   public class MyClass2<E,T>
   {
     public void put(E e,T t)
     {
     
     }
   }

    public class MyClass3<E extends Animal>{

     }

泛型接口

 修饰符interface  接口名<类型变量,类型变量,..> {
 
 }
 public interface A <E>{
 ...
 
 }  
 

注意：类型变量建议用大写字母，常用的有：E、T、K、V 等

  public class Test{
     public static void main(String []args)
     {
        //目标：掌握泛型接口的定义和使用。
        //场景：系统需要处理学生和老师的数据，需要提供两个功能：保存对象和查询功能。
        
     }
  }
//泛型接口
public  interface Data<T>
{
    void add(T t);
    ArrayList<T>  getByName(String name);
    
     }

public class StudentData implements Data<Student>
{
   @Override 
   public void add(Student student)
   {
   
   }
   @Override
   public ArrayList<Student> getByName(String name)
   {
     return null;
     
   }
}

泛型方法、泛型通配符、上下限

   修饰符 <类型变量,类型变量,...> 返回值类型 方法名 (形参列表){
   
   }
   //示例
   public static void test(T t){
   
   }

   public class Test{
     public static void main(String []args)
     {
         //目标：掌握泛型方法的定义和使用
         String rs= test("java");
         System.out.println(rs);
         
         Dog d = test(new Dog());
         System.out.println(d);

    //需求：所有的汽车可以一起参加比赛。
    ArrayList<Car> cars = new ArrayList<>();
    cars.add(new BMW());
    cars.add(new BENZ());
    go1(cars);

     ArrayList<BMW> bmws = new ArrayList<>();
     bmws.add(new BMW());
     bmws.add(new BMW());
     bmws.add(new BMW());
     go1(bmws);

     ArrayList<BENZ> benzs = new ArrayList<>();
     benzs.add(new BENZ());
     benzs.add(new BENZ());
     go1(benzs);
    
     }
     public static void go(ArrayList<Cat> cars)
     {
        
     }
   }
//泛型方法
public static <T> test(T t)
{
   return t;
}
//定义泛型参数
public static <T extends Car> void go1(T t)
{
   return t;
}
//？通配符，在使用泛型的时候可以代表一切类型 ？extends Car(上限) super(下限)
public static void go(ArrayList<? extends Car> cars)
{

}

public static void go(ArrayList<? super Car> cars)
{

}

泛型的注意事项：擦除问题、基本数据类型问题

泛型是工作在编译阶段的，一旦程序编译成class 文件，class文件中就不存在泛型了，这就是泛型擦除。

泛型不支持基本数据类型，只能支持对象类型(引用数据类型)。

    public class  Test{
        public static void main(String []args)
        {
             //目标：理解泛型的注意事项。
             //1、泛型是工作在编译阶段的，一旦程序编译成class文件，class文件就不存在泛型了，这就是泛型擦除。
             ArrayList<String> list = new ArrayList<>();
             list.add("java1");
             list.add("java2");
             list.add("java3");
             String rs = list.get(2);
             System.out.println(rs);
//2.泛型不支持基本数据类型，只能支持对象类型(引用数据 类型)。
   //ArrayList<int> list2 = new ArrayList<>();
   //ArrayList<double> list1 = new ArrayList<>();
   ArrayList<Integer> list1 = new ArrayList<>();

   list1.add(12);

   ArrayList<double> list2 = new ArrayList<>();
   list2.add(23.3);
    
     
        }
    }