java泛型

为什么要有泛型

规范集合，给集合添加标签。

集合、类、接口使用泛型

总结：
1.集合接口或集合在jdkjdk5时都戴泛型结构。
2.在实例化集合类时，可以指明具体的泛型类型
3.指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）
比如：add（E e） 实例化后：add（Interger e）
4.注意点：泛型的类型必须是类，不能时基本数据类型。需要用到基本数据类型的位置，拿包装类替换
5.如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。

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

写一个自定义泛型类的作用

泛型改改变Comparable 接口方法
package fxexer;

import java.util.Collections;

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-26-22:07
 */
public class Person implements Comparable<Person>{
    String name;
    int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }



    @Override
    public int compareTo(Person o) {
        return this.compareTo(o);
    }
}

这个例子用到泛型类枚举类、集合

package fxexer;

import org.junit.Test;

import java.util.*;

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-26-22:08
 */
public class LIST {
    TreeMap<Person,Work> treeMap =new TreeMap();
    @Test
    public void method(){
        treeMap.put(new Person("tom",12),Work.engineer);
        treeMap.put(new Person("kevim",3),Work.Farmer);
        treeMap.put(new Person("jack",53),Work.Garverment);
        treeMap.put(new Person("farm",33),Work.Police);
        treeMap.put(new Person("house",13),Work.Farmer);
        Iterator <Map.Entry<Person,Work>>iterator = treeMap.entrySet().iterator();
        while (iterator.hasNext()){
            Map.Entry entry = iterator.next();
            System.out.println(entry.getKey()+"  "+entry.getValue());
        }
    }
}

package fxexer;

import java.util.Date;

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-26-22:24
 */
public enum Work {
    Farmer("生产粮食"),
    Police("维护治安"),
    Garverment("挥斥方遒"),
    engineer("建设国家");
    private String Detail;
    Work(String detail) {
        Detail = detail;
    }

    public String getDetail() {
        return Detail;
    }

    public void setDetail(String detail) {
        Detail = detail;
    }
}

package fxexer;

import java.util.Collections;

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-26-22:07
 */
public class Person implements Comparable<Person>{
    String name;
    int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public int compareTo(Person o) {
        return this.name.compareTo(o.name);
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

泛型改变treeset的ilterator

package fxexer;

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

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-26-22:08
 */
public class LIST {
    TreeSet<Person> treeSet =new TreeSet<>();
    public void method(){
        treeSet.add(new Person("tom",13));
        treeSet.add(new Person("kevim",3));
        treeSet.add(new Person("jack",53));
        treeSet.add(new Person("farm",33));
        treeSet.add(new Person("house",13));
        Iterator <Person>iterator = treeSet.iterator();
        while (iterator.hasNext()){
            Person p = iterator.next();
            System.out.println(p);
        }
    }
}

自定义泛型结构（如果定义了泛型，实例化没有指明类型，则认为此泛型类型为Object类型。如果定义了类是带泛型的，最好使用的时候指明泛型类型）

自定义泛型类\接口
泛型类

package DivFx;

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-26-22:41
 */
public class DivFxClass <T>{
    String name ;
    int id;
    T t;
    public T Method(T t){
        this.t=t;
        return t;
    }
}

泛型接口

package DivFx;

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-26-22:46
 */
public interface UST<T> {
    void method();
    T method1();
}

静态方法不能使用泛型
public static T NIHAO(){}
异常类不能使用泛型
public class DivFxClass extends Exception{}

带泛型子类继承带有泛型父类不能与父类的泛型完全不同。可以一个一样，可以定义不声明，可以包括父类泛型拓展。
总结：使用泛型可以使得代码更简洁，List一般使用规范输入内容
泛型方法
泛型方法在调用时需要多加一个<>指明里面的元素是泛型（因为和类里的泛型不一致，或者类里不带泛型）
泛型方法可以是静态的。常规方法可以调用静态方法，静态属性。静态方法是在实例化之前创建调用，或者在实例化之后调用，不能与实例化同步，所以泛型类不能有相同泛型的静态方法（静态泛型方法得重新定义一个和类不同的的泛型）。

public <E>List<E> NIHAO(E arr[]){
    ArrayList<E> list =new ArrayList<>();
    for (E e:arr
         ) {
        list.add(e);
    }
    return list;
}

定义一个泛型接口使用

package DivFx;

import java.util.ArrayList;
import java.util.List;

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-27-10:18
 */
public interface Dao <T>{
    String name = null;
    int number = 0;
    void add(T t);
    void remove(T t);
    T get(int index);
    void checkall();
}

package DivFx;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-27-10:24
 */
public class Customer implements Dao<Customer>{
    String name;
    int number;
    ArrayList <Customer>list =new <Customer>ArrayList();
    public Customer() {
    }
    public Customer(String name, int number) {
        this.name = name;
        this.number = number;
    }

    @Override
    public void add(Customer customer) {
        list.add(customer);
    }

    @Override
    public void remove(Customer customer) {
        list.remove(customer);
    }

    @Override
    public Customer get(int index) {
        return null;
    }

    @Override
    public void checkall() {
        for (Customer c :list
                ) {
            System.out.println(c.toString());
        }
        return ;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Customer customer = (Customer) o;
        return number == customer.number &&
                Objects.equals(name, customer.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, number);
    }

    @Override
    public String toString() {
        return "Customer{" +
                "name='" + name + '\'' +
                ", number=" + number +
                '}';
    }
}

package DivFx;

import org.junit.Test;

import java.net.PortUnreachableException;
import java.util.ArrayList;
import java.util.List;

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-26-22:43
 */
public class Text {
    public static void main(String[] args) {
        Customer customer =new Customer();
        customer.add(new Customer("kevin",20));
        customer.add(new Customer("durant",23));
        customer.add(new Customer("rose",2));
        customer.add(new Customer("james",25));
        customer.add(new Customer("kobe",50));
        customer.add(new Customer("mory",40));
        customer.checkall();
    }
}

泛型在继承上的体现（继承泛型对于属性的影响）

目前已知，属性中只能数组集合类可以加泛型，其他正常类无法加泛型
通常的子类可以付给父类，当子类父类作为泛型给集合的时候，是无法赋值的。相当于去了多态的效果。

public class Son extends Customer {
    Son s =new Son();
    Customer customer =new Customer();
    List <Son>list =new ArrayList<>();
    List <Customer>lists =new ArrayList<>();
    @Test
    public void method() {
        list=lists;
    }
}

**为解决上面问题引入一个?通配符。他是所有类的公共父类，List通配符不能加任何数据除了null；可以获取数据（读取数据）
**

public class Son extends Customer {
    Son s =new Son();
    Customer customer =new Customer();
    List <Son>list =new ArrayList<>();
    List <Customer>lists =new ArrayList<>();
    List<?> listss =new ArrayList<>();
    @Test
    public void method() {
        listss=list;
        listss=lists;

    }

}

? instrance of Person 意思是？不大于Person