目录
泛型
检查添加元素的类型
减少了类型转换的次数,直接对这个类型进行遍历,例如arraylist<>()
public class Main {
public static void main(String[] args) {
Person<String> person1 = new Person<>("xiaoming");
Person<Integer> person2 = new Person<>(100);
}
}
//E表示s的数据类型,在定义Person对象的时候指定,即在编译期间,就确定E是什么
class Person<E> {
E s;
public Person(E s) {
this.s = s;
}
public E f() {
return s;
}
}
泛型的声明
interface接口 {} 和class 类<K, V...> {}
例如: List,ArrayList
说明:
其中,T,K,V不代表值,而是代表类型
任意字母都行,常用T表示。
泛型的实例化
需要在类名后面指定类型参数的值(类型),例如:
List< String > strList = new ArrayList< String>();
迭代器取值
Iterator< Customer> iterator = customers.iterator()
泛型的使用细节
1、给泛型指定数据类型时,要求是引用类型,不能是基本数据类型,自动装箱。
2、在给泛型指定具体类型后,可以传入该类型或该类型的子类。
3、右边的尖括号可以省略,推荐 List< String > strList = new ArrayList<>();
4、如果不指明泛型类型,默认为 Object 。
5、静态方法和静态属性不能使用泛型。因为静态和类相关,在类加载时,对象还没有创建,JVM 无法实现初始化。
自定义泛型类
- 普通成员可以使用泛型(属性,方法)
- 使用泛型的数组不可初始化
- 静态方法不能使用类的泛型,静态只和类有关,类加载时,对象还没创建
- 泛型类的类型,是在创建对象时确定的(因为创建对象时,需要指定确定类型)
- 如果在创建对象时,没有指定类型,默认为Object,推荐写Object
class Person<E, T> {
E s;
T[] ts;//不能初始化,因为数组在new的时候不能确定T的类型,无法在内存开辟空间
public Person(E s) {
this.s = s;
}
public E f() {
return s;
}
public Person(E s, T[] ts) {
this.s = s;
this.ts = ts;
}
}
自定义泛型接口
- 接口中,静态成员也不能使用泛型,属性是静态的
- 泛型接口的类型,在继承接口或者实现接口时确定
- 没有指定类型,默认Object
自定义泛型方法
- 泛型方法,可以定义在普通类中,也可以定义在泛型类中
- 当泛型方法被调用时,类型会确定
- public void eat(E e) {}, 修饰符后面没有< T, R…> 因此,eat方法不是泛型方法,只是使用了泛型.
public class CustomMethodGeneric {
public static void main(String[] args) {
Car car = new Car();
car.fly("宝马", 100);//当调用方法时,传入参数,编译器,就会确定类型
System.out.println("=======");
car.fly(300, 100.1);//当调用方法时,传入参数,编译器,就会确定类型
//测试
//T->String, R-> ArrayList
Fish<String, ArrayList> fish = new Fish<>();
fish.hello(new ArrayList(), 11.3f);
}
}
//泛型方法,可以定义在普通类中, 也可以定义在泛型类中
class Car {//普通类
public void run() {//普通方法
}
//说明 泛型方法
//1. <T,R> 就是泛型
//2. 是提供给 fly使用的
public <T, R> void fly(T t, R r) {//泛型方法
System.out.println(t.getClass());//String
System.out.println(r.getClass());//Integer
}
}
class Fish<T, R> {//泛型类
public void run() {//普通方法
}
public<U,M> void eat(U u, M m) {//泛型方法
}
//说明
//1. 下面hi方法不是泛型方法
//2. 是hi方法使用了类声明的 泛型
public void hi(T t) {
}
//泛型方法,可以使用类声明的泛型,也可以使用自己声明泛型
public<K> void hello(R r, K k) {
System.out.println(r.getClass());//ArrayList
System.out.println(k.getClass());//Float
}
}
泛型的继承和通配符
泛型不具备继承性
-
< ?> :表示支持任意泛型类型
-
< ? extends A >:支持A类及A类的子类,规定了泛型的上限
-
< ? super A > ;支持A类及A类的父类,不限于直接父类,规定了泛型的下限
public class GenericExtends {
public static void main(String[] args) {
Object o = new String("xx");
//泛型没有继承性
//List<Object> list = new ArrayList<String>();
//举例说明下面三个方法的使用
List<Object> list1 = new ArrayList<>();
List<String> list2 = new ArrayList<>();
List<AA> list3 = new ArrayList<>();
List<BB> list4 = new ArrayList<>();
List<CC> list5 = new ArrayList<>();
//如果是 List<?> c ,可以接受任意的泛型类型
printCollection1(list1);
printCollection1(list2);
printCollection1(list3);
printCollection1(list4);
printCollection1(list5);
//List<? extends AA> c: 表示 上限,可以接受 AA或者AA子类
// printCollection2(list1);//×
// printCollection2(list2);//×
printCollection2(list3);//√
printCollection2(list4);//√
printCollection2(list5);//√
//List<? super AA> c: 支持AA类以及AA类的父类,不限于直接父类
printCollection3(list1);//√
//printCollection3(list2);//×
printCollection3(list3);//√
//printCollection3(list4);//×
//printCollection3(list5);//×
//冒泡排序
//插入排序
//....
}
// ? extends AA 表示 上限,可以接受 AA或者AA子类
public static void printCollection2(List<? extends AA> c) {
for (Object object : c) {
System.out.println(object);
}
}
//说明: List<?> 表示 任意的泛型类型都可以接受
public static void printCollection1(List<?> c) {
for (Object object : c) { // 通配符,取出时,就是Object
System.out.println(object);
}
}
// ? super 子类类名AA:支持AA类以及AA类的父类,不限于直接父类,
//规定了泛型的下限
public static void printCollection3(List<? super AA> c) {
for (Object object : c) {
System.out.println(object);
}
}
}
class AA {
}
class BB extends AA {
}
class CC extends BB {
}
Junit 单元测试类
1、JUnit 是一个 Java 语言的单元测试框
2、多数 Java 的开发环境都已经集成了 Junit 作为单元测试的工具。
3、使用步骤
在方法前加 @Test 注解,等待下载 Maven 依赖
Add Junit to classPath