文章目录
泛型的语法
泛型的声明
interface 接口 {}和 class 类 <K,V>{}
//比如:List,ArrayList
说明:
- 其中:T,K,V不代表值,而是表示类型
- 任意字母都可以。常用T表示,是Type的缩写
泛型使用的注意事项和细节
interface List<T>{}
public class HashSet<E>{}
- T,E 只能是引用类型
- 看看下面语句是否正确?
List<Integer> list = new ArrayList<Integer>(); //ok
List<int> list2 = new ArrayList<int>(); //error,int是基本数据类型
- 在指定泛型具体类型后,可以传入该类型或者其子类类型
- 泛型使用形式
List <Integer> list1 = new ArrayList<Integer>();
List <Integer> list2 = new ArrayList<>();
- 如果我们这样写
List list3 = new ArrayList();
默认给它的 泛型是[E 就是 Object]
package com.tao.generic_;
import java.util.ArrayList;
import java.util.List;
/**
* Create By 刘鸿涛
* 2022/1/11 1:20
*/
public class GenericDetail {
public static void main(String[] args) {
Pig<A> pig = new Pig<A>(new A()); //A作为Pig的泛型
pig.show();
Pig<A> pig2 = new Pig<A>(new B()); //因为B继承A
pig2.show();
//3.泛型的使用形式
ArrayList<Integer> list1 = new ArrayList<Integer>();
List<Integer> list2 = new ArrayList<Integer>();
//在实际开发中,我们往往简写
ArrayList<Integer> list3 = new ArrayList<>();
List<Integer> list4 = new ArrayList<>();
ArrayList<Pig> pigs = new ArrayList<>();
//4.如果是这样写,泛型默认是 Object
ArrayList arrayList = new ArrayList();
// ||||||||
ArrayList<Object> arrayList1 = new ArrayList();
}
}
class A{
}
class B extends A{
}
class Pig<E>{
E e;
public Pig(E e){
this.e = e;
}
public void show(){
System.out.println(e.getClass());
}
}
泛型的实例化
要在类名后面指定类型参数的值(类型)。如:
- List strList = new ArrayList();
- Iterator iterator = customers.iterator();
泛型应用实例
创建 3个学生对象
放入到HashSet中学生对象,使用.
放入到 HashMap中,要求 Key 是String name,Value 就是 学生对象
使用两种方式遍历
package com.tao.generic_;
import java.util.*;
/**
* Create By 刘鸿涛
* 2022/1/11 0:06
*/
@SuppressWarnings({"all"})
public class GenericExercise {
public static void main(String[] args) {
//使用泛型方式给HashSet 放入3个学生对象
HashSet<Student> students = new HashSet<Student>();
students.add(new Student("刘刘",20));
students.add(new Student("涛涛",40));
students.add(new Student("汤姆",50));
System.out.println("---增强for遍历---");
for (Student o:students){
System.out.println(o);
}
//使用泛型方式
HashMap<String,Student> map = new HashMap<String,Student> ();
map.put("刘刘",new Student("刘刘",20));
map.put("涛涛",new Student("涛涛",40));
map.put("汤姆",new Student("汤姆",50));
//迭代器 EntrySet
Set<Map.Entry<String,Student>> entries = map.entrySet();
Iterator<Map.Entry<String,Student>> iterator = entries.iterator();
System.out.println("============================");
while (iterator.hasNext()){
Map.Entry<String,Student> next = iterator.next();
System.out.println(next.getKey() + "-" + next.getValue());
}
}
}
/**
* 创建 3个学生对象
* 放入到HashSet中学生对象,使用.
* 放入到 HashMap中,要求 Key 是String name,Value 就是 学生对象
* 使用两种方式遍历
*/
class Student {
String name;
int age;
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public String toString(){
return name + "," + age;
}
}
泛型课堂练习
- 定义Employee类
- 该类包含:private成员变量name,sal,brithday,其中birthday 为 MyDate 类的对象;
- 为每一个属性定义 getter,setter 方法;
- 重写 toString 方法输出 name,sal,birthday
- MyDate类包含:private成员变量month,day,year;并为每一个属性定义getter,setter 方法;
- 创建该类的 3个对象,并把这些对象放入 ArrayList 集合中(ArrayList 需使用泛型来定义),对集合中的元素进行排序,并遍历输出;
- 排序方式:调用ArrayList 的sort 方法,传入 Comparator对象[使用泛型],先按照name排序,如果那么相同,则按生日日期的先后排序。
package com.tao.generic_;
import java.util.ArrayList;
import java.util.Comparator;
/**
* Create By 刘鸿涛
* 2022/1/11 1:46
*/
public class HomeWork01 {
public static void main(String[] args) {
ArrayList<Employee> employees = new ArrayList<Employee>();
employees.add(new Employee("刘刘", 10, new MyDate(2000, 10, 10)));
employees.add(new Employee("刘刘", 10, new MyDate(2001, 11, 11)));
employees.add(new Employee("刘刘", 10, new MyDate(1999, 12, 12)));
System.out.println(employees);
System.out.println("==对员工进行排序==");
employees.sort(new Comparator<Employee>() {
@Override
public int compare(Employee emp1, Employee emp2) {
//先按照 name 排序,如果name相同,则按生日日期的先后排序。[定制排序]
//先对传入的参数进行验证
if(!(emp1 instanceof Employee && emp2 instanceof Employee)){
System.out.println("类型不正确");
return 0;
}
//比较name
int i = emp1.getName().compareTo(emp2.getName());
if(i != 0){
return i;
}
//下面是对birthday的比较,因此,我们最好把这个比较,放在MyDate类完成
//封装后,将来可维护性和复用性,就大大提高
return emp1.getBirthday().compareTo(emp2.getBirthday());
}
});
System.out.println(employees);
}
}
class Employee {
private String name;
private int sal;
private MyDate birthday;
public Employee(String name, int sal, MyDate birthday) {
this.name = name;
this.sal = sal;
this.birthday = birthday;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSal() {
return sal;
}
public void setSal(int sal) {
this.sal = sal;
}
public MyDate getBirthday() {
return birthday;
}
public void setBirthday(MyDate birthday) {
this.birthday = birthday;
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", sal=" + sal +
", birthday=" + birthday +
'}';
}
}
class MyDate {
private int year;
private int month;
private int day;
public MyDate(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
@Override
public String toString() {
return "MyDate{" +
"year=" + year +
", month=" + month +
", day=" + day +
'}';
}
public int compareTo(MyDate o){
//如果name 相同,就比较 birthday 、 year
int yearMinus = year - o.getYear();
if (yearMinus != 0){
return yearMinus;
}
//如果year 相同,就比较 month
int monthMinus = month - o.getMonth();
if (monthMinus != 0){
return monthMinus;
}
return 0;
}
}
自定义泛型
基本语法
class 类名<T,R...>{ //...表示可以有多个泛型
成员
}
注意细节
- 普通成员可以使用泛型(属性,方法)
- 使用泛型的数组,不能初始化
- 静态方法中不能使用类的泛型
- 泛型类的类型,是在创建对象时确定的(因为创建对象时,需要指定确定类型)
- 如果在创建对象时,没有指定类型,默认为Object
package com.tao.generic_.customgeneric;
/**
* Create By 刘鸿涛
* 2022/1/11 2:36
*/
public class Customgeneric {
public static void main(String[] args) {
Tiger<String, Double, Object> taotao = new Tiger<String, Double, Object>("taotao");
taotao.setR(4.0); //Double
taotao.setM(11.0); //Object
taotao.setT("f"); //String
System.out.println(taotao);
}
}
//1. Tiger 后面泛型,所以我们把 Tiger 就称为自定义泛型类
//2. T,R,M 泛型的标识符,一般是单个大写字母
//3. 泛型标识符可以有多个
//4. 普通成员可以使用泛型(属性、方法)
//5. 使用泛型的数组,不能初始化
//6. 静态方法不能使用泛型
class Tiger<T,R,M>{
String name;
R r;
M m;
T t;
//因为数组在new 不能确定T的类型,就无法在内存开辟空间
// T[] ts = new T[8]; //error
public Tiger(String name){
this.name = name;
}
public Tiger( R r, M m, T t) {
this.r = r;
this.m = m;
this.t = t;
}
//因为静态是和类相关的,在类加载时,对象还没有创建
//所以,如果静态方法和静态属性使用了泛型,JVM就无法完成初始化
// static R r2; //error
// public static void m1(M m){} //error
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public R getR() { //方法使用泛型
return r; //返回值为泛型
}
public void setR(R r) {
this.r = r;
}
public M getM() {
return m;
}
public void setM(M m) {
this.m = m;
}
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
@Override
public String toString() {
return "Tiger{" +
"name='" + name + '\'' +
", r=" + r +
", m=" + m +
", t=" + t +
'}';
}
}
自定义泛型接口
基本语法
interface 接口名 <T,R...>{
}
注意细节
- 接口中,静态成员也不能使用泛型(这个和泛型类规定一样)
- 泛型接口的类型,在继承接口或者实现接口时确定
- 没有指定类型,默认为Object
interface A<A,B>{
}
interface B extends A<String,Double>{ //确定父类接口中的泛型类型,如果没有指定,默认Object
}
package com.tao.generic_.customgeneric;
/**
* Create By 刘鸿涛
* 2022/1/11 5:14
*/
public class CustomInterfaceGeneric {
public static void main(String[] args) {
}
}
/**
*
* 泛型接口使用的说明
* 1.接口中,静态成员也不能使用泛型
* 2.泛型接口的类型,在继承接口或者实现接口时确定
*/
//在继承接口 指定泛型接口的类型
interface IA extends IUsb<String,Double>{
}
//当我们去实现IA接口时,因为IA在继承IUsu接口时,指定了U 为String R为Double,
//在实现IUsu接口的方法时,使用String替换U,是Double替换R
class AA implements IA{
@Override
public Double get(String s) {
return null;
}
@Override
public void hi(Double aDouble) {
}
@Override
public void run(Double r1, Double r2, String u1, String u2) {
}
@Override
public Double method(String s) {
return IA.super.method(s);
}
}
//实现接口时,直接指定泛型接口的类型
//给U 指定Integer 给R 指定了 Float
//所以,当我们实现IUsb方法时,会使用Integer替换U,使用Float替换R
class BB implements IUsb<Integer,Float>{
@Override
public Float get(Integer integer) {
return null;
}
@Override
public void hi(Float aFloat) {
}
@Override
public void run(Float r1, Float r2, Integer u1, Integer u2) {
}
}
interface IUsb<U, R>{
int n = 10;
//U name = "taotao"; //error,不能这样使用
//普通方法中,可以使用接口泛型
R get(U u);
void hi(R r);
void run(R r1, R r2, U u1, U u2);
//在jdk8中,可以在接口中,使用默认方法
default R method(U u){
return null;
}
}
//没有指定类型,默认为Object
class CC implements IUsb{ //<Object,Object>
@Override
public Object get(Object o) {
return null;
}
@Override
public void hi(Object o) {
}
@Override
public void run(Object r1, Object r2, Object u1, Object u2) {
}
}
自定义泛型方法
基本语法
修饰符 <T,R...>返回类型 方法名(参数列表){
}
注意细节
-
当泛型方法被调用时,类型会确定
-
public void eat(E e){} //修饰符后没有<T,R...>eat方法不是泛型方法,而是使用了泛型
泛型方法练习
package com.tao.generic_.customgeneric;
/**
* Create By 刘鸿涛
* 2022/1/11 17:56
*/
public class CustomGenericMethodExercise {
public static void main(String[] args) {
Apple<String,Integer,Double>apple = new Apple<>();
apple.fly(10); //Integer
apple.fly(new Dog()); //Dog
}
}
class Apple<T,R,M>{
public<E> void fly(E e){
//getClass()运行类型或者包名,getSimpleName()类的简写名称
System.out.println(e.getClass().getSimpleName());
}
public void eat(R r){}
public void run(M m){}
}
class Dog{
}
泛型继承和通配
- 泛型不具备继承性
List list = new ArrayList(); //error
- <?>:支持任意泛型类型
- <? extends A>:支持A类以及A类的子类,规定了泛型的上限
- <?super A>:支持A类以及A类的父类,不限于直接父类,规定了泛型的下限
package com.tao.generic_.customgeneric;
import java.util.ArrayList;
import java.util.List;
/**
* Create By 刘鸿涛
* 2022/1/11 18:22
*/
public class GenericExercise {
public static void main(String[] args) {
//泛型没有继承性
//ArrayList<Object> a = new ArrayList<String>();
//举例说明下面三个方法的使用
List<Object> list1 = new ArrayList<>();
List<String> list2 = new ArrayList<>();
List<A> list3 = new ArrayList<>();
List<B> list4 = new ArrayList<>();
List<C> list5 = new ArrayList<>();
//如果是 List<?>c,可以接收任意的泛型类型
printCollection1(list1);
printCollection1(list2);
printCollection1(list3);
printCollection1(list4);
printCollection1(list5);
//List<? extends A> c 表示 上限,可以接收 A或者 A子类
// printCollection2(list1); //Object error
// printCollection2(list2); //String error
printCollection2(list3);
printCollection2(list4);
printCollection2(list5);
printCollection3(list1); //A的父类
// printCollection3(list2); //String error
printCollection3(list3); //A类
// printCollection3(list4); //B类 error
// printCollection3(list5); //C类 error
}
//编写几个方法
//说明:List <?> 表示 任意的泛型类型都可以接收
public static void printCollection1(List<?> c) {
for (Object o : c) { //通配符,取出时,就是Object
System.out.println(o);
}
}
//? extends A 表示 上限,可以接收 A或者 A子类
public static void printCollection2(List<? extends A> c){
for (Object o : c){
System.out.println(o);
}
}
// ? super 子类类名AA:支持AA类以及AA类的父类,不限于直接父类
//规定了泛型的下限
public static void printCollection3(List<? super A> c){
for (Object o : c){
System.out.println(o);
}
}
}
class A {
}
class B extends A {
}
class C extends B {
}
JUnit使用
- 为什么需要JUnit
- 一个类有很多功能代码需要测试,为了测试,就需要写入到main方法中
- 如果有多个功能代码测试,就需要来回注销,切换很麻烦
- 如果可以直接运行一个方法,就方便很多,并且可以给出相关信息,就好了 -> JUnit
- Alt + Enter导入包
泛型课堂练习2
编程题 Homework01
package com.tao.generic_.homeword;
import org.testng.annotations.Test;
import java.util.*;
/**
* Create By 刘鸿涛
* 2022/1/11 19:16
*/
public class Homework01 {
public static void main(String[] args) {
}
@Test
public void testList(){
//说明
//这里我们给T 指定类型是User
DAO<User> dao = new DAO<>();
dao.save("001",new User(1,10,"jack"));
dao.save("002",new User(2,18,"king"));
dao.save("003",new User(3,38,"smith"));
List<User> list = dao.list();
System.out.println("list = " + list);
dao.update("003",new User(3,58,"milan"));
//更新数据后
System.out.println(dao.list());
System.out.println("id=03" + dao.get("003")); //milan
}
}
class DAO<T>{
private Map<String,T> map = new HashMap<String,T>();
//保存T类型的对象到 Map 成员变量中
public void save(String id,T entity){
map.put(id, entity);
}
//从 map中获取 id 对应的对象
public T get(String id){
return map.get(id);
}
//替换 map 中key为 id的内容,改为 entity对象
public void update(String id,T entity){
map.put(id, entity);
}
//返回map 中存放的所有T 对象
//遍历map[k - v] , 将map的所有value(T entity),封装到ArrayList返回即可
public List<T> list(){
//创建 ArrayList
List<T> list = new ArrayList<>();
//遍历map
Set<String> keySet = map.keySet();
for (String o : keySet){
//map.get(o) 返回就是User 对象 -> ArrayList
list.add(map.get(o)); //list.add(get(o));
}
return list;
}
//删除指定id对象
public void delete(String id){
map.remove(id);
}
}
class User{
private int id,age;
private String name;
public User(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", age=" + age +
", name='" + name + '\'' +
'}';
}
}
泛型结论
一句话搞定泛型
- 泛型就是一种可以接收数据类型的数据类型!!