2020-09-07

1.泛型

1.1泛型概述【理解】(视频01)

1.什么是泛型(泛型概述)

泛型就是参数化类型,也可称为类型参数。格式为:<类型>.（ArrayList）

2.为什么要使用泛型(泛型的好处)

它提供了编译时类型安全检测机制,把运行时期的问题提前到了编译期间
避免了强制类型转换

package com.itheima.genericitysummarize;

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

/**
 *  不写泛型的弊端
 */
public class GenericitySummarize {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add(123);

        Iterator it = list.iterator();
        while(it.hasNext()){
            String next = (String) it.next();
            int len = next.length();
            System.out.println(len);

        }
    }
}

1.2泛型类的使用【应用】（视频02）

1.泛型用在什么地方(泛型可以使用的地方)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F2iYzUxz-1599473380859)(img/1596093650953.png)]

2.什么是泛型类（ArrayList）

如果一个类的后面有，表示这个类是一个泛型类

3.如何使用泛型类

创建泛型类对象时,必须要给这个泛型确定具体的数据类型

1.3 泛型-自定义泛型类(应用)（视频03）

1.如何定义泛型(泛型的定义格式)

<类型>: 指定一种类型的格式.

尖括号里面可以任意书写,一般只写一个字母.

例如:
<类型1,类型2…>: 指定多种类型的格式,多种类型之间用逗号隔开.

例如: <E,T> <K,V><Q,M>

泛型字母总结:

E：元素（Element），多用于java集合框架

K：关键字（Key）

N：数字（Number）

T：类型（Type）

V：值（Value）

2.如何定义泛型类(泛型类格式)

定义格式

修饰符 class 类名<类型> {  }

范例:

public class Generic {},此处的T可以推荐使用常见的T,E,K,V等形式参数来表示泛型

示例代码

package com.itheima.genericityclass;

//就是一个泛型类
public class Box<E> {
    private E element;

    public E getElement() {
        return element;
    }

    public void setElement(E element) {
        this.element = element;
    }
}

测试类

package com.itheima.genericityclass;

/**
 * 自定义泛型类
 */
public class MyGenericityClass {
    public static void main(String[] args) {
        Box<String> box1 = new Box<>();
        box1.setElement("给小丽的土味情话");

        String element1 = box1.getElement();
        System.out.println(element1);


        Box<Integer> box2 = new Box<>();
        box2.setElement(19);

        Integer element2 = box2.getElement();
        System.out.println(element2);

    }
}

1.3泛型-泛型方法的使用【应用】(视频04)

1.什么是泛型方法(前置知识)

方法声明中有泛型的方法，就是一个泛型方法

泛型方法的格式

public <T> T[] toArray(T[] a){}
参数类型 
T - 数组的运行时类型
参数 
a - 要存储列表的元素的数组，如果它足够大; 否则，为此目的分配相同运行时类型的新数组。 
结果 
一个包含列表元素的数组

测试类

package com.itheima.genericitymethod;

import java.util.ArrayList;
import java.util.Arrays;

/**
 * 使用Java中的泛型方法
 */

public class GenericityMethod1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("给小花同学的土味情话");
        list.add("给小丽同学的土味情话");
        list.add("给小路同学的土味情话");
        //将list集合转成一个数组并返回
        //如果是空参的,那么返回的数组类型为Object类型的.
        Object[] objects = list.toArray();
        System.out.println(Arrays.toString(objects));

        String[] strings = list.toArray(new String[list.size()]);
        System.out.println(Arrays.toString(strings));

    }
}

1.4 自定义泛型方法（视频05）

1.定义格式

修饰符 <类型> 返回值类型 方法名(类型 变量名) {  }

范例: public void show(){}

示例代码:

package com.itheima.genericitymethod;

import java.util.ArrayList;

/**
 * 自定义泛型方法
 * 定义一个泛型方法，传递一个集合和四个元素，将元素添加到集合中并返回
 */
public class GenericityMethod2 {
    public static void main(String[] args) {
        ArrayList<String> list1 = addElement(new ArrayList<String>(), "a", "b", "c", "d");
        System.out.println(list1);

        ArrayList<Integer> list2 = addElement(new ArrayList<Integer>(), 1, 2, 3, 4);
        System.out.println(list2);
    }

    public static <T> ArrayList<T> addElement(ArrayList<T> list , T t1 ,T t2 ,T t3 ,T t4){
        list.add(t1);
        list.add(t2);
        list.add(t3);
        list.add(t4);
        return list;
    }
}

1.5泛型接口【应用】(视频06)

定义格式

修饰符 interface 接口名<类型> {  }

示例代码

package com.itheima.genericityinterface;

public class GenericityInterface {
    public static void main(String[] args) {
        GenericityImpl1<String> genericity = new GenericityImpl1<>();
        genericity.method("小丽给我的土味情话");

        GenericityImpl2 genericityImpl2 = new GenericityImpl2();
      genericityImpl2.method(19);
    }
}


interface Genericity<E>{
    public abstract void method(E e);
}

class GenericityImpl2 implements  Genericity<Integer>{

  @Override
    public void method(Integer integer) {
      System.out.println(integer);
    }
}



class GenericityImpl1<E> implements Genericity<E>{

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

1.5类型通配符(视频07)（直接使用父类）

1.类型通配符的格式

<?>

2.泛型通配符的使用

1.类型通配符: <?>

ArrayList<?>: 表示元素类型未知的ArrayList,它的元素可以匹配任何的类型,但是并不能把元素添加到ArrayList中了,获取出来的也是父类类型

2.类型通配符下限: <? extends 类型>

ArrayList <? extends Number>: 它表示的类型是Number或者其子类型

3.类型通配符上限: <? super 类型>

ArrayListList <? super Number>: 它表示的类型是Number或者其父类型

public class Genericbobing{
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        ArrayList<Number> list3 = new ArrayList<>();
        ArrayList<Object> list4 = new ArrayList<>();
		printList(list1);
        printList(list2);
        
        method1(list1);
        method1(list2);
      	method1(list3);
        method1(list4);

        method2(list1);
        method2(list2);
      	method3(list3);
        method4(list4);
    }
  
    // 泛型通配符: 此时的泛型?,可以是任意类型
    public static void printList(ArrayList<?> list){}
    // 泛型的上限: 此时的泛型?,必须是Number类型或者Number类型的子类
    public static void method1(ArrayList<? extends Number> list){}
    // 泛型的下限: 此时的泛型?,必须是Number类型或者Number类型的父类
    public static void method2(ArrayList<? super Number> list){}
}

小结

1.为什么要使用泛型

使用泛型的目的就是为了类型安全，将类型问题从运行时提到编译时进行处理

2.什么是泛型

它提供了编译时类型安全检测机制

3.怎么使用？

在创建声明或创建时给泛型类型指定具体的类型

4.用在哪里？

泛型类、泛型方法、泛型接口

5.泛型通配符

? 、? extends 父类或接口（下限） ? super 父类或接口（上限）

6.多态遇到泛型会怎么样?(扩展不需要讲)

ArrayList alist= ArrayList 对象？

ArrayList alist=List对象?

List llist= ArrayList 对象?

List llist=ArrayList 对象?

public static print(ArrayList list) 是可否可以传ArrayList对象?