Java--泛型--概述&泛型类

  1. 什么是泛型:
    1. 我们使用ArrayList是如果不指定泛型,他会自动给我们转换为Object类型,当我们取出来的时候还是Object类型的对象,需要进行强制类型转换(如果我们在集合中加入了不同的对象,但是我们还是按照一种对象进行转换的话,容易造成类型转换异常),还会影响我们的执行效率
    2.  

    3. package com.model.fanxing;
      
      import java.util.ArrayList;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/6/30 13:48
       *
       * 演示泛型的引出背景
       */
      public class FanXingDemo01 {
          public static void main(String[] args) {
      
      //        当我们创建集合对象是,不指定泛型,它默认就是Object类型接受
              /*
              * Exception in thread "main" java.lang.ClassCastException:   类型转换异常
              * java.lang.Integer cannot be cast to java.lang.String
              * */
              ArrayList list = new ArrayList<>();  //接受Object类型的数据
              list.add("a");
              list.add(100);
              list.add(true);
              for (int i = 0; i < list.size(); i++) {
                  //存入的是不同的数据类型,取出的时候必须按照存入的类型进行转换,否则会发生类型转换异常
                  String s= (String) list.get(i); //当遍历的时候容易发生类型转换异常
                  System.out.println(s);
              }
      
      
      //        指定了泛型为String,则存入的数据只能是String类型的
      //      泛型的好处:
      //      编译期检查类型(避免了运行时类型转换异常)
      //      遍历时减少了数据类型转换,直接输出就可以了
              ArrayList<String> list1 = new ArrayList<>();
              list1.add("a");
              list1.add("b");
              list1.add("c");
      //        list1.add(100);  //不能存入其他的类型,且在编译阶段就会告诉我们这是错误的,避免了运行时的类型转换异常
      
              for (String s:list1){
                  System.out.println(s);
              }
              ArrayList<Integer> list2 = new ArrayList<>();  //泛型不支持基本数据类型,只能是引用的数据类型
              list2.add(100);
              list2.add(200);
              list2.add(300);
              for (int num:list2){  //自动拆箱的动作,将Integer类型拆箱为int类型
                  System.out.println(num);
              }
              
          }
      } 
  2. 泛型类
    1. package com.model.fanxing;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/6/30 14:32
       *
       *  演示泛型类的创建及使用
       *  T E K V
       *  T:泛型标识--类型参数
       *  T 创建对象的时候里指定的具体的数据类型
       *
       */
      public class FanXingDemo02 {
      
          public static void main(String[] args) {
      //        泛型类在创建对象时候,来指定操作的具体类型的数据
              Generic<String> strGeneric = new Generic<>(); //指定泛型类的类型为String类型
              strGeneric.setKey("张紫韩");
              System.out.println(strGeneric.getKey());
              System.out.println("------------------------------");
              Generic<Integer> integerGeneric = new Generic<>();
              integerGeneric.setKey(100);
              System.out.println(integerGeneric.getKey());
      
      //        Generic<int> generic=new Generic<int>();
      // 泛型不支持基本数据类型,他在内部处理的时候,会将数据都转换为Object,进行统一的处理,
      // 在适当的时机在转换为我们传入的泛型的类型,而基本数据类型不能转换为Object类型,所有不支持基本数据类型
      
      //        只定义了一个泛型类,却可以操做不同的数据类型的对象,代码复用,减少类型转换
      //        泛型类在创建对象时没有指定类型时,会自动认为时Object类型
      
              System.out.println(integerGeneric.getClass());
              System.out.println(strGeneric.getClass());
      //        根据不同的数据类型创建的不同的泛型类型对象,他们的Class类对象只有一个,是一样的,即运行时数据类型一样
              System.out.println(integerGeneric.getClass()==strGeneric.getClass());
          }
      }
      //声明一个泛型类
      class Generic<T>{
      //    T:是由外部实用类的时候来指定的
          private T key;
      
          @Override
          public String toString() {
              return "Generic{" +
                      "key=" + key +
                      '}';
          }
      
          public Generic() {
          }
      
          public T getKey() {
              return key;
          }
      
          public void setKey(T key) {
              this.key = key;
          }
      
          public Generic(T key) {
              this.key = key;
          }
      }
  3.  泛型类的使用--抽奖类

    1. package com.model.collection;
      
      import java.util.ArrayList;
      import java.util.Iterator;
      import java.util.List;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/6/11 9:19
       */
      public class CollectionDemo03 {
          public static void main(String[] args) {
              List<Object> list = new ArrayList<>();
              list.add(new Books(0,"三国",13.1));
              list.add(new Books(1,"水浒",13.2));
              list.add(new Books(2,"红楼",13.3));
      
              System.out.println("list"+list);
      
              /**
               * 第一种遍历的方式(iterator)
               * */
              Iterator<Object> iterator = list.iterator();
          /*
              while(iterator.hasNext()){
                  Books books = (Books) iterator.next();
                  System.out.println(books.toString());
              }
          */
              //使用快捷键的方式:itit 形成iterator遍历
      //          Ctrl + j  显示所有快捷键
              while (iterator.hasNext()) {
                  Object next =  iterator.next();
                  System.out.println(next);
              }
              // 当我们跳出while循环后,如果继续使用 iterator.next() 获取下一个元素的会抛出异常
      //        iterator.next();
      //        如果需要重新遍历集合需要重置我们的迭代器
              iterator=list.iterator();
              System.out.println("*******iterator第二次遍历*********");
              while (iterator.hasNext()) {
                  Object next =  iterator.next();
                  System.out.println(next);
      
              }
      
              /**
               * 第二种遍历的方式(增强for循环)
               *
               *  1.使用增强for循环,在Collection集合
               *  2.增强for循环底层仍然是  迭代器
               *  3.增强for循环是简化版本的迭代器遍历
               *  4.可以遍历数组和集合
               *  5.快捷键 I
               * */
      
              System.out.println("*******第二种遍历的方式*********");
              for (Object book:list){
                  System.out.println(book);
              }
      
              /*
              int[] num=new int[]{1,2,3,4,5,6};
              for(int i:num){
                  System.out.println(i);
              }*/
          }
      }
      class Books{
          private int id;
          private String name;
          private double price;
      
          @Override
          public String toString() {
              return "Books{" +
                      "id=" + id +
                      ", name='" + name + '\'' +
                      ", price=" + price +
                      '}';
          }
      
          public Books(int id, String name, double price) {
              this.id = id;
              this.name = name;
              this.price = price;
          }
      
          public int getId() {
              return id;
          }
      
          public void setId(int id) {
              this.id = id;
          }
      
          public String getName() {
              return name;
          }
      
          public void setName(String name) {
              this.name = name;
          }
      
          public double getPrice() {
              return price;
          }
      
          public void setPrice(double price) {
              this.price = price;
          }
      }
  4. 泛型类的派生子类

    1.  

      package com.model.fanxing;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/6/30 21:51
       */
      public class FanXingDemo04 {
      
          /**
           * 1.如果子类是泛型类,父类也是泛型类,我们的子类的泛型类型必须要和父类的泛型类型一致,否则会报错
           * 泛型类派生子类,子类也是泛型类,那么子类的泛型类标识要和父类的一样
           * 但是子类的泛型类型可以扩展
           *2.泛型类派生子类,如果子类不是泛型类,那么父类要明确具体的泛型类型,否则会报错
           * */
          public static void main(String[] args) {
              Son<String> son = new Son<>();
              son.setValue("张紫韩");
              System.out.println(son.getValue());
      
              Son01 son01 = new Son01();
              son01.setValue("张紫韩");
              System.out.println(son01.getValue());
          }
      }
      
      class Father<T>{
          private T value;
          @Override
          public String toString() {
              return "Father{" +
                      "value=" + value +
                      '}';
          }
      
          public void setValue(T value) {
              this.value = value;
          }
      
          public T getValue() {
              return value;
          }
      }
      class Son<T> extends Father<T>{ //子类的泛型类型要和父类的泛型类型一致,否则会报错
      
      
          @Override
          public String toString() {
              return super.toString();
          }
      }
      //class Son01 extends Father<T>{ } //错误的,当子类不是泛型类是,我们父类的泛型标识要换成具体的类型,如果还是泛型标识那是错误的
      class Son01 extends Father<String>{
      
      
          @Override
          public String toString() {
              return super.toString();
          }
      }  
posted @ 2021-06-30 22:26  张紫韩  阅读(188)  评论(0编辑  收藏  举报