泛型 java

最新推荐文章于 2024-05-22 14:11:15 发布

醉酒的李白o.O

最新推荐文章于 2024-05-22 14:11:15 发布

阅读量132

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_47144389/article/details/128064797

版权

package mygenerics;

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

public class GenericsDemo1 {
    public static void main(String[] args) {
        //没有泛型的时候 集合如何存储数据
        //结论
        //如果我们没有给集合指定类型 默认认为所有的数据类型都是Object类型
        //此时可以往集合添加任意的数据类型
        //带来一个坏处  我们在获取数据的时候 无法使用他的特有行为

        //此时推出了泛型 可以在添加数据的时候就把类型进行统一
        //而且我们在获取数据的时候 也省的强转了 非常方便

        //1.创建集合的对象

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

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

        //3.遍历集合获取里面的每一个元素

        Iterator  <String> it = list.iterator();
        while (it.hasNext()){
            Object obj =it.next();
            //多态的弊端是不能访问子类的特有功能
            System.out.println(obj);//aaa
        }


    }
}

package mygenerics;

public class GenericsDemo2 {
    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> list2 = new MyArrayList<>();

        list2.add(123);
        list2.add(456);
        list2.add(789);

        int i =list2.get(0);
        System.out.println(i);//123

        System.out.println(list2);//[123, 456, 789, null, null, null, null, null, null, null]


    }
}

package mygenerics;


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

* */

import java.util.ArrayList;

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


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

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


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


    }
}

package mygenerics;

public class GenericsDemo4 {
    public static void main(String[] args) {
        /*
        泛型接口的两种实现方式：
          1.实现类给出具体的类型
          2.实现类延续泛型 创建实现类对象时再确定类型
        * */

     
    }
}

package mygenerics;

import java.util.ArrayList;

public class GenericsDemo5 {
    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) {

    }


}

package mygenerics;

import java.util.ArrayList;

public class GenericsDemo6 {
    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(list1);
        method(list2);
        //method(list3);


        //method(list4);


    }

    /*
     * 此时，泛型里面写的是什么类型，那么只能传递什么类型的数据。
     * 弊端：
     *      利用泛型方法有一个小弊端，此时他可以接受任意的数据类型
     *      Ye  Fu   Zi    Student
     *
     * 希望：本方法虽然不确定类型，但是以后我希望只能传递Ye Fu Zi
     *
     * 此时我们就可以使用泛型的通配符：
     *      ?也表示不确定的类型
     *      他可以进行类型的限定
     *      ? extends E: 表示可以传递E或者E所有的子类类型
     *      ? super E:表示可以传递E或者E所有的父类类型
     *
     * 应用场景：
     *      1.如果我们在定义类、方法、接口的时候，如果类型不确定，就可以定义泛型类、泛型方法、泛型接口。
     *      2.如果类型不确定，但是能知道以后只能传递某个继承体系中的，就可以泛型的通配符
     * 泛型的通配符：
     *      关键点：可以限定类型的范围。
     *
     * */
    public static void method(ArrayList<? super Fu> list) {

    }
}

class Ye {
}

class Fu extends Ye {
}

class Zi extends Fu {
}

class Student2{}

package mygenerics;

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("尼古拉斯 阿伟");
    }

}

package mygenerics;


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 mygenerics;

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 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;
    }
}

package mygenerics;

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 null;
    }
}

package mygenerics;

public class Student {
    private  String name;
    private  int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}