Java之路---Day16(泛型)

2019-11-02-23:25:26

目录

　　1.泛型的概念:

　　2.泛型的定义和使用:

　　　　2.1定义和使用含有泛型的类：

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

　　　　2.3定义和使用含有泛型的接口：

---

泛型的概念:

　　泛型是一种未知的数据类型,当我门不知道使用什么数据类型的时候,可以使用泛型,泛型也可以看成是一个变量,用来接受数据类型

　　E e:Element 元素

　　T t:Type 类型

泛型的定义和使用:

　　我们在集合中会大量使用到泛型,用来灵活地将数据类型应用到不同的类、方法、接口当中，将数据类型作为参数进行传递

　　定义和使用含有泛型的类：

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

 package demosummary.generic;

 public class GenericClass<E> {
     private E name;

     public GenericClass() {
     }

     public GenericClass(E name) {
         this.name = name;
     }

     public E getName() {
         return name;
     }

     public void setName(E name) {
         this.name = name;
     }

     @Override
     public String toString() {
         return "GenericClass{" +
                 "name=" + name +
                 '}';
     }
 }

 package demosummary.generic;

 public class GenericClassTest {
     public static void main(String[] args) {
         //不写泛型则默认为Object类
         GenericClass gc = new GenericClass();
         gc.setName("默认为Object类");
         Object obj = gc.getName();
         System.out.println(obj);

         //使用泛型为Integer类
         GenericClass<Integer> gci = new GenericClass<>();
         gci.setName(1);
         Integer integer = gci.getName();
         System.out.println(integer);
     }
 }

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

　　　　格式：修饰符<泛型> 返回值类型 方法名（参数列表（使用泛型））{

　　　　　　语句体;

　　　　}

　　注意：含有泛型的方法，在调用方法的时候确定泛型的数据类型，传递什么类型的参数，泛型就是什么类型

 package demosummary.generic;

 public class GenericMethod {
     //定义一个含有泛型的方法
     public <E> void method(E e){
         System.out.println(e);
     }

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

 package demosummary.generic;

 public class GenericMethodTest {
     public static void main(String[] args) {
         //创建一个GenericMethod对象
         GenericMethod gm = new GenericMethod();
         gm.method(1);//传入Integer类型
         gm.method("字符串");//传入String类型
         gm.method(1.1);//传入Float类型
         gm.method(true);//传入Boolean类型

         //静态方法建议通过类名调用
         GenericMethod.method01(2);//传入Integer类型
         GenericMethod.method01("静态方法");//传入String类型
     }
 }

　　定义和使用含有泛型的接口：

　　　　格式：

　　　　　　修饰符 interface接口名<代表泛型的变量>{ }

　　　　第一种使用方式：

　　　　　　定义接口的实现类，实现接口，指定接口的泛型

　　　　第二种使用方式：

　　　　　　接口使用什么泛型，实现类就使用什么泛型，类跟着接口走

 package demosummary.generic;
 //定义一个抽象类
 public interface GenericInterface<E> {
     //创建一个抽象方法
     public void method(E e);
 }

 package demosummary.generic;

 public class GenericInterface01 implements GenericInterface<String>{
     //重写抽象方法
     @Override
     public void method(String s) {
         System.out.println(s);
     }
 }

 package demosummary.generic;

 public class GenericInterface02<E> implements GenericInterface<E>{
     //重写抽象类中的抽象方法
     @Override
     public void method(E e) {
         System.out.println(e);
     }
 }

 package demosummary.generic;

 public class GenericInterfaceTest {
     public static void main(String[] args) {
         //创建一个GenericInterface01对象,指定实现类泛型为String类型
         GenericInterface01 gi01 = new GenericInterface01();
         gi01.method("泛型指定为字符串");

         //创建一个GenericInterface02对象,接口泛型为Integer类型,实现类也为Integer类型
         GenericInterface02<Integer> gi02 = new GenericInterface02<>();
         gi02.method(2);

         //创建一个GenericInterface02对象,接口泛型为String类型,实现类也为String类型
         GenericInterface02<String> gi021 = new GenericInterface02<>();
         gi021.method("接口为什么泛型,实现类就是什么泛型");
     }
 }