泛型

• 定义类、接口、方法时，同时声明了一个或多个类型变量（）
  称为泛型类、泛型接口、泛型方法，统称为泛型
  泛型提供了在编译阶段约束所能操作的数据类型，并自动检查的能力

public class GenericDemo1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList();
        list.add("hello");
        /*list.add(10);
        list.add(true);
        list.add(new Object());*/

        //获取数据
        for(int i=0;i<list.size();i++){
            /*Object obj = list.get(i);
            //把数据进行转型
            String s = (String) obj;
            System.out.println(s);*/

            String s = list.get(i);
            System.out.println(s);
        }
    }
}

泛型类

注意：类型变量建议用大写的英文字母，常见的有：E、D、K、V等

public class MyArrayList<E> {
    private ArrayList<E> list = new ArrayList<>();
    public boolean add(E e) {
        list.add(e);
        return true;
    }
    public boolean remove(E e){
        return list.remove(e);
    }

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

public class demo2 {
    public static void main(String[] args) {
        //自定义泛型类
        //需求：模拟ArrayList集合，自定义一个集合MyArrayList
        MyArrayList<String> mlist = new MyArrayList<>();//JDK7以后，可以省略泛型类型
        mlist.add("hello");
        mlist.add("world");
        //list.add(123);//错误，泛型类型只能是String
        mlist.add("java");

        System.out.println(mlist.remove("hello"));

        System.out.println(mlist);
    }
}

泛型接口

预先定义Student和Teacher两个类，之后定义方法接口

public interface Data<T> {
    void add(T s);
    void delete(T s);
    void update(T s);
    T query(int id);
}

public class StudentData implements Data<Student>{
    @Override
    public void add(Student s) {

    }

    @Override
    public void delete(Student s) {

    }

    @Override
    public void update(Student s) {

    }

    @Override
    public Student query(int id) {
        return null;
    }
}

public class TeacherData implements Data<Teacher>{
    @Override
    public void add(Teacher s) {

    }

    @Override
    public void delete(Teacher s) {

    }

    @Override
    public void update(Teacher s) {

    }

    @Override
    public Teacher query(int id) {
        return null;
    }
}

public class demo3 {
    public static void main(String[] args) {
        //泛型接口的基本作用
        //需求：项目要对学生数据和老师数据进行增删改查
        StudentData sData = new StudentData();
        sData.add(new Student());
        sData.delete(new Student());
        sData.update(new Student());
        Student s = sData.query(1);
    }
}

泛型方法

泛型方法

public static <T> void test(T t){
	
}

示例

public class demo4 {
    public static void main(String[] args) {
        //泛型方法
        //打印任意数组的内容
        String[] a = {"张三","李四","王五"};
        printArray(a);

        Student[] stu = new Student[3];
        printArray(stu);

        Student s = getMax(stu);
        String max = getMax(a);
    }
    public static <T> void printArray(T[] a){

    }
    public static <T> T getMax(T[] a){
        return null;
    }
}

通配符

指的是“?”，可在“使用泛型”时代表一切类型

上下限

• 泛型上限
  ? extends Car：？能接受Car或其子类
• 泛型下限
  ? super Car：？能接受Car或其父类

public class demo5 {
    public static void main(String[] args) {
        //理解通配符和上下限
        ArrayList<Xiaomi> xiaomis = new ArrayList<>();
        xiaomis.add(new Xiaomi());
        xiaomis.add(new Xiaomi());
        xiaomis.add(new Xiaomi());
        go(xiaomis);

        ArrayList<LX> lxs = new ArrayList<>();
        lxs.add(new LX());
        lxs.add(new LX());
        lxs.add(new LX());
        go(lxs);

        /*ArrayList<Bronya> bronyas = new ArrayList<>();
        bronyas.add(new Bronya());
        bronyas.add(new Bronya());
        bronyas.add(new Bronya());
        go(bronyas);*/
    }
    //需求：开发一个飞车游戏
    //虽然Xiaomi和LX都是继承Car，但ArrayList<Xiaomi>和ArrayList<LX>和ArrayList<Car>是没有关系的
    public static void go(ArrayList<? extends Car> cars){

    }
}

泛型支持的类型

• 泛型不支持基本数据类型，只支持对象类型（引用数据类型）

public class demo6 {
    public static void main(String[] args) {
        //泛型和集合不支持基本数据类型，只能支持引用数据类型
        //ArrayList<int> list = new ArrayList<>();
        //泛型的擦除：泛型工作在编译阶段，编译后泛型没用了，就会被擦除掉，泛型类型参数会替换成Object
    }
}

包装类

把基本类型的数据包装成对象的类型

• 自动装箱：基本数据类型自动转为包装类型
• 自动拆箱：包装类型自动转为基本数据类型

包装类其他功能

• 把基本类型数据转换成字符串类型
• 把字符串类型的数值转为数值本身对应的真实数据类型

public class demo6 {
    public static void main(String[] args) {
        //泛型和集合不支持基本数据类型，只能支持引用数据类型
        //ArrayList<int> list = new ArrayList<>();
        //泛型的擦除：泛型工作在编译阶段，编译后泛型没用了，就会被擦除掉，泛型类型参数会替换成Object

        //把基本数据类型变成包装类对象
        //手工包装
        //Integer i = new Integer(10);//过时
        Integer it1 = Integer.valueOf(10);//推荐
        Integer it2 = Integer.valueOf(10);//推荐
        System.out.println(it1==it2);

        //自动装箱：基本数据类型可直接包装成对象的数据
        Integer i = 130;
        Integer j = 130;
        System.out.println(i==j);

        //自动拆箱：包装类型的对象数据可以自动转换成基本数据类型
        int m = i;
        System.out.println( m);

        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);//自动装箱

        int n = list.get(0);//自动拆箱

        //包装类新增功能
        //1、基本类型转为字符串
        int a = 10;
        String s1 = Integer.toString(a);//“10”
        System.out.println(s1+1);//101

        Integer b = a;
        String s2 = b.toString();
        System.out.println(s2+1);

        String s3 = b + "";
        System.out.println(s3+1);

        //2、字符串数值转为对应的基本数据类型（重要）
        String s = "123";
        //int c = Integer.parseInt(s);
        int c = Integer.valueOf(s);
        System.out.println(c+1);

        String s4 = "123.456";
        //double d = Double.parseDouble(s4);
        double d = Double.valueOf(s4);
        System.out.println(d+1);
    }
}