非零基础自学Java (老师：韩顺平) 第15章 泛型 15.6 自定义泛型

非零基础自学Java (老师：韩顺平)

✈【【零基础 快速学Java】韩顺平 零基础30天学会Java】

第15章 泛型

15.6 自定义泛型

15.6.1 自定义泛型类

【基本语法】

class 类名{ //...表示可以有多个泛型
    成员
}

注意细节：

• 普通成员可以使用泛型(属性、方法)
• 使用泛型的数组，不能初始化
• 静态方法中不能使用类的泛型
• 泛型类的类型,是在创建对象时确定的(因为创建对象时,需要指定确定类型)
• 如果在创建对象时，没有指定类型，默认为Object

【举个栗子】

package com.dingjiaxiong.customgeneric;

import java.util.Arrays;

/**
 * ClassName: CustomGeneric_
 * date: 2022/9/6 11:19
 *
 * @author DingJiaxiong
 */

@SuppressWarnings({"all"})
public class CustomGeneric_ {
    public static void main(String[] args) {
        Tiger<Double , String , Integer> g = new Tiger<>("john");
        g.setT(10.9); //可以
//        g.setT("yy"); // 直接报红，类型不对
        System.out.println(g);

        Tiger g2  = new Tiger("john~~~~");  // ok , 其他三个泛型默认为 Object
        g2.setT("yy");

        System.out.println("g2 = " + g2);
    }
}

class Tiger<T , R , M>{
    String name;
    R r; //属性使用到泛型
    M m;
    T t;
    //数组在new 时不能确定T的类型，就无法在内存开辟空间
    T[] ts;

    public Tiger(String name) {
        this.name = name;
    }

    public Tiger(R r, M m, T t) { //构造器使用泛型
        this.r = r;
        this.m = m;
        this.t = t;
    }

    public Tiger(String name, R r, M m, T t) { //构造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }

    //方法使用泛型

    public String getName() {
        return name;
    }

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

    public R getR() {
        return r;
    }

    public void setR(R r) {
        this.r = r;
    }

    public M getM() {
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "Tiger{" +
                "name='" + name + '\'' +
                ", r=" + r +
                ", m=" + m +
                ", t=" + t +
                ", ts=" + Arrays.toString(ts) +
                '}';
    }
}

运行结果

15.6.2 自定义泛型接口

【基本语法】

interface 接口名{
    
}

【注意细节】

• 接口中，静态成员也不能使用泛型(这个和泛型类规定一样)
• 泛型接口的类型,在继承接口或者实现接口时确定
• 没有指定类型,默认为Object

【举个栗子】

package com.dingjiaxiong.customgeneric;

/**
 * ClassName: CustomInterfaceGeneric
 * date: 2022/9/6 11:28
 *
 * @author DingJiaxiong
 */

public class CustomInterfaceGeneric {
}

//在继承接口时指定 泛型接口的类型
interface IA extends IUsb<String , Double>{
}

//实现IA接口
class AA implements IA{

    @Override
    public Double get(String s) {
        return null;
    }

    @Override
    public void hi(Double aDouble) {

    }

    @Override
    public void run(Double r1, Double r2, String u1, String u2) {

    }
}

//实现接口，直接指定泛型接口的类型
class BB implements IUsb<Integer , Float>{

    @Override
    public Float get(Integer integer) {
        return null;
    }

    @Override
    public void hi(Float aFloat) {

    }

    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {

    }
}

//没有指定类型，默认为Object
//韩老师建议加上类型
class CC implements IUsb<Object , Object>{

    @Override
    public Object get(Object o) {
        return null;
    }

    @Override
    public void hi(Object o) {

    }

    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {

    }
} 


interface IUsb<U , R>{
    int n = 10;

    //普通方法中，可以使用接口泛型
    R get(U u);

    void hi(R r);

    void run(R r1 , R r2 , U u1 , U u2);

    //在JDK 8 中，可以在接口中使用默认方法，也是可以使用泛型
    default R method(U u){
        return null;
    }
}

15.6.3 自定义泛型方法

【基本语法】

修饰符  返回类型 方法名(参数列表){
    
}

注意细节

• 泛型方法，可以定义在普通类中,也可以定义在泛型类中
• 当泛型方法被调用时,类型会确定
• public void eat(E e)0,修饰符后没有 eat方法不是泛型方法，而是使用了泛型

【举个栗子】

package com.dingjiaxiong.customgeneric;

import java.util.ArrayList;

/**
 * ClassName: CustomMethodGeneric
 * date: 2022/9/6 11:37
 *
 * @author DingJiaxiong
 */

@SuppressWarnings({"all"})
public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("宝马",100); //调用方法，传入参数，编译器就会确定类型
        System.out.println("=======================");
        car.fly(300,100.1);


        System.out.println("==========================");

        //测试
        Fish<String , ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList() , 11.3f);
    }
}

//泛型方法，可以定义在普通类中，也可以定义在泛型类中
class Car{ //普通类
    public void run(){ //普通方法

    }

    //泛型方法
    public <T , R> void fly(T t , R r){
        System.out.println(t.getClass());
        System.out.println(r.getClass());
    }
}

class Fish<T , R>{ //泛型类
    public void run(){ //普通方法

    }

    public <U , M> void eat(U u , M m){//泛型方法

    }

    //下面这个不是泛型方法
    // 只是hi方法使用了 类声明的泛型
    public void hi(T t){

    }

    //泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
    public<K> void hello(R r , K k){
        System.out.println(r.getClass());
        System.out.println(k.getClass());
    }
}

运行结果