泛型的理解和好处
泛型的好处
- 编译时,检查添加元素的类型,提高了安全性
- 减少了类型转换的次数,提高效率
不使用泛型
Dog-加入->Object-取出->Dog(向下转型) Dog放入到ArrayList 会先转成Object,在转出时,还需要转换成Dog
使用泛型
Dog->Dog->Dog 放入和取出时,不需要类型转换,提高效率 - 不再提示编译警告
泛型的介绍
泛型:广泛类型
- 泛型又称参数化类型,是JDK5.0 出现的新特性,解决数据类型的安全性问题
- 在类声明或实例化时(在定义对象时,即编译期间),只要指定好需要的具体类型即可
- Java 泛型可以保证如果程序在编译时,没有发出警告,运行时就不会产生,ClassCastException异常。同时,代码更加简洁
- 泛型的作用:可以在类声明时通过一个标识表示类中某个属性的类型,或者某个方法的返回值类型,或者是参数类型
public class Generic01 {
public static void main(String[] args) {
//注意:E 具体的数据类型在定义Person对象时指定(即在编译期间),就确定E是什么类型
Person<Integer> integerPerson = new Person<>(1);//E的数据类型是Integer
integerPerson.show();
}
}
//泛型的作用:可以在类声明时通过一个标识表示类中某个属性的类型、某个方法的返回值类型 或 参数类型
class Person<E>{
E S;//E表示s的数据类型,该数据类型在定义Person对象的时候指定,即在编译期间,就确定E是什么类型
public Person(E s) {//E也可以是参数类型
S = s;
}
public E f(){//E也可以是返回类型
return S;
}
public void show(){
System.out.println("S的运行类型="+S.getClass());
}
}
结果
泛型的语法
泛型的声明
- interface 接口{} 和 class类<K,V>{}
1,其中 T K V 不代表值,而是表示类型
2,任意字母都可以,常用T表示,是Type的缩写
泛型的实例化
要在类名后面指定类型参数的值(类型)。如:
- 1,List strList = new ArrayList();
- 2,Iterator iterator = customers.iterator();
泛型使用实例
public class GenericExercise {
public static void main(String[] args) {
//使用泛型方式给HashSet放入三个学生对象,遍历时可以直接调用Student1中的方法
Set<Student1> objects = new HashSet<Student1>();
objects.add(new Student1("jack"));//当调用add方法时,显示调用Student1 对象
objects.add(new Student1("tom"));
objects.add(new Student1("smith"));
// 遍历
for(Student1 o:objects){
System.out.println(o.getName());
}
//使用泛型方式给 HashMap 放入 3 个学生对象
//K -> String V->Student
//一旦添加了泛型,编译器就会规范调用类型
Map<String, Student1> map = new HashMap<String, Student1>();
//public class HashMap<K,V> {}
Student1 student1 = new Student1("jack");
Student1 student2 = new Student1("tom");
Student1 student3 = new Student1("smith");
map.put("jack",student1);
map.put("tom",student2);
map.put("smith",student3);
//遍历
//迭代器 EntrySet
/*
public Set<Map.Entry<K,V>> entrySet() {
Set<Map.Entry<K,V>> es;
return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
}
*/
//1,map.entrySet();
Set<Map.Entry<String, Student1>> entries = map.entrySet();
/*
public final Iterator<Map.Entry<K,V>> iterator() {
return new EntryIterator();
}
*/
//2,调迭代器 entries.iterator()
Iterator<Map.Entry<String, Student1>> iterator = entries.iterator();
//3,先判断hasNext 下一个是否还有
while (iterator.hasNext()) {
Map.Entry<String, Student1> next = iterator.next();
System.out.println(next.getKey()+"-"+next.getValue());
}
}
}
class Student1{
private String name;
public Student1(String name) {
this.name = name;
}
public String getName() {
return name;
}
@Override
public String toString() {
return "Student1{" +
"name='" + name + '\'' +
'}';
}
}
结果
泛型的注意事项
- 1,interface List{} public class HashSet{}
说明:T E 只能是引用类型 - 2,在给泛型指定具体类型后,可以传入该类型或其子类类型
- 3,泛型使用形式
List list1 = new ArrayList ();
List list1 = new ArrayList <>();
如果我们这样写List list1 = new ArrayList (); 默认他的泛型是 E 就是Object
public class GenericDetail {
public static void main(String[] args) {
//1,泛型指向的数据类型是引用类型Integer,不能是基本数据类型int
List<Integer> list = new ArrayList<Integer>();
//List<int> list = new ArrayList<int>(); 错误
//2,E指定了A类型,构造器传入 new A()
// 在给泛型指定具体类型后,可以传入该类型或者子类类型
Pig<A> aPig = new Pig<A>(new A());
aPig.f();
Pig<A> aPig1 = new Pig<A>(new B());
aPig1.f();
//3,泛型的使用形式
List<Integer> list1 = new ArrayList <Integer>();
//实际开发中往往简写为:
List<Integer> list2 = new ArrayList <>();
//4,如果我们这样写List list1 = new ArrayList (); 默认他的泛型是 <E> E 就是Object
List list3 = new ArrayList ();//等价 ArrayList<Object> arrayList = new ArrayList<Object>();
}
}
class A{
}
class B extends A{}
class Pig<E>{
E e;
public Pig(E e) {
this.e = e;
}
public void f(){
System.out.println("Pig类中的f方法");
}
}
自定义泛型
自定义泛型类
- 基本语法
class 类名<T,R…>{//…表示可以有多个泛型
成员} - 注意细节
1,普通成员可以使用泛型(属性,方法)
2,使用泛型的数组,不能初试化
3,静态方法中不能使用类的泛型
4,泛型类的类型,是在创建对象时确定的(因为创建对象时,需要指定确定类型)
5,如果在创建对象时,没有指定类型默认为Object
public class CustomGeneric {
public static void main(String[] args) {
//4,泛型类的类型,是在创建对象时确定的(因为创建对象时,需要指定确定类型)
//T=Double, R=String, M=Integer
Tiger<Double, String, Integer> g = new Tiger<Double, String, Integer>("john");
g.setT(10.9);//ok
//g.setT("yy");//错误,类型不对
System.out.println(g);
//5,如果在创建对象时,没有指定类型默认为Object
Tiger g2 = new Tiger("john~~~");//ok T=Object R=Object M=Object
//等价于 Tiger<Object,Object,Object> g2 = new Tiger<Object,Object,Object>("john~~~")
g2.setT("yy"); //OK 因为 T=Object "yy" = String 是 Object 子类
System.out.println("g2="+g2);
}
}
//T, R, M 泛型的标识符, 一般是单个大写字母,泛型标识符可以有多个
class Tiger<T,R,M>{
String name;
//1,普通成员可以使用泛型 (属性、方法)
R r;//属性使用到泛型
M m;
T t;
// T[] ts = new T[4];//报错,不能初试化
//2,使用泛型的数组,不能初试化
//因为数组在new时,便要去开辟数组的空间,但是 还现在还不能确定T的类型,就无法在内存开空间
T[] ts;
public Tiger(String name) {
this.name = name;
}
public Tiger(String name, R r, M m, T t, T[] ts) {
this.name = name;
this.r = r;
this.m = m;
this.t = t;
this.ts = ts;
}
//3,静态属性和方法中不能使用类的泛型
//因为:静态是和类相关的,在类加载时,对象还没有创建. 但是泛型是和对象相关,但是泛型类型是在对象创建时指定
//static R r2; 报错
// public static void m1(M m){ 报错}
//方法使用到泛型
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;
}
public T[] getTs() {
return ts;
}
public void setTs(T[] ts) {
this.ts = ts;
}
@Override
public String toString() {
return "Tiger{" +
"name='" + name + '\'' +
", r=" + r +
", m=" + m +
", t=" + t +
", ts=" + Arrays.toString(ts) +
'}';
}
}
结果
自定义泛型接口
- 基本语法
interface 接口名<T,R…>{//…表示可以有多个泛型
成员} - 注意细节
1,接口中,静态成员也不能使用泛型(原因同类:一般是先有类才选择是否创建对象。而静态是与类相关的,泛型是当创建对象时才会指定。)
2,泛型接口的类型,在继承接口或实现接口时确定
3,没有指定对象,默认为Object
public class CustomInterface {
public static void main(String[] args) {
}
}
//2,泛型接口的类型,在继承接口时确定
interface IA extends IUsb<String,Double>{
}
//2,BB在实现IUsb接口时,指定了泛型的接口类型
class BB implements IUsb<Integer, Float>{
@Override
public Float get(Integer integer) {
return null;
}
@Override
public void hi(Float aFloat) {
}
}
//3,CC类,在实现IUsb接口时,因为没有指定泛型类型,,默认为<Object,Object>
class CC implements IUsb{//等价 class CC implements IUsb<Object,Object> {
@Override
public Object get(Object o) {
return null;
}
@Override
public void hi(Object o) {
}
}
//AA在实现IA接口时,自动确定了U为String R为Double;因为IA在继承IUsb时确定了接口类型,而AA有实现了IA
class AA implements IA{
@Override
public Double get(String s) {
return null;
}
@Override
public void hi(Double aDouble) {
}
}
interface IUsb<U,R>{
int n = 10;
//U name;报错//1,接口中的属性只能是public static final 修饰的,而静态属性和方法中不能使用接口的泛型
//普通方法,可以使用接口泛型
R get(U u); //R表示返回值类型,U表示传入参数类型
void hi(R r);//R表示传入参数类型
//在 jdk8 中,可以在接口中,使用默认方法, 也是可以使用泛型
default R method(U u) {
return null;
}
}
自定义泛型方法
- 基本语法:
修饰符<T,R…>返回类型 方法名(参数列表){} - 注意事项
1,泛型方法,可以定义在普通类中,也可以定义在泛型类中
2,当泛型方法被调用时,类型会确定
3,public void eat(E e){} 修饰符后没有<T,R…>eat 方法,不是泛型方法,而是使用了泛型
public class CustomMethodGeneric {
public static void main(String[] args) {
//T-String, R-Integer
Car car = new Car();
//2,当泛型方法被调用时,类型会确定
car.fly("宝贝", 100);
//K->String, R-> ArrayList
Fish<String, ArrayList> fish = new Fish<>();
fish.hello("zl",new ArrayList());
}
}
class Car {//普通类
//普通方法
public void run() {
}
//泛型方法
// <T,R> 就是泛型,是提供给fly使用的
public <T, R> void fly(T t, R r) {
System.out.println("T的类型=" + t.getClass());//String
System.out.println("R的类型=" + r.getClass());//Integer
}
}
class Fish<T, R> {//泛型类
//1,泛型方法,可以定义在普通类中,也可以定义在泛型类中
//普通方法
public void run() {
}
//泛型方法
public <U, M> void eat(U u, M m) {
}
//3,hi方法不是泛型方法,只是使用了类声明的泛型
public void hi(T t) {
}
//泛型方法可以使用类声明的泛型,也可以使用自己声明的泛型
public <K> void hello(K k,R r) {
System.out.println("K的数据类型"+k.getClass());
System.out.println("R的数据类型"+r.getClass());
}
}
结果
泛型的继承和通配符
- 1,泛型不具备继承性
List list = new ArrayList(); 报错 - 2,<?>:支持任意泛型类型
- 3,<? extends A>:支持A类以及A类的子类,规定了泛型的上限
- 4,<? Super A>:支持A类以及A类的父类, 不限于直接父类,规定了泛型的下限
public class GenericExtends {
public static void main(String[] args) {
//1,泛型不具备继承性
//String类是Object的子类
Object o = new String("xx");//可以
//但是不能继承
// List<Object> list = new ArrayList<String>(); 报错
List<Object> list1 = new ArrayList<>();
List<String> list2 = new ArrayList<>();
List<AAA> list3 = new ArrayList<>();
List<BBB> list4 = new ArrayList<>();
List<CCC> list5 = new ArrayList<>();
//2,List<?> c 可以接收任意的泛型类型
printCollection1(list1);
printCollection1(list2);
printCollection1(list3);
printCollection1(list4);
printCollection1(list5);
//3,<? extends A>:支持A类以及A类的子类,规定了泛型的上线
//printCollection2(list1);//报错,会只限AAA 或者 AAA 子类
printCollection2(list3);
printCollection2(list4);
printCollection2(list5);
//4,<? Super A>:支持A类以及A类的父类, 不限于直接父类,规定了泛型的下限
printCollection3(list1);//Object 为所有类的父类
//printCollection3(list2);// String类 报错
printCollection3(list3);//AAA类
}
//说明: List<?> 表示 任意的泛型类型都可以接受
public static void printCollection1(List<?> c) {
for (Object object : c) { // 通配符,取出时,就是 Object
System.out.println(object);
}
}
// ? extends AA 表示 上限,可以接受 AA 或者 AA 子类
public static void printCollection2(List<? extends AAA> c) {
for (Object object : c) {
System.out.println(object);
}
}
// ? super 子类类名 AA:支持 AA 类以及 AA 类的父类,不限于直接父类,
//规定了泛型的下限
public static void printCollection3(List<? super AAA> c) {
for (Object object : c) {
System.out.println(object);
}
}
}
class AAA {
}
class BBB extends AAA {
}
class CCC extends BBB {
}
JUnit
为什么需要JUnit
- 一个类有很多功能代码需要测试,为了测试,就需要写入到main中
- 如果有多个功能代码测试,就需要来回注销,切换很麻烦
- 如果可以直接运行一个方法,就方便很多,并且可以给出相关信息
基本介绍
- 1,JUnit是一个Java语言的单元测试框架
- 2,多数Java的开发环境都已经集成JUnit作为单元测试的工具
怎么使用
- 1,不用在主方法中测试
- 2,在想要测试的方法前加@Test 键入Ait+Enter,
public class JUnit_ {
public static void main(String[] args) {
}
@Test
public void m1 (){
System.out.println("m1被调用");
}
}
结果