248/249定义和使用含有泛型的类和含有泛型的方法（1）

定义和使用含有泛型的类

我们在集合中会大量使用到泛型，这里来完整地学习泛型知识。

泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。

定义格式︰

　　修饰符class类名<代表泛型的变量>{}

　　　　例如，API中的ArrayList集合∶

　　class ArrayList<E>{

　　　　public boolean add(E e){ }

　　　　public E get(int index){

　　　　}

　　}

定义一个含有泛型的类,模拟Arraylist集合

泛型是一个未知的数据类型,当我们不确定什么什么数据类型的时候,可以使用泛型

泛型可以接收任意的数据类型,可以使用Integer , string, student. . .

class ArrayList<E>{ 
    public boolean add(E e){ }
 
    public E get(int index){ }
       ....

class ArrayList<String>{ 
     public boolean add(String e){ }
 
     public String get(int index){  }
     ...
}

public class MyGenericClass<MVP> {
    //没有MVP类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型
    private MVP mvp;
     
    public void setMVP(MVP mvp) {
        this.mvp = mvp;
    }
     
    public MVP getMVP() {
        return mvp;
    }
}

class ArrayList<Integer> { 
     public boolean add(Integer e) { }
 
     public Integer get(int index) {  }
     ...
}

public class MyGenericClass<MVP> {
    //没有MVP类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型
    private MVP mvp;
     
    public void setMVP(MVP mvp) {
        this.mvp = mvp;
    }
     
    public MVP getMVP() {
        return mvp;
    }
}

public class GenericClassDemo {
      public static void main(String[] args) {         
         // 创建一个泛型为String的类
         MyGenericClass<String> my = new MyGenericClass<String>();        
         // 调用setMVP
         my.setMVP("大胡子登登");
         // 调用getMVP
         String mvp = my.getMVP();
         System.out.println(mvp);
         //创建一个泛型为Integer的类
         MyGenericClass<Integer> my2 = new MyGenericClass<Integer>(); 
         my2.setMVP(123);         
         Integer mvp2 = my2.getMVP();
    }
}

package com.learn.demo03.Generic;
/*
    定义一个含有泛型的类,模拟ArrayList集合
    泛型是一个未知的数据类型,当我们不确定什么什么数据类型的时候,可以使用泛型
    泛型可以接收任意的数据类型,可以使用Integer,String,Student...
    创建对象的时候确定泛型的数据类型
 */
public class GenericClass<E> {
    private E name;
 
    public E getName() {
        return name;
    }
 
    public void setName(E name) {
        this.name = name;
    }
}

package com.learn.demo03.Generic;
 
public class Demo02GenericClass {
    public static void main(String[] args) {
        //不写泛型默认为Object类型
        GenericClass gc = new GenericClass();
        gc.setName("只能是字符串");
        Object obj = gc.getName();
 
        //创建GenericClass对象,泛型使用Integer类型
        GenericClass<Integer> gc2 = new GenericClass<>();
        gc2.setName(1);
 
        Integer name = gc2.getName();
        System.out.println(name);
 
        //创建GenericClass对象,泛型使用String类型
        GenericClass<String> gc3 = new GenericClass<>();
        gc3.setName("小明");
        String name1 = gc3.getName();
        System.out.println(name1);
    }
}

 

定义和使用含有泛型的方法

定义格式:

修饰符<代表泛型的变量>返回值类型方法名(参数){ }

 

定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间格式:

　　修饰符<泛型>返回值类型方法名(参数列表(使用泛型)){　　
　　　　方法体;
　　}
含有泛型的方法,在调用方法的时候确定泛型的数据类型传递什么类型的参数,泛型就是什么类型

 

 

package demo01;
/*
  测试含有泛型的方法
*/
public class Demo05GenericMethod {
    public static void main(String[] args) {
        //创建GenericMethod对象
        GenericMethod g=new GenericMethod();
        /*
          调用含有泛型的方法method01
          传递什么类型，泛型就是什么类型
        */
        g.method01(22);
        g.method01("jj");
        g.method01(0.90);
        g.method01(false);

        g.method02("静态方法，不建议创建对象使用");
        //静态方法，通过类名.方法名(参数)可以直接使用
        GenericMethod.method02("静态方法");
        GenericMethod.method02("yy");

    }
}

package demo01;

public class GenericMethod {
    //定义一个含有泛型的方法
    public <M> void method01(M m){
        System.out.println(m);

    }
    //定义一个含有泛型的静态方法
    public static  <S> void method02(S s){
        System.out.println(s);

    }
}