泛型类接口方法通配符

泛型

泛型类

what:

类型参数化

why use：

1. 输出时候是object类型而不是真正类型转化麻烦

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

public class ObjectExample {
    public static void main(String[] args) {
        List<Object> list = new ArrayList<>();
        list.add("Hello");
        list.add(123); // 可以添加任何类型的对象

        // 运行时可能会出现 ClassCastException
        String str = (String) list.get(1); 
        System.out.println(str);
    }
}

一个盒子什么类型都可以装

而不是橘子苹果火龙果盒子

分别对应一个类

fault example：

package box;

import fruit.*;

public class box {
}


public class appleBox{
    private apple apple;
    private double length;
    private double width;
    private double heigth;
    private double count;
    private double weigth;
    appleBox(){

    }
    appleBox(apple apple,double length,double width,double heigth,double count,double weigth){
        this.apple = apple;
        this.length = length;
        this.width = width;
        this.heigth = heigth;
        this.count = count;
        this.weigth = weigth;


    }

public class orangeBox{
    private orange orange;
    private double length;
    private double width;
    private double heigth;
    private double count;
    private double weigth;
    orangeBox(){

    }
    orangeBox(orange orange, double length, double width, double heigth, double count, double weigth){
        this.orange = orange;
        this.length = length;
        this.width = width;
        this.heigth = heigth;
        this.count = count;
        this.weigth = weigth;


    }
    public class pitayaBox{
        private pitaya pitaya;
        private double length;
        private double width;
        private double heigth;
        private double count;
        private double weigth;
        pitayaBox(){

        }
        pitayaBox(pitaya pitaya,double length,double width,double heigth,double count,double weigth){
            this.pitaya = pitaya;
            this.length = length;
            this.width = width;
            this.heigth = heigth;
            this.count = count;
            this.weigth = weigth;


        }

}

代码冗余：每个盒子类的逻辑几乎相同，只是类型不同，但需要重复编写。
扩展性差：如果需要支持更多类型的水果，就需要继续添加更多的盒子类。
维护困难：如果需要修改盒子的功能（如增加新的方法），需要在每个盒子类中逐一修改。

example：

bug1：构造函数不公开化外部无法构造

/*
	构造函数公开化
	*/
    
    public boxGeneric(T fruit, double length, double width, double heigth, double count, double weigth) {
        this.fruit = fruit;
        this.length = length;
        this.width = width;
        this.heigth = heigth;
        this.count = count;
        this.weigth = weigth;

    }

泛型实例：

package box;

/*
what:
    generic 类型参数化
 */
public class boxGeneric<T> {
    /*
    what:
        不同部分只是水果类型 给他类型参数化
        但是我接收时候只能接收一种水果类型 然后对应对象确定了 是 苹果盒子/橘子盒子 然后就当苹果盒子正常使用
     */
    private T fruit;

    private double length;
    private double width;
    private double heigth;
    private double count;
    private double weigth;
	/*
	构造函数公开化
	*/
    
    public boxGeneric(T fruit, double length, double width, double heigth, double count, double weigth) {
        this.fruit = fruit;
        this.length = length;
        this.width = width;
        this.heigth = heigth;
        this.count = count;
        this.weigth = weigth;

    }

    public T getFruit() {
        return fruit;
    }

    public void setFruit(T fruit) {
        this.fruit = fruit;
    }

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeigth() {
        return heigth;
    }

    public void setHeigth(double heigth) {
        this.heigth = heigth;
    }

    public double getCount() {
        return count;
    }

    public void setCount(double count) {
        this.count = count;
    }

    public double getWeigth() {
        return weigth;
    }

    public void setWeigth(double weigth) {
        this.weigth = weigth;
    }
}

调用：

import box.boxGeneric;
import fruit.apple;

public class Main {
    public static void main(String[] args) {


        /*
        使用泛型水果盒子
         */
        apple apple = new apple();
        boxGeneric<fruit.apple> appleboxGeneric = new boxGeneric<>(apple, 1, 1, 1, 1, 1);
        System.out.println(appleboxGeneric.getFruit().getName());
    }



}

apple类型

package fruit;

public class apple {

    private final String name = "apple";


    public String getName() {
        return name;
    }
}

语法

创建参数化类

class boxGeneric<T>(T fruit){
	T fruit;
	
}

创建泛型对象

new boxGeneric<>()

alt + enter

接口使用

接口后要立马接收参数类型参数

类后要立马接收参数类型参数

接口

package interfaceModle;
/*
what:
    接口使用泛型 参数要紧紧跟着类呀
 */
public interface keyInterface<T> {
    /*
    接口函数返回类型为泛型
     */
    T getKey();
}

使用1：实现泛型接口的类不是泛型类实现类不用接收参数类型接口还要由实现类给出参数那么我们自己指定接口的类型参数

这时实现类使用接口时候要给出接口的类型参数因为外部无法给出参数类型只能我自己给，如果实现类不给接口参数默认给接口Object类型

package imple;

import interfaceModle.keyInterface;
/*
非泛型类 要给接口类型参数
 */
public class keyImple implements keyInterface<String> {


    @Override
    public String getKey() {
        return "This is a key ------ 并非generic 是由实现类直接指定类型";
    }
}

main:

/*
    what:
        实现类直接指定类型 的 实现类返回信息
     */
    public static void test2(){
        keyImple keyImple = new keyImple();
        System.out.println(keyImple.getKey());
    }

使用2：实现类接收外部的类型参数接口泛型参数由实现类给出则接口的类型参数可以与实现类参数一致，也可以直接由实现类给出

package imple;

import interfaceModle.keyInterface;

/*
what:
    实现类接收类型参数 赋值给接口参数
 */
public class keyGenericImple<T,E> implements keyInterface<T> {
    private T key;
    private E value;

    public keyGenericImple(T key, E value) {
        this.key = key;
        this.value = value;
    }

    public E getValue() {
        return value;
    }

    public void setValue(E value) {
        this.value = value;
    }

    @Override
    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }
}

main

/*
    what:
        实现类接收类型参数 发给接口的类型参数
        确定类型参数 设置普通参数值 返回信息
     */
    public static void test3(){
        keyGenericImple<String, Integer> si = new keyGenericImple<>("你好", 114514);
        String key = si.getKey();
        Integer value = si.getValue();
        System.out.println(key + " = " + value);
    }

方法使用

在调用方法时候指明泛型的具体类型

泛型类作用在返回值参数上但方法内部无法使用泛型

即泛型类只在类内部使用方法内部使用泛型需要泛型方法

how use：

泛型类后面紧接所需要的参数
泛型方法后面无需紧跟参数但是泛型方法需要被修饰所以泛型标志在函数名前面
能用泛型方法里的泛型E，类的泛型T也可以用

how set parameter:

类的传递参数写在类的后面

getProduct<Integer> gp = new getProduct<>();

接口的类型参数写作接口后面

方法的类型参数写在修饰符那里

泛型方法的类型参数只能通过接收参数时候设置方法泛型类型其他没地方接收类型参数呀。。。。

example：

类管类的内部方法管方法的内部及方法返回值方法参数

方法和类同一个类型参数T 时候设置一个T = 方法和类全部设置

泛型类 + 泛型方法设置参数

泛型方法

package methodGeneric;

import java.util.ArrayList;
import java.util.Random;

/*
what:
     给出任意类型列表 返回一个奖品
 */
public class getProduct<E> {

    /*
    what：
        方法接收任意类型集合 返回一个奖品
    how use：
        方法类型参数 修饰作用 所以在最前面 声明后 该方法返回值 形式参数都可以使用该类型
        接收任意类型奖品列表
    how set type parameter:
        1.接收参数时候设置参数中的类型参数时 设置方法类型的参数

     */
    Random rand = new Random();
    public <T> T getProductMethod(ArrayList<T> list) {

        return list.get(rand.nextInt(list.size()));
    }
}

传入泛型类类型参数（类后面直接给出）、泛型方法类型参数（方法参数设置参数）

/*
what：
    给出字符串类型奖品列表 返回奖品

 */

public static void test4(){
    ArrayList<String> list = new ArrayList<>();
    list.add("笔记本电脑");
    list.add("苹果手机");
    list.add("安卓手机");
    /*
    what:
        传给方法 抽出奖品
     */
    getProduct<Integer> gP = new getProduct<>();
    String product = gP.getProductMethod(list);
    System.out.println("取出奖品为：" + product);
}

/*
what:
    给出数字类型列表 抽出奖金
 */
public static void test5(){
    ArrayList<Integer> products = new ArrayList<>();
    products.add(1000);
    products.add(20000);
    products.add(300000);
    getProduct<Integer> gP = new getProduct<>();
    Integer product = gP.getProductMethod(products);
    System.out.println("你的奖金为：" + product);
}

careout：

设置类泛型参数后不一定设置方法的类型参数
类和方法类型参数名字就算一样也是相互独立的
类的类型参数在实例化对象时设置
方法类型参数在接收形式参数时设置

泛型类设置类型参数–成员方法仅泛型类类型参数接收

泛型方法任意类型参数接收

泛型类的成员方法无法静态

泛型方法可以静态泛型方法不是泛型类的成员方法

泛型成员方法：

{
        getProduct<Integer> gP = new getProduct<>();
        /*
        what；
            数组
         */
        int[] arr = {1000,20000,3000000};
        ArrayList<Integer> products = new ArrayList<>();
        for(int i = 0;i<arr.length;i++){
            products.add(arr[i]);
        }
        /*
        what:
            泛型实例化 给成员方法得到奖品
         */
        getProduct<Integer> gp = new getProduct<>();
        Integer product0 = gp.getProduct0(products);
        System.out.println(product0 + " " + product0.getClass().getName());
    }

public class getProduct<E> {
    Random rand = new Random();
    /*
    what：
        泛型类的成员方法  成员方法全部依赖泛型类 比如 泛型类的类型参数
        返回奖品
     */
    public E getProduct0(ArrayList<E> list) {
        return list.get(rand.nextInt(list.size()));
    }
    }

泛型方法;


    public <T, E, K, V> void getMessage(T t,E e,K k,V v){
        System.out.println(t + "\t" + t.getClass().getName());
        System.out.println(e + " \t" + t.getClass().getName());
        System.out.println(k + " \t" + k.getClass().getName());
        System.out.println(v + " \t" + v.getClass().getName());
    }

public static void test7(){
        getProduct<Integer> gp = new getProduct<>();
        gp.getMessage("aaa","bbb",false,true);
        System.out.println("------------");
        gp.getMessage(true,false,1,22.66);
    }

泛型可变参数

泛型方法上E… e 泛型方法前设置修饰符

public static <E> void constantParameterPrint(E... e){
        for(int i = 0;i<e.length;i++){
            System.out.println(e[i]);
        }
    }

public static void test7(){
        getProduct<Integer> gp = new getProduct<>();
        gp.getMessage("aaa","bbb",false,true);

        System.out.println("------------");
        gp.getMessage(true,false,1,22.66);

        System.out.println("------------");
        gp.constantParameterPrint(1,2,3,4,5);
        System.out.println("------------");
        gp.constantParameterPrint('a','b','c','d','e');
    }

类型通配符

difficult:

1.Box box 这是一个Box对象指明Box对象形式参数创建Box实例对象而不是一个列表 ArrayLIst arrayList 创建一个ArrayList对象指明 Number参数创建arrayList 实例对象

why use：

在用泛型对象作为参数时候相当于实例化对象这时候要给对象泛型类型发参数，说明函数有泛型类实例化对象时我们已经给该泛型实例化对象设置了泛型的类型这时候多种类型传入函数（泛型类实例化对象已经指定）这时候就会报错

interge 与 Number 在泛型类型参数里不能当作父亲接收子多态来理解

solve：

方法重载？
- 同名不能形式参数尽管泛型的接收类型参数不一样但是他们都是泛型类所以相同的参数无法重载
Object 泛型类类型参数
- 那么不利于上层接收调用以为是Object类型

在函数形式参数泛型类实例化对象用问号代替类型参数该泛型类接收所有类型的类型参数然后实例化形式参数

example：

package typeWildcard;

public class test {

    /*
        what:
            模拟多次 不同类型的泛型对象传入含有通配符函数
            返回Object类型 但是上一层强转类型即可
     */
    public static void main(String[] args) {
        Box<Number> box1 = new Box<>();
        box1.setFirst(1);
        Number o = (Number)showBox(box1);
        System.out.println(o);
        System.out.println("-------------");
        Box<String> box2 = new Box<>();
        box2.setFirst("函数的形式参数 实例化 接收全部类型");
        String s = (String)showBox(box2);
        System.out.println(s);
    }
    /*
    what；
        函数的形式参数 实例化也需要指定泛型类的类型参数  这样无法多态

    public static void showBox(Box<Number> box){
        Number first = box.getFirst();

    }

    what effect:
        衬托无法多态  因为 形式参数 的类型都是泛型类 所以无法多态

    public static void showBox(Box<Integer> box){
        Number first = box.getFirst();

    }
    */

    /*
    what:
        1.对于函数形式参数为泛型类需要指明类型参数情况 使用问号 代表实例化时接收各种类型参数
        2.咱们使用Object接收 但是直接返回上一层因为上一层知道这个object是声明类型呀！！！
     */

    public static Object showBox(Box<?> box){

        return box.getFirst();
    }

}

~~~java
package typeWildcard;

/*
what:
    泛型类 当个函数形式参数实例化参数时候 必须要指定泛型类型参数
 */
public class Box<T> {
    T first;

    public T getFirst() {
        return first;
    }

    public void setFirst(T first) {
        this.first = first;
    }
}