Java 泛型编程

一 . 定义泛型类

package com.example.java;

public class Person<T> {
    T name;

    public T getName() {
        return name;
    }

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

public class Person<T, W> {
    T name;
    W age;

    public W getAge() {
        return age;
    }

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

    public T getName() {
        return name;
    }

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

二 . 定义泛型方法

(1)普通泛型方法

public class Person{
    public <T> void func(T name ){
        System.out.println("func"+name);
    }
}

(2)静态泛型方法

public class Person{
    public static  <W> void func1(W name ){
        System.out.println("func1"+name);
    }
}

三 . 定义泛型接口

public interface IM <T>{
    public void show(T name);
}

(1)泛型接口实现类方式一

泛型接口的实现类可以在实现接口的时候直接指定泛型的类型

public class Person implements  IM<String>{
    @Override
    public void show(String name) {
        
    }
}

(2)泛型接口实现类方式二

泛型接口的实现类在实现接口的时候没有指定泛型的类型，相当于将该泛型T传递给了类，所以需要在类名后接收泛型传递。

public class Person<T> implements  IM<T>{
    @Override
    public void show(T name) {
        
    }
}

四 . 泛型的擦除以及原因

例如该类

public class Person<T>{
    T name;

    public T getName() {
        return name;
    }

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

public class Test {
    public static void main(String[] args) {
        Person<String> p=new Person<String>();
        Person<Integer> p1=new Person<Integer>();
        System.out.println(p.getClass()==p1.getClass());
    }
}

输出结果是true

也就是说泛型只存在于编译阶段，在运行阶段的时候会被擦除。其目的是为了兼容jdk老版本。

五. 泛型通配符

java中的继承并不是泛型中的继承。

public class Person<T>{
    T name;

    public T getName() {
        return name;
    }

    public void setName(T name) {
        this.name = name;
    }
	
	//传入一个该对象类型的参数
    public void show(Person<T> p){
        this.name=p.name;
    }
}

原因是对象对p的泛型类型要求是Number，但是p1的实际泛型类型是Interger。虽然Interger是Number的子类，但是不可以。

因此 需要通配符 **？**来解决这个问题 ，修改代码如下。

  public void show(Person<?> p){
        this.name=(T)p.name;
    }

1 通配符 ?

可以看做是所有泛型的父类,因此 我们在这个地方对传入的父类参数进行强转为子类的T。上面这个问题就解决了 。
但这会带来一个问题。比如

public class Test {
    public static void main(String[] args) {
        Person<Number> p=new Person<Number>();
        Person<Integer> p1=new Person<Integer>();
        Person<String> p2=new Person<String>();
        p.show(p2);
    }
}

p2 是泛型类型是字符串类型的 ，但是也能使用，这就会导致泛型的滥用。因此引申除了边界的概念，两个关键字 super和extends

（1）extends 上边界

    public void show(Person<? extends T> p){
        this.name=(T)p.name;
    }

这就意味着传入的参数的泛型类型必须是T的子类或者本身

这样就对对象p2就行了限制。而Interger是Number的子类，这时候传入对象p1 就没有问题了。

（2 ）super 下边界

  public void show(Person<? super T> p){
        this.name=(T)p.name;
    }

这就意味着传入的参数的泛型类型必须是T的父类或者本身。

   public static void main(String[] args) {
        Person<Number> p=new Person<Number>();
        Person<Integer> p1=new Person<Integer>();
        Person<String> p2=new Person<String>();
        p.show(p);
    }

2 什么时候使用上边界和下边界。

上边界：读取父类的数据。不修改。子类访问父类数据。
下边界：需要写入数据的时候，不读取。父类修改子类数据。