Java泛型深入

一. 泛型的概述和优势

泛型概述

  • 泛型:是JDK5中引入的特性,可以在编译阶段约束操作的数据类型,并进行检查。
  • 泛型的格式:<数据类型>,注意:泛型只能支持引用数据类型。
  • 集合体系的全部接口和实现类都是支持泛型的使用的。

泛型的好处:

  • 统一数据类型
  • 把运行时期的问题提前到了编译期间,避免了强制类型转化可能出现的异常,因为编译阶段类型就能确定下来。

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

    类后面---------------------->泛型类

    方法申明上---------------->泛型方法

    接口后面------------------->泛型接口

package com.gch.d7_genericity;

import java.util.ArrayList;
import java.util.List;

/**
    目标:泛型的概述。

    什么是泛型?
        泛型就是一个标签:<数据类型>
        泛型可以在编译阶段约束只能操作某种数据类型。

    注意:
        JDK 1.7开始之后后面的泛型申明可以省略不写
    小结:
         泛型就是一个标签。
         泛型可以在编译阶段约束只能操作某种数据类型。
         泛型只能支持引用数据类型。
 */
public class GenericityDemo {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("Java");
        list.add("Java2");
        // list.add(23); 直接报错

        List list1 = new ArrayList();
        list1.add("Java");
//        list1.add(23.3);
//        list1.add(false);
        list1.add("Spring");

        // 任意类型加字符串""都是字符串
        // double类型是不能转成String类型的

//        for (Object o : list1) {
//            String ele = (String) o;
//            System.out.println(ele);
//        }

        for (String s : list1) {
            System.out.println(s);
        }

        System.out.println("---------------------");
        // 泛型存储任意类型的元素:
        List list2 = new ArrayList<>();
        list2.add(23);
        list2.add(23.3);
        list2.add("Java");

        // 泛型不支持基本数据类型,只支持引用数据类型
        // List list3 = new ArrayList<>();
        List list3 = new ArrayList<>();
    }
}
 
  

二. 自定义泛型类

Java泛型深入_第1张图片

package com.gch.d8_genericity_class;

import java.util.ArrayList;

public class MyArrayList {
    // 外部对象可以再包一个内部对象,这是一种装饰模式的一种思想
    private ArrayList lists = new ArrayList();
    public void add(E e){
        lists.add(e);
    }

    public void remove(E e){
        lists.remove(e);
    }

    @Override
    public String toString() {
        return lists.toString();
    }
}
package com.gch.d8_genericity_class;

public class Test {
    public static void main(String[] args) {
        // 需求:模拟ArrayList定义一个MyArrayList,关注泛型设计
        MyArrayList list = new MyArrayList<>();
        list.add("Java");
        list.add("Java");
        list.add("MySQL");
        list.remove("MySQL");
        System.out.println(list); // [Java, Java]

        MyArrayList list1 = new MyArrayList<>();
        list1.add(23);
        list1.add(24);
        list1.add(25);
        list1.remove(25);
        System.out.println(list1); // [23, 24]
    }
}

三. 自定义泛型方法

Java泛型深入_第2张图片

package com.gch.d10_genericity_method;

/**
    目标:自定义泛型方法。

    什么是泛型方法?
        定义了泛型的方法就是泛型方法。

    泛型方法的定义格式:
        修饰符 <泛型变量> 返回值类型 方法名称(形参列表){

        }
        注意:方法定义了是什么泛型变量,后面就只能用什么泛型变量。
        泛型类的核心思想:是把出现泛型变量的地方全部替换成传输的真实数据类型。

    需求:给你任何一个类型的数组,都能返回它的内容。Arrays.toString(数组)的功能!

    小结:
        泛型方法可以让方法更灵活的接收数据,可以做通用技术!
 */
public class GenericDemo {
    public static void main(String[] args) {
        String[] names = {"小璐", "蓉容", "小何"};
        System.out.println(printArray(names));


        Integer[] ages = {10, 20, 30};
        System.out.println(printArray(ages));

        Integer[] ages2 = getArr(ages);
        String[]  names2 = getArr(names);
    }

    public static  T[] getArr(T[] arr){
        return arr;
    }

    /**
     * 打印数组内容的方法
     * @param arr:要打印的数组
     * @return:返回数组的内容
     * @param :数组的类型
     */
    public static  String printArray(T[] arr){
        if(arr != null){
            // 开始拼接内容
            StringBuilder sb = new StringBuilder("[");
            for (int i = 0; i < arr.length; i++) {
                sb.append(arr[i]).append(i == arr.length - 1 ? "" : " , ");
            }
            sb.append("]");
            return sb.toString();
        }else {
             return null;
        }
    }
    
//    public static  void printArray(T[] arr){
//        if(arr != null){
//            StringBuilder sb = new StringBuilder("[");
//            for (int i = 0; i < arr.length; i++) {
//                sb.append(arr[i]).append(i == arr.length - 1 ? "" : ", ");
//            }
//            sb.append("]");
//            System.out.println(sb);
//        }else {
//            System.out.println(arr);
//        }
//    }
}

 四. 自定义泛型接口

Java泛型深入_第3张图片

package com.gch.d11_genericity_interface;

public interface Data {
    void add(E e);
    void delete(int e);
    void update(E e);
}
package com.gch.d11_genericity_interface;

public class StudentData implements Data{
    @Override
    public void add(Student student) {

    }

    @Override
    public void delete(int id) {

    }

    @Override
    public void update(Student student) {

    }
}
package com.gch.d11_genericity_interface;

public class TeacherData implements Data{
    @Override
    public void add(Teacher teacher) {

    }

    @Override
    public void delete(int id) {

    }

    @Override
    public void update(Teacher teacher) {

    }
}

五. 泛型通配符、上下限

 Java泛型深入_第4张图片

package com.gch.d12_genericity_limit;

import java.util.ArrayList;

/**
    目标:泛型通配符。?

    需求:开发一个极品飞车的游戏,所有的汽车都能一起参与比赛。

    注意:
        虽然BMW和BENZ都继承了Car
        但是ArrayList和ArrayList与ArrayList没有关系的!!
    通配符:?
        ?可以在“使用泛型”的时候代表一切类型。
        E T K V 是在定义泛型的时候使用的。
    泛型的上下限:
        ? extends Car : ?必须是Car或者其子类  泛型上限
        ? super Car :?必须是Car或者其父类   泛型下限
    小结:
        通配符:?
        ?可以在“使用泛型”的时候代表一切类型。

 */
public class GenericDemo {
    public static void main(String[] args) {
        ArrayList bmws = new ArrayList<>();
        bmws.add(new BMW());
        bmws.add(new BMW());
        bmws.add(new BMW());
        go(bmws);

        ArrayList benzs = new ArrayList<>();
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        go(benzs);

        ArrayList dogs = new ArrayList<>();
        dogs.add(new Dog());
        dogs.add(new Dog());
        dogs.add(new Dog());
        // go(dogs);
    }

    /**
       所有车比赛
     */
    public static void go(ArrayList cars){
    }
}

class Dog{

}

class BENZ extends Car{
}

class BMW extends Car{
}

// 父类
class Car{
}

 

你可能感兴趣的:(Java,java,c#,开发语言)