Java泛型

感觉是个重点

感觉是一个很重要的东西，很有必要记录下来，也觉得蛮有用的

泛型类

我认为是一个定义一个类，这个类里面的数据类型不是固定的，可以让这个类处理多种数据类型的数据
格式:
定义一个含有泛型的类，就是在类的名称后面加一个<E>，把数据的类型换成E就可以了，E也可以换成其他的，只要有尖括号就行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class generic<E>{ //定义一个含有泛型的类
    private E name;
    
    public E getName() {
        return name;
    }

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

    public void show(){
        System.out.println(name);
    }
}

使用:
使用泛型类有两种方式，一种是不用泛型，直接使用类，另一种是使用泛型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
generic gc1 = new generic<>(); //这样实例化泛型类也是可以的，在使用后面setName方法时可以使用各种类型的数据
gc1.setName("str1");
Object obj1 = gc1.getName();
System.out.println(obj1);

generic gc2 = new generic<>();
gc2.setName(123);
Object obj2 = gc2.getName();
System.out.println(obj2);

generic<String> gc3 = new generic<>(); //这样实例化泛型类也是可以的，后面的setName方法只能传入String类型数据
gc3.setName("str2");
Object obj3 = gc3.getName();
System.out.println(obj3);

generic<Integer> gc4 = new generic<>(); //这个对象的setName方法只能传入Integer类型的数据
gc4.setName(456);
Object obj4 = gc4.getName();
System.out.println(obj4);

泛型方法

定义一个含有泛型的方法，就是在修饰符后面加一个<E>，和类一样
格式:
修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
}

1
2
3
4
5
6
public <M> void method1(M m){ //定义一个含有泛型的方法
    System.out.println(m);
}
public static <S> void method1(S s){ //定义一个含有泛型的方法
    System.out.println(s);
}

泛型接口

定义一个泛型接口，里面的方法可以是泛型方法
格式:

1
2
3
public interface generic<E>{
    public abstract void method(E e);
}

实现类有两种:

  1. 实现类也使用泛型，相当与定义了一个含有泛型的类，创建对象的时候确定泛型的类型
    在实现类的名字后面也有一个尖括号<O>

    1
    2
    3
    4
    5
    6
    public class genericClass1<O> implements generic<O>{
        @Override
        public void method(O o) {
            System.out.println("1重写接口方法" + o);
        }
    }

    使用:

    1
    2
    3
    4
    public static void main(String[] args) {
        genericClass1<String> gc = new genericClass1<>();
        gc.method1("~bia~");
    }

  2. 定义接口的实现类，实现接口，指定接口的泛型，实现类已经定义好使用什么数据类型
    在实现类的名字后面没有尖括号<String>

    1
    2
    3
    4
    5
    6
    public class genericClass2 implements generic<String>{
        @Override
        public void method(String s) {
            System.out.println("2重写接口方法" + s);
        }
    }

    使用:

    1
    2
    3
    4
    public static void main(String[] args){
        genericClass2 gc = new genericClass2();
        gc.method("~pia~");
    }

泛型的通配符 ?

不能在创建对象的时候使用，只能作为方法的参数使用
定义一个方法，传入的数组/集合数据类型不固定，全部输出

1
2
3
4
5
6
public static void method(ArrayList<?> list){ //list里的数据类型是不确定的，这里可以使用泛型通配符 ?
    Iterator<?> it = list.iterator(); //同理，迭代器里的数据也不确定，使用泛型通配符 ?
    while (it.hasNext()){
        System.out.println(it.next());
    }
}

泛型这么难，肯定是块硬骨头，啃下来说不定对Java就有更深的了解了，况且为了总结一下泛型，把看过的课又看了一遍，算是复习了吧，脑子里对这玩意的了解更深刻了 ヾ(´∀`o)+