泛型
1、泛型介绍
泛型（Generics）是一种强大的 Java 编程语言特性，它允许在**定义类、接口和方法时使用类型参数。**通过使用泛型，可以使代码更加通用、类型安全，并提高代码的可读性和重用性。泛型又称为参数化类型，是Jdk5.0出现的新特性。
（1）传统方法问题
- 不能对加入集合ArrayList等中的数据类型进行约束（不安全）
- 遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有一定影响
（2）泛型方法优点
- 编译时，检查添加元素的类型，提高了安全性
- 减少了类型转换的次数，提高了效率
- 不再提示编译警告
举例：
public class Generic01 {
public static void main(String[] args) {
//1、常见集合使用了泛型： public class ArrayList<E>，这里指定E为Integer类型
List list = new ArrayList<Integer>();
//E在定义的时候，也就是编译的时候确定E为String类型
Person<String> person = new Person<String>("Jack");
}
}
//创建类或者接口的时候可以使用泛型
class Person<E> { //泛型在编译时，确定类型
E s;
public Person(E s) { //可以是参数类型
this.s = s;
}
//方法也可以使用泛型
public E function01(){
return s; //可以是返回类型
}
}
2、泛型语法
（1） 泛型的声明
interface 接口<T>{} //里面可以有多个
class 类<K,V>{}
说明：
（1）T,K,V不代表值，而是表示类型
（2）任意字母都可以，常用T表示，是Type的缩写
（2）泛型的实例化
需要在类名后面的泛型中给定一个具体的类型，比如：
List<String> list = new ArrayList<String>();
Iterator<Customer> iterator = customer.iterator();
举例
public static void main(String[] args) {
HashSet<Student> students = new HashSet<Student>();
students.add(new Student("jack", 18));
students.add(new Student("tom", 28));
students.add(new Student("mary", 19));
//增强for循环遍历
for(Student s : students){
System.out.println(s);
}
//public class HashMap<K,V> ,这里String -> K , Student -> V
HashMap<String, Student> hashMap = new HashMap<String, Student>();
hashMap.put("jack",new Student("jack", 18));
hashMap.put("tom", new Student("tom", 28));
hashMap.put("mary",new Student("mary", 19));
//迭代器遍历
//public Set<Map.Entry<K,V>> entrySet() ，这里String -> K , Student -> V
Set<Map.Entry<String, Student>> entries = hashMap.entrySet();
// public final Iterator<Map.Entry<K,V>> iterator()，这里String -> K , Student -> V
Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
while (iterator.hasNext()) {
Map.Entry<String, Student> next = iterator.next();
System.out.println(next);
}
}
（3）泛型使用细节以及注意事项
-
泛型中的类型只能是引用类型
-
List<Integer> list1 = new ArrayList<Integer>();//正确 List<int> list2 = new ArrayList<int>(); //编译报错
-
-
在给泛型指定具体类型后，可以传入该类型或者其子类类型
-
List<Map> listMaps = new ArrayList<>(); listMaps.add(new HashMap()); //可以传入该其子类类型
-
-
泛型使用形式
-
List<Integer> list1 = new ArrayList<Integer>(); List<Integer> list2 = new ArrayList<>(); //推荐这种，方便 List arrayList = new ArrayList(); //默认泛型为<E> 即Object
-
3、自定义泛型
（1）自定义泛型类基本语法
class 类名<T,R...>{//...表示可以有多个泛型
成员
}
（2）注意事项与细节
- 普通成员可以使用泛型（属性，方法）
- 使用泛型的数组，不能初始化
- 静态方法中不能使用类的泛型
- 泛型类的类型，是在创建对象的时候确定的
- 如果在创建对象时，没有指定类型，默认为Object
举例：
//Tiger 后面的为泛型，Tiger就称为自定义泛型类
//T,R,M 为泛型的标识符，一般是单个的大写字母
//普通成员可以使用泛型（属性，方法）
class Tiger<T,R,M>{
String name;
T t; //属性使用泛型
R r;
M m;
// T[] t1 = new T[8]; //报错，无法确定数组类型，数组不知道开辟多大空间
public Tiger(String name, T t, R r, M m) { //方法使用泛型
this.name = name;
this.t = t;
this.r = r;
this.m = m;
}
//静态方法，静态属性，是在类加载的时候进行的，但是对象还没有创建，JVM就无法初始化
// static R r2;
// public static void m1(T t){}
}
（3）自定义泛型接口基本语法
interface 接口名<T,R...>{
}
（4）注意事项与细节
- 接口中，静态成员不能使用泛型
- 泛型接口的类型，在继承接口或者实现接口时确定
- 没有指定类型，默认为Object
举例：
//接口中，成员属性时默认静态的 final static
interface IUsb<U,R>{
//普通方法，可以使用泛型接口
// U name; //报错，成员属性时默认静态的 final static
void run(R r1,U u1);
//在jdk8中，可以在接口中，使用默认方法，也是可以使用泛型
default R method(U u){
return null;
}
}
//继承接口时，指定类型 U->String, R->Double
interface AUsb extends IUsb<String, Double>{}
//实现接口时，指定类型 U->String, R->Double
class BUsb implements IUsb<String, Double>{
@Override
public void run(Double r1, String u1) { //自动填充类型
}
}
//未指定，默认为Object
class CUsb implements IUsb{
@Override
public void run(Object r1, Object u1) {//默认为Object
}
}
（5）自定义泛型方法基本语法
修饰符<T,R,...> 返回类型 方法名（参数列表）{
}
（6）注意事项和使用方法
- 泛型方法可以定义在普通类中，也可以定义在泛型类中
- 当泛型方法被调用时，类型被确定
- public void eat(E e){}，修饰符后面没有<T,R…>，这里的方法不是泛型方法，而是使用了泛型
- 泛型方法可以使用自己的泛型，也可以使用类声明的泛型
举例：
public class CustomMethodGeneric {
public static void main(String[] args) {
Car car = new Car();
//调用方法，传入参数，编译器，就会确定类型
car.run("run"); //调用的时候指定泛型的类型
new Fish<Integer>().swim1(2);
Fish fish = new Fish<Integer>();
fish.swim(2,new ArrayList());
}
}
class Car{//普通类的泛型方法
public<E> void run(E e){
System.out.println("泛型方法类型为"+e.getClass());
}
}
class Fish<T>{//泛型类里面的泛型方法
public<U> void swim(U u, T t){ //泛型使用了泛型类的泛型，也可以使用自己方法里面的泛型
System.out.println(u.getClass());
System.out.println(t.getClass());
}
public void swim1(T t){ //使用了泛型，但是不是泛型方法
System.out.println(t.getClass());
}
}
4、泛型继承与通配符
-
泛型不具备继承性
List<Object> list = new ArrayList<String>(); //不可以报错 -
<?>:支持任意泛型的类型 -
<? extends A>:支持A类以及A类的子类，规定了泛型的上限 -
<? super B>:支持A类以及A类的父类，不限于直接父类，规定了泛型的下限
举例：
public class GeneralGeneric {
public static void main(String[] args) {
//<?> 可以接受任意类型的泛型
method1(new ArrayList<Object>());
method1(new ArrayList<String>());
method1(new ArrayList<A>());
//<? extends A>可以接受其本身或者子类的泛型
method2(new ArrayList<A>());
method2(new ArrayList<B>());
// method2(new ArrayList<String>()); //报错
//<? super A>可以接受其本身或者父类的泛型
method3(new ArrayList<A>());
method3(new ArrayList<Object>());
// method2(new ArrayList<B>()); //报错
}
public static void method1(List<?> list){}
public static void method2(List<? extends A> list){}
public static void method3(List<? super A> list){}
}
class A{}
class B extends A{}
5、JUNIT
（1）简介
一个类有很多功能代码需要测试，为了测试，就需要加入main方法之中
如果有很多的功能代码需要测试，就需要来回注销，切换比较麻烦
如果可以直接运行一个方法，就可以很方便，于是便有了JUnit
- JUnit是一个Java语言的单元测试框架
- 多数Java的开发环境都搭建好了JUnit作为单元测试的工具
举例：
public class JUnitMethod {
public static void main(String[] args) {
//传统方法
new JUnitMethod().method1();
new JUnitMethod().method2();
}
//JUnit方法，比较方便，直接加入一个@Test就可以
@Test
public void method1(){
System.out.println("测试方法1");
};
public void method2(){
System.out.println("测试方法2");
};
}
7746
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
