泛型

泛型：是jdk5中引入的新特性，可以在编译阶段约束操作的数据类下，并进行检查
泛型的格式：<数据类型>

注意：泛型只能支持引用数据类型

package A03Generic;

import java.util.ArrayList;
import java.util.Iterator;

public class Demo01 {
    public static void main(String[] args) {
        /*
        *没有泛型的时候，集合如何存储数据
        * 结论
        * 如果我们没有给集合指定类型，默认认为所有的数据类型都是Object类型
        * 此时可以往集合中日俺家任意的数据
        * 带来一个坏处，我们在获取数据包的时候，无法使用他的特有行为（原因是多态的弊端不能放为子类的特有功能）
        *
        * 此时推出了泛型，可以在添加数据的时候就把类型统一，
        * 而且我们在获取数据的时候，也省得强转了，非常的方便
         */

        //1.创建集合的对象
        ArrayList<String> list=new ArrayList<>();

        //2.添加数据
        //list.add(123);
        list.add("aaa");
        //list.add("zhangsan");

        //3.遍历集合获取里面的每一个元素
        Iterator<String> it=list.listIterator();
        while(it.hasNext()){
            String str=it.next();
            //多态的弊端是不能访问子类的特有功能
            //obj.length();
            //str.length();
            System.out.println(str);

        }
    }
}

泛型的好处：
- 同意数据类型
- 把运行时期的问题提前到了编译期间，避免了强制类型转换可能出现的异常，因为在编译阶段就能确定下来
细节：
- 泛型中不能写基本数据类型
- 指定泛型的具体类型后，传递数据，可以传入该类类型或者子类
- 如果不写泛型，默认是object
泛型类
- 使用场景：当一个类中，某个变量的数据类型不确定时，就可以定义带有泛型的类

package A03Generic;

import java.util.Arrays;

public class MyArrayList<E> {

    Object[] obj=new Object[10];
    int size;


    /*
    E表示不确定的类型，该类型在类后面已经定义过了
    e表示形参的名字，变量名
     */
    public boolean add(E e){
        obj[size]=e;
        size++;
        return  true;
    }

    public E get(int index){
        return (E) obj[index];
    }


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

使用

package A03Generic;

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


        MyArrayList<String> list = new MyArrayList<>();

        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        System.out.println(list);


        MyArrayList<Integer>it=new MyArrayList<>();
        it.add(123);
        it.add(456);
        it.add(789);

        int i=it.get(0);
        System.out.println(i);

        System.out.println(it);
    }
}

泛型方法：方法中形参类型不确定时，可以使用类名后面定义的泛型

形参类型不确定时：
- 1.使用类名后面·定义的泛型（所有方法都能使用）
- 在方法申明上定义自己的泛型（只有本方法能用）

package A03Generic;

import java.util.ArrayList;

/*
   定义一个工具类 ListUtil
   类中定义一个静态方法addAll，用来添加多个集合的元素
 */
public class GenericsDemo03{
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();

        ListUtil.addAll(list,"aaa","bbb","ccc","ddd");
        System.out.println(list);


        ArrayList<Integer> list2=new ArrayList<>();
        ListUtil.addAll(list2,1,2,3,4);
        System.out.println(list2);
    }

}

package A03Generic;

import javax.swing.*;
import java.util.ArrayList;

public class ListUtil {
    private ListUtil(){}

     //   类中定义一个静态方法addAll，用来添加多个集合的元素

    /*

    参数一：集合
    参数二：最后要添加到元素


     */

       public static<E> void addAll(ArrayList<E> list,E e1,E e2,E e3,E e4){
        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);

        }

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

泛型接口

package A03Generic;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class MyArrayList2 implements List<String>{
    @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 Object[] toArray() {
        return new Object[0];
    }

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

    @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 retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {

    }

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

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

package A03Generic;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class MyArrayList3<E> implements List<E> {

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

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

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

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

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

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

    @Override
    public boolean add(E e) {
        return false;
    }

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

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

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

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

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

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

    @Override
    public void clear() {

    }

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

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

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

    }

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

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

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

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

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

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        return List.of();
    }
}

package A03Generic;

import java.util.ArrayList;

public class Demo04 {
    /*
    泛型接口的两种使用方式：
    1.实现类给出具体的类型
    2.实现类延续泛型，创建实现类对象时再确定类型

     */
    public static void main(String[] args) {


        MyArrayList3<String> list = new MyArrayList3<>();
        list.add("aaa");


    }
}

泛型的继承和通配符

package A03Generic;

import java.util.ArrayList;

public class Demo05 {
    public static void main(String[] args) {
    /*
          泛型不具备继承性，但是数据具备继承性
     */
        //创建集合对象
        ArrayList<Ye> list1=new ArrayList<>();
        ArrayList<Fu> list2=new ArrayList<>();
        ArrayList<Zi> list3=new ArrayList<>();

        //调用method方法
        //method(list1);
        //method(list2);
        //method(list3);

        list1.add(new Ye());
        list1.add(new Fu());
        list1.add(new Zi());

    }
    public static void method(ArrayList<Ye> list){

    }
}

class Ye{}
class Fu extends Ye {}
class Zi extends Fu{}
class Student2{}

package A03Generic;

import java.util.ArrayList;

public class Demo06 {
    public static void main(String[] args){
        /*
       *
       * 需求：
       * 定义一个方法，形参是一个集合，但是集合中的数据类型不确定
         */


        //创建集合对象
        ArrayList<Ye> list1=new ArrayList<>();
        ArrayList<Fu> list2=new ArrayList<>();
        ArrayList<Zi> list3=new ArrayList<>();
        ArrayList<Student2> list4=new ArrayList<>();

        //调用method方法
        method(list1);
        method(list2);
        method(list3);
        //method(list4); 报错
    }


    /*
        此时，泛型里面写的时什么类型，那么只能传递什么类型的数据
        弊端：
        利用泛型方法有一个小弊端，此时他可以接收任意数据的类型Ye Fu ZI Student

        希望：本方法虽然不确定类型，但我只希望只能传递Ye Fu Zi
             此时，我们可以使用泛型的通配符：
             1.？也·可以表示不确定的类型，他可以表示类型的限定
             2.？extrends E：表示可以传递E或者E的所有子类类型
             3.？super E：表示可以传递E或者E所有的父类类型


         应用场景：
         1.如果我们再定义类，方法，接口的时候，如果类型不确定，就可以定义泛型类，泛型方法，泛型1接口
         2.如果类型不确定，但是能知道以后只能传递某个继承体系中的，就可以使用泛型的通配符
         泛型的通配符
         1.关键点：可以限定类型的范围
             */
    public static void method(ArrayList<? extends Ye> list){

    }
}

posted @ 2025-11-09 10:35 RIcard 阅读(6) 评论(0) 收藏举报

刷新页面返回顶部

Ricard

泛型

泛型

泛型方法：方法中形参类型不确定时，可以使用类名后面定义的泛型

泛型接口

泛型的继承和通配符

公告