java基础--泛型

例子1

package com.atguigu.java;

import org.junit.Test;

import java.util.*;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 18:23
 */
public class GenericTest {

    //在集合中使用泛型之前的情况
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        //需求：存放学生的成绩
        list.add(78);
        list.add(76);
        list.add(89);
        list.add(88);

        //问题一：类型不安全
        list.add("Tom");

        //问题二：强转时，可能出现ClassCastException
        for(Object score:list){
            int stuScore= (Integer) score;
            System.out.println(stuScore);
        }
    }

    //在集合中使用泛型的情况

    @Test
    public void test2(){
        ArrayList<Integer> list = new ArrayList<Integer>();

        list.add(78);
        list.add(76);
        list.add(89);
        list.add(88);
        //编译时，就会进行类型检查，保证数据的安全
        //list.add("Tom");

        //方式一：遍历list
//        for(Integer score:list){
//            int stuScore = score;
//            System.out.println(stuScore);
//        }

        //方式2；
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()){
            int stuScore = iterator.next();
            System.out.println(stuScore);
        }

    }

    //在集合中使用泛型的情况：以HashMap为例
    @Test
    public void test3(){

        HashMap<String, Integer> map = new HashMap<String,Integer>();

        map.put("Tom",87);
        map.put("Jerry",87);
        map.put("Jack",67);

        //泛型的嵌套
        Set<Map.Entry<String, Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();

        while(iterator.hasNext()){
            Map.Entry<String, Integer> e = iterator.next();
            String key = e.getKey();
            Integer value = e.getValue();
            System.out.println(key);
            System.out.println(value);
        }
    }

}

例子2

order

package com.atguigu.java;

/**
 * 自定义泛型类
 * @author shkstart
 * @create 2021-12-{DAY} 18:52
 */
public class Order<T> {

    String orderName;
    int orderId;

    T orderT;

    public Order() {
    }

    public Order(String orderName, int orderId,T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT=orderT;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public int getOrderId() {
        return orderId;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }

    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
}

SubOrder

package com.atguigu.java;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 19:03
 */
public class SubOrder extends Order<Integer>{
//SubOrder不再是一个泛型类，而是一个普通类

}

SubOrder1

package com.atguigu.java;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 19:07
 */
public class SubOrder1<T> extends Order<T>{

//SubOrder1任然是一个泛型类
}

GenericTest

package com.atguigu.java;

import org.junit.Test;

import java.util.*;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 18:23
 */
public class GenericTest {

    //在集合中使用泛型之前的情况
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        //需求：存放学生的成绩
        list.add(78);
        list.add(76);
        list.add(89);
        list.add(88);

        //问题一：类型不安全
        list.add("Tom");

        //问题二：强转时，可能出现ClassCastException
        for(Object score:list){
            int stuScore= (Integer) score;
            System.out.println(stuScore);
        }
    }

    //在集合中使用泛型的情况

    @Test
    public void test2(){
        ArrayList<Integer> list = new ArrayList<Integer>();

        list.add(78);
        list.add(76);
        list.add(89);
        list.add(88);
        //编译时，就会进行类型检查，保证数据的安全
        //list.add("Tom");

        //方式一：遍历list
//        for(Integer score:list){
//            int stuScore = score;
//            System.out.println(stuScore);
//        }

        //方式2；
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()){
            int stuScore = iterator.next();
            System.out.println(stuScore);
        }

    }

    //在集合中使用泛型的情况：以HashMap为例
    @Test
    public void test3(){

        HashMap<String, Integer> map = new HashMap<String,Integer>();

        map.put("Tom",87);
        map.put("Jerry",87);
        map.put("Jack",67);

        //泛型的嵌套
        Set<Map.Entry<String, Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();

        while(iterator.hasNext()){
            Map.Entry<String, Integer> e = iterator.next();
            String key = e.getKey();
            Integer value = e.getValue();
            System.out.println(key);
            System.out.println(value);
        }
    }

}

GenericTest1

package com.atguigu.java;

import org.junit.Test;

/**
 * @author shkstart
 * @create 2021-12-{DAY} 18:56
 */
public class GenericTest1 {

    @Test
    public void test1(){
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
        //要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型
        Order order = new Order();
        order.setOrderT(123);
        order.setOrderT("ABC");

        //建议：实例化时指明类的泛型
        Order<String> order1 = new Order<>("orderAA",123,"order:AA");

        order1.setOrderT("AA:hello");
    }

    @Test
    public void test2(){
        SubOrder sub1 = new SubOrder();
        //由于子类在继承带泛型的父类时，指明了泛型类型，则实例化子类对象时，不再需要指明泛型
        sub1.setOrderT(1122);

        SubOrder1<String> sub2 = new SubOrder1<String>();
        sub2.setOrderT("order2...");

    }



}