一. 泛型的概述和优势
泛型概述
- 泛型：是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<String> list = new ArrayList<>();
list.add("Java");
list.add("Java2");
// list.add(23); 直接报错
List<String> 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("---------------------");
// 泛型存储任意类型的元素:<Object>
List<Object> list2 = new ArrayList<>();
list2.add(23);
list2.add(23.3);
list2.add("Java");
// 泛型不支持基本数据类型,只支持引用数据类型
// List<int> list3 = new ArrayList<>();
List<Integer> list3 = new ArrayList<>();
}
}
二. 自定义泛型类
package com.gch.d8_genericity_class;
import java.util.ArrayList;
public class MyArrayList<E> {
// 外部对象可以再包一个内部对象,这是一种装饰模式的一种思想
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<String> list = new MyArrayList<>();
list.add("Java");
list.add("Java");
list.add("MySQL");
list.remove("MySQL");
System.out.println(list); // [Java, Java]
MyArrayList<Integer> list1 = new MyArrayList<>();
list1.add(23);
list1.add(24);
list1.add(25);
list1.remove(25);
System.out.println(list1); // [23, 24]
}
}
三. 自定义泛型方法
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> T[] getArr(T[] arr){
return arr;
}
/**
* 打印数组内容的方法
* @param arr:要打印的数组
* @return:返回数组的内容
* @param <T>:数组的类型
*/
public static <T> 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 <T> 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);
// }
// }
}
四. 自定义泛型接口
package com.gch.d11_genericity_interface;
public interface Data <E>{
void add(E e);
void delete(int e);
void update(E e);
}
package com.gch.d11_genericity_interface;
public class StudentData implements Data<Student>{
@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<Teacher>{
@Override
public void add(Teacher teacher) {
}
@Override
public void delete(int id) {
}
@Override
public void update(Teacher teacher) {
}
}
五. 泛型通配符、上下限
package com.gch.d12_genericity_limit;
import java.util.ArrayList;
/**
目标：泛型通配符。?
需求：开发一个极品飞车的游戏，所有的汽车都能一起参与比赛。
注意：
虽然BMW和BENZ都继承了Car
但是ArrayList<BMW>和ArrayList<BENZ>与ArrayList<Car>没有关系的！!
通配符：？
？可以在“使用泛型”的时候代表一切类型。
E T K V 是在定义泛型的时候使用的。
泛型的上下限：
？ extends Car : ?必须是Car或者其子类 泛型上限
? super Car ：？必须是Car或者其父类 泛型下限
小结：
通配符：？
？可以在“使用泛型”的时候代表一切类型。
*/
public class GenericDemo {
public static void main(String[] args) {
ArrayList<BMW> bmws = new ArrayList<>();
bmws.add(new BMW());
bmws.add(new BMW());
bmws.add(new BMW());
go(bmws);
ArrayList<BENZ> benzs = new ArrayList<>();
benzs.add(new BENZ());
benzs.add(new BENZ());
benzs.add(new BENZ());
go(benzs);
ArrayList<Dog> dogs = new ArrayList<>();
dogs.add(new Dog());
dogs.add(new Dog());
dogs.add(new Dog());
// go(dogs);
}
/**
所有车比赛
*/
public static void go(ArrayList<? extends Car> cars){
}
}
class Dog{
}
class BENZ extends Car{
}
class BMW extends Car{
}
// 父类
class Car{
}
