Java进阶笔记——泛型

一、泛型

 泛型方法：

当方法中形参类型不确定时：1、使用类名后定义的泛型（所有方法都能用）

                                                2、在方法申明上定义自己的泛型（只有本方法可用）

package com.JinJie.MyList;

import java.util.ArrayList;

//泛型练习
// 构建一个工具类ListUtil，类中定义方法addAll可以把元素添加到集合
public class demo03 {

    public static void main(String[] args) {

        ArrayList<Integer> ints = new ArrayList<>();
        ListUtil listUtil = new ListUtil();
        listUtil.addAll(ints,1,2,3,4,5,6,7,8,9);
        System.out.println(ints);
    }
}

class ListUtil{
    private int size;

    public ListUtil() {}

    public  <E> void addAll(ArrayList arr, E ... e){
        for (int i = 0; i < e.length; i++) {
            arr.add(e[i]);
        }
        size = arr.size();
        System.out.println(size);
    }
}

泛型接口：

package com.JinJie.MyList;

//泛型接口练习
public class demo04 {

    public static void main(String[] args) {

        test1impl test1impl = new test1impl();
        test1impl.myMethod("234234");

        test2impl<Double> doubletest2impl = new test2impl<>();
        doubletest2impl.myMethod(34.3);
    }
}

interface test1<E>{
    void myMethod(E e);
}

//实现类给出具体类型
class test1impl implements test1<String>{

    @Override
    public void myMethod(String str) {
        System.out.println(str);
    }
}

//实现类沿用泛型
class test2impl<E> implements test1<E>{

    @Override
    public void myMethod(E e) {
        System.out.println(e);
    }
}

泛型不具备继承性，但数据具备继承性

通过泛型通配符？解决：？也表示不确定的类型，但可以进行类型的限定。

？extends E：表示可以传递E或者E的所有子类

？super E：表示可以传递E或者E的所有父类

 应用场景：

1、如果在定义类、方法、接口时，不确定类型，则可以使用泛型类、泛型方法、泛型接口

2、如果不确定类型，但可以确定只传递某个继承体系的类型，则使用泛型通配符

 泛型通配符练习：

package com.JinJie.MyList.demo05;

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(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 abstract void eat();
}

package com.JinJie.MyList.demo05;

public abstract class Cat extends Animal{
}

class BoSiCat extends Cat{
    @Override
    public void eat() {
        System.out.println("一只叫做"+getName()+"的,"+getAge()+"岁的波斯猫，正在吃饼干。");
    }
}

class LiHuaCat extends Cat{
    @Override
    public void eat() {
        System.out.println("一只叫做"+getName()+"的,"+getAge()+"岁的梨花猫，正在吃鱼。");
    }
}

package com.JinJie.MyList.demo05;

public abstract class Dog extends Animal{
}

class TaiDi extends Dog{
    @Override
    public void eat() {
        System.out.println("一只叫做"+getName()+"的,"+getAge()+"岁的泰迪，正在吃骨头边吃边蹭。");
    }
}

class HaShiQi extends Dog{
    @Override
    public void eat() {
        System.out.println("一只叫做"+getName()+"的,"+getAge()+"岁的哈士奇，正在吃骨头边吃边拆家。");
    }
}

package com.JinJie.MyList.demo05;

import java.util.ArrayList;

public class Test {

    public static void main(String[] args) {
        BoSiCat boSiCat = new BoSiCat();
        boSiCat.setName("波斯猫");
        boSiCat.setAge(3);

        LiHuaCat liHuaCat = new LiHuaCat();
        liHuaCat.setAge(4);
        liHuaCat.setName("狸花猫");

        HaShiQi haShiQi = new HaShiQi();
        haShiQi.setAge(5);
        haShiQi.setName("哈士奇");

        TaiDi taiDi = new TaiDi();
        taiDi.setAge(6);
        taiDi.setName("泰迪");

        ArrayList<Cat> cats = new ArrayList<>();
        cats.add(liHuaCat);
        cats.add(boSiCat);
        keepCat(cats);
        System.out.println("===========================");

        ArrayList<Dog> dogs = new ArrayList<>();
        dogs.add(haShiQi);
        dogs.add(taiDi);
        keepDog(dogs);
        System.out.println("===========================");

        ArrayList<Animal> animals = new ArrayList<>();
        animals.add(liHuaCat);
        animals.add(boSiCat);
        animals.add(haShiQi);
        animals.add(taiDi);
        keepPet(animals);
    }

    //能养所有的猫但不能养狗,遍历集合调用动物的eat方法
    public static void keepCat(ArrayList<? extends Cat> arr){
        for (int i = 0; i < arr.size(); i++) {
            arr.get(i).eat();
        }
    }

    //能养所有的狗但不能养猫。。。
    public static void keepDog(ArrayList<? extends Dog> arr){
        for (Dog dog : arr) {
            dog.eat();
        }
    }

    //能养所有的动物，但不能传递其他类型
    public static void keepPet(ArrayList<? extends Animal> arr){
        for (Animal animal : arr) {
            animal.eat();
        }
    }
}

总结