java泛型的深入 泛型还可以在很多地方进行定义 泛型类 泛型方法 泛型接口 泛型的继承和通配符 泛型类练习

泛型的深入

public static void main(String[] args) {

        //在没有泛型的时候怎么存储数据
        ArrayList list=new ArrayList();


        list.add(1);
        list.add("abc");


        //遍历集合
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            Object o = iterator.next();
            //多态的弊端 不能访问子类特有的功能
            //o.length()就会报错

            //由此得出如果没有给集合限定类型那么所有类型都是object类型
            
            System.out.println(o);
            //打印结果1
            //abc
        }


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

结论:如果我们给定集合的类型 那么所有数据类型都是object
此时可以往集合添加任何的数据类型
带来一个坏处我们获取数据的时候无法用她的特有行为
所以推出泛型

以上为泛型的好处

以上为泛型的细节

泛型还可以在很多地方进行定义

泛型类

思考:并且自己写出一个泛型类

public class myArrayList <E>{

    Object []obj=new Object[10];

    int size;//表达长度  你现在存了几个元素


    public boolean add(E e){
        obj[size]=e;//相当于现在要把元素添加到数组
        size++;
        return true;//表示添加成功
    }


    public E get(int index){

        return (E) obj[index];
    }



    //重写toString 要求返回对象属性值1
    @Override
    public String toString() {
        return Arrays.toString(obj);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

泛型方法

下面是应用场景

public class ListUtil {
    //这是一个工具类
    //所以要私有化其构造方法(不让外界创建他的对象 )
    private  ListUtil(){}
    //这个工具类的作用是让集合可以添加元素
    //参数1是集合  参数二是参数


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


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

如果泛型只需要使用一次可以不用创建在整个类下(红圈的),可以单独创建在方法里形参及方法体都可以使用

代码改写 上面的有限制只能添加四个 改写下可以添加多个

public class ListUtil {
    //这是一个工具类
    //所以要私有化其构造方法(不让外界创建他的对象 )
    private  ListUtil(){}
    //这个工具类的作用是让集合可以添加元素
    //参数1是集合  参数二是参数


    public static <E>void addall(ArrayList<E>list,E...e){
        //他的底层是一个数组
        //可以用普通for遍历也可以用增强for
        for (E election : e) {
            list.add(election);
        }
    }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

泛型接口

1:实现类给出具体的类型.在实现的地方定义泛型类型表示就只能这个类型了

---

以上为实现类也不明确类型

泛型的继承和通配符

泛型不具备继承性,但是数据具备继承性.

import java.util.ArrayList;

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

        //泛型不具备继承性 但是数据具备继承性

        ArrayList<ye>list1 =new ArrayList<ye>();
        ArrayList<fu>list2=new ArrayList<fu>();
        ArrayList<zi>list3 =new ArrayList<zi>();

        method(list1);
        method(list2);
        method(list3);
        //这个就是泛型不具备继承性  list2 3 报错了 因为他俩是继承来的

        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{

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

---

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

        //泛型不具备继承性 但是数据具备继承性

        ArrayList<ye> list1 =new ArrayList<ye>();
        ArrayList<fu>list2=new ArrayList<fu>();
        ArrayList<zi>list3 =new ArrayList<zi>();

        method(list1);
        method(list2);
        method(list3);
        
    }
    //这种方法不要严谨 因为它可以接收所有类
    //但是如果我只想限定的只接受部分类呢
    //这时候就用到了通配符
    // ? extend E表示可传递e或者e的所有的子类类型
    // ? super E表示传递e或者e的所有父类类型
    public static<E>  void method(ArrayList<E> list){

    }
}
class ye{

}
class fu extends ye{

}
class zi extends fu{

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

这种方法不要严谨 因为它可以接收所有类
但是如果我只想限定的只接受部分类呢
这时候就用到了通配符
? extend E表示可传递e或者e的所有的子类类型
? super E表示传递e或者e的所有父类类型

泛型类练习

    public static void main(String[] args) {


        ArrayList<BosiCat>list1=new ArrayList<>();
        ArrayList<LihuaCat>list2=new ArrayList<>();
        ArrayList<TaidiDog>list3=new ArrayList<>();
        ArrayList<huskey>list4=new ArrayList<>();


        keepPet(list1);
        keepPet(list2);
        //要求1



        keepPet2(list3);
        keepPet2(list4);
        //要求2

        keepPet3(list1);
        keepPet3(list3);
        //要求3


    }
    //要求1:该方法能养所有品种的猫但不能养狗
    public static void keepPet(ArrayList<? extends Cat>list){
        
    }


    //要求2:该方法能养所有品种的狗但不能养猫
    public static void keepPet2(ArrayList<? extends Dog>list){

    }


    //要求3:该方法能养所有动物但是不能是其他类型
    public static void keepPet3(ArrayList<? extends animal>list){

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

总结