【java】javaSE知识梳理-泛型

package javaLang.reflect.generic.methods;

import org.junit.Before;
import org.junit.Test;

import java.util.*;

/**
 * @author ChenDan
 * @create 2021-05-23
 * 为什么用泛型
     * 不加泛型，对象可以是多种数据类型，会出现数据异常ClassCastException
 * 泛型有什么特性
     * 实例化泛型如果指定数据类型，不同数据类型不能互相赋值;若不指定，默认为java.Lang.Object
     * 实例化泛型可以缩写：CollName<DateType> paraName = new CollName<>();
     * 集合类都使用的是泛型结构
     * 异常中不可使用泛型
 */
public class GenericTest {
    ArrayList list = new ArrayList();
    ArrayList<String> list1 = new ArrayList<>();
    ArrayList<Integer> list2 = new ArrayList<>();
    Map<String, Integer> map = new HashMap<>();

    @Test
    public void test() {
        list.add(123);
        list.add("123");  // 不加泛型，对象可以是多种数据类型，会出现数据异常

//        list1.add(123); // 加了泛型，只能是实例化的指定数据类型
//        list1.add(list2);  //不同数据类型不能互相赋值

        Set<Map.Entry<String, Integer>> entries = map.entrySet();  // map泛型应用
        Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }

    }

    @Before
    public void test1() {
        map.put("Ross",1);
        map.put("Joey",2);
        map.put("Chandler",3);
        map.put("Phoebe",4);
    }
}

package javaLang.reflect.generic.methods;

import org.junit.Before;
import org.junit.Test;

import java.util.*;

/**
 * @author ChenDan
 * @create 2021-05-23
 * 为什么用泛型
     * 不加泛型，对象可以是多种数据类型，会出现数据异常ClassCastException
 * 泛型有什么特性
     * 实例化泛型如果指定数据类型，不同数据类型不能互相赋值;若不指定，默认为java.Lang.Object
     * 实例化泛型可以缩写：CollName<DateType> paraName = new CollName<>();
     * 集合类都使用的是泛型结构
     * 异常中不可使用泛型
 */
public class GenericTest {
    ArrayList list = new ArrayList();
    ArrayList<String> list1 = new ArrayList<>();
    ArrayList<Integer> list2 = new ArrayList<>();
    Map<String, Integer> map = new HashMap<>();

    @Test
    public void test() {
        list.add(123);
        list.add("123");  // 不加泛型，对象可以是多种数据类型，会出现数据异常

//        list1.add(123); // 加了泛型，只能是实例化的指定数据类型
//        list1.add(list2);  //不同数据类型不能互相赋值

        Set<Map.Entry<String, Integer>> entries = map.entrySet();  // map泛型应用
        Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }

    }

    @Before
    public void test1() {
        map.put("Ross",1);
        map.put("Joey",2);
        map.put("Chandler",3);
        map.put("Phoebe",4);
    }
}

package javaLang.reflect.generic.methods;

import org.junit.Before;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;

public class GenericMethodTest {
    GenericMethod genericMethod = new GenericMethod();

    @Test
    public void test1() {
        Object[] arr =  new Object[10];  // 泛型数组实例化
        Collection<Object> coll = new ArrayList<>();
        GenericMethod.fromArrayToCollection(arr,coll);
    }

    @Test
    public void test() {
        genericMethod.add(new Customer());  // 泛型参数类型
        System.out.println(genericMethod.getIndex(0));  // 泛型返回值类型
        System.out.println(genericMethod.getValue());  // 泛型方法
    }

    @Before
    public void before() {
        genericMethod.add(new Customer());
        genericMethod.add(new Customer());
        genericMethod.add(new Customer());
    }

}

class Customer {}
class CustomerMethod extends GenericMethod<Customer> {}

/**
 * @author ChenDan
 * @create 2021-05-23
 * 创建泛型方法
     * 修饰符 <泛型> 返回值类型 方法名(参数类型 参数名) 抛出的异常
     *  { ……
     *  方法体
     *  ……
     *  return 返回值；
     *  }
 *  <泛型>：中可以extends,但是不能implements
 */
class GenericMethod<T> {
    public void add(T t) {}

    public boolean remove(int index) {
        return false;
    }

    public T getIndex(int index) {
        return null;
    }

    public <E extends GenericMethod > E getValue() { // 具有继承性的泛型方法
        return null;
    }

    public static <T> void fromArrayToCollection(T[] a, Collection<T> c) {
        T[] b = (T[]) new Object[a.length]; // 创建泛型数组
        b = a;
        for (T o:b) {
            c.add(o);
        }
    }

}

package javaLang.reflect.generic.methods;

import org.junit.Before;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

/**
 * @author ChenDan
 * @create 2021-05-23
 * 泛型继承
     * A extends B -> G<A> x G<B>
     *     这种同遍历怎么办？--G<?>
     * A extends B ->  A<G> = B<G>
     *     以<>外面的为准
 * 通配符泛型
     * 特点
         * 不能增改，可以查删
     * 有限制条件的通配符
         * 扩展了数据类型，可以包含更多
             * ? extends className
             * ? super className
 *
 */
public class InheritedTest {
    List<?> list = null;
    List<Object> list1 = null;
    List<String> list2 = null;
    List<String> list3 = new ArrayList<>();


    /**
     * 有限制条件的通配符
         * 扩展了数据类型，可以包含更多
             * ? extends className
             * ? super className
     */
    public void test2() {
        List<? extends Person> list1 = null; // Person的自己/子类的实例化对象都可以赋值
        List<? super Person> list2 = null; // Person的父类/自己/子类的实例化对象都可以赋值
        List<Person> list3 = null;
        List<Student> list4 = null;
        List<Object> list5 = null;

        list1 = list3;
        list2 = list3;

//        list5 = list1.get(0); // 读取，数据类型扩展对应自己/父类都接不住

    }

    /**
     * 通配符泛型特点
         * 不能增改，可以查删
     */
    @Test
    public void test1() {
        list = list3;
//        list.add("sdsa"); // 不可增
        list.add(null);
//        list.set(1,"ds");  // 不可修改
        System.out.println(list.get(0));  // 可查
        list.remove(1);  // 可删
    }

    /**
     * 继承关系
     * 不同类型的数据类型，怎么用一个方法遍历
     */
    @Test
    public void test() {
        List<Number> list = new ArrayList<>();
        List<Integer> list1 = new ArrayList<>();

//        list = list1; // 子不能赋值给父类
//        list1 = list; // 父不能赋值给子类

        List<String> list2 = null;
        Collection<String> coll = null;

//        list2 = coll; // 父不能赋值给子类
        coll = list2;  // 子类可以赋值给父类

        print(list);  // 通配符？
        print(list1);
        print(list2);
        print(list3);
    }

    @Before
    public void test0() {
        list3.add("AA");
        list3.add("BB");
        list3.add("CC");
        list3.add("DD");
    }

    public void print(List<?> list){
        Iterator<?> iterator = list.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

class Person{}
class Student extends Person{}