Java 泛型

目录

定义：

格式：

注意：

使用场景：

泛型类：

泛型方法：

泛型接口：

---

定义：

泛型是JDK5中引入的新特性，可以在编译阶段约束操作的数据类型，并进行检查。

格式：

<数据类型>

注意：

1.泛型只能支持引用数据类型

2.泛型中不能是基本数据类型

3.指定泛型的数据类型之后，传递数据时，可以传入该类类型或者其子类类型

4.如果不写泛型，类型默认是Object

使用场景：

泛型类：

当一个类中，某个变量的数据类型不确定时，就可以定义带有泛型的类

package GEnerics;

import java.util.Arrays;
//泛型类
public class MyArrayLIst <E>{
    int size;
    Object []arr=new Object[3];
    public boolean add(E e){
        arr[size]=e;
        size++;
        return true;
    }
    public E get(int index){
        return (E)arr[index];
    }

    @Override
    public String toString() {
        return (Arrays.toString(arr));
    }
}

 

package GEnerics;

public class testMyList {
    public static void main(String[] args) {
        MyArrayLIst<Integer>ml=new MyArrayLIst<>();
        ml.add(1);
        ml.add(2);
        ml.add(3);
        System.out.println(ml);
    }
}

泛型方法：

当方法中有不确定的数据类型时，也可以定义带有泛型的方法

package GEnerics;

import java.util.ArrayList;

//泛型方法
public class ListUtil {
    private ListUtil(){};

    public static<E> void addAll(ArrayList<E>list,E...e){//可变参数
        for (E e1 : e) {
            list.add(e1);
        }
    }


}

 

package GEnerics;

import java.util.ArrayList;

public class testLIstUtil {
    public static void main(String[] args) {
        ArrayList<String>list=new ArrayList<>();
        ListUtil.addAll(list,"aaa","bbb","ccccc");
        System.out.println(list);
    }
}

泛型接口：

使用带有泛型的接口时，既可以实现类给出类型，也可以实现类延续泛型，创建对象时再确定。

package GEnerics;

import java.util.*;
import java.util.function.Consumer;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;
import java.util.stream.Stream;

public class useLIst implements List <String>{
    @Override
    public String toString() {
        return "useLIst{}";
    }

    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }

    @Override
    public boolean contains(Object o) {
        return false;
    }

    @Override
    public Iterator<String> iterator() {
        return null;
    }

    @Override
    public void forEach(Consumer<? super String> action) {
        List.super.forEach(action);
    }

    @Override
    public Object[] toArray() {
        return new Object[0];
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return null;
    }

    @Override
    public <T> T[] toArray(IntFunction<T[]> generator) {
        return List.super.toArray(generator);
    }

    @Override
    public boolean add(String s) {
        return false;
    }

    @Override
    public boolean remove(Object o) {
        return false;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends String> c) {
        return false;
    }

    @Override
    public boolean addAll(int index, Collection<? extends String> c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean removeIf(Predicate<? super String> filter) {
        return List.super.removeIf(filter);
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void replaceAll(UnaryOperator<String> operator) {
        List.super.replaceAll(operator);
    }

    @Override
    public void sort(Comparator<? super String> c) {
        List.super.sort(c);
    }

    @Override
    public void clear() {

    }

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

    @Override
    public String set(int index, String element) {
        return null;
    }

    @Override
    public void add(int index, String element) {

    }

    @Override
    public String remove(int index) {
        return null;
    }

    @Override
    public int indexOf(Object o) {
        return 0;
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator<String> listIterator() {
        return null;
    }

    @Override
    public ListIterator<String> listIterator(int index) {
        return null;
    }

    @Override
    public List<String> subList(int fromIndex, int toIndex) {
        return null;
    }

    @Override
    public Spliterator<String> spliterator() {
        return List.super.spliterator();
    }

    @Override
    public Stream<String> stream() {
        return List.super.stream();
    }

    @Override
    public Stream<String> parallelStream() {
        return List.super.parallelStream();
    }
}

package GEnerics;

public class TestuseList {
    public static void main(String[] args) {
        useLIst ul=new useLIst();
        ul.add("sdf");
        System.out.println(ul);
    }
}