wordpress网站500错误,郴州新网0735,阿里云服务器可以做多少个网站,网站建设打造学院泛型的理解和好处
泛型是在JDK5之后引入的一个新特性#xff0c;可以在编译阶段约束操作的数据类型#xff0c;并进行检查。
泛型的格式为 数据类型
import java.util.ArrayList;SuppressWarnings({all})
public class Generic02 {public static void…泛型的理解和好处
泛型是在JDK5之后引入的一个新特性可以在编译阶段约束操作的数据类型并进行检查。
泛型的格式为 数据类型
import java.util.ArrayList;SuppressWarnings({all})
public class Generic02 {public static void main(String[] args) {//使用传统的方法来解决 使用泛型//1. 当我们 ArrayListDog 表示存放到 ArrayList 集合中的元素是Dog类型 (细节后面说...)//2. 如果编译器发现添加的类型不满足要求就会报错//3. 在遍历的时候可以直接取出 Dog 类型而不是 Object//4. public class ArrayListE {} E称为泛型,那么 Dog-EArrayListDog arrayList new ArrayListDog();arrayList.add(new Dog(旺财, 10));arrayList.add(new Dog(发财, 1));arrayList.add(new Dog(小黄, 5));//假如我们的程序员不小心添加了一只猫//arrayList.add(new Cat(招财猫, 8));System.out.println(使用泛型);for (Dog dog : arrayList) {System.out.println(dog.getName() - dog.getAge());}}
}
/*
1.请编写程序在ArrayList 中添加3个Dog对象
2.Dog对象含有name 和 age, 并输出name 和 age (要求使用getXxx())
3.使用泛型来完成代码*/
class Dog {private String name;private int age;public Dog(String name, int age) {this.name name;this.age age;}public String getName() {return name;}public void setName(String name) {this.name name;}public int getAge() {return age;}public void setAge(int age) {this.age age;}
}class Cat { //Cat类private String name;private int age;public Cat(String name, int age) {this.name name;this.age age;}public String getName() {return name;}public void setName(String name) {this.name name;}public int getAge() {return age;}public void setAge(int age) {this.age age;}
}泛型的理解和好处
1)编译时检查添加元素的类型提高了安全性2)减少了类型转换的次数提高效率[说明] √ 不使用泛型Dog -加入-Object -取出-Dog //放入到ArrayList 会先转成 Object,在取出时还需要转换成Dog √ 使用泛型Dog - Dog - Dog // 放入时和取出时不需要类型转换提高效率3)不再提示编译警告
1统一数据类型对于后续业务层中取出数据有很强的统一规范性方便对数据的管理
2把运行时期的问题提前到了编译期避免了强转类型转换可能出现的异常降低了程序出错的概率
泛型介绍
int a 10;理解:泛(广泛)型(类型)Integer, String,Dog
1)泛型又称参数化类型是Jdk5.0 出现的新特性,解决数据类型的安全性问题2)在类声明或实例化时只要指定好需要的具体的类型即可3)Java泛型可以保证如果程序在编译时没有发出警告运行时就不会产生ClassCastException异常。同时代码更加简洁、健壮4)泛型的作用是:可以在类声明时通过一个标识表示类中某个属性的类型或者是某个方法的返回值的类型或者是参数类型。[有点难举例 Generic03.java]
import java.util.List;public class Generic03 {public static void main(String[] args) {//注意特别强调 E具体的数据类型在定义Person对象的时候指定,即在编译期间就确定E是什么类型PersonString person new PersonString(韩顺平教育);person.show(); //String/*你可以这样理解上面的Person类class Person {String s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间就确定E是什么类型public Person(String s) {//E也可以是参数类型this.s s;}public String f() {//返回类型使用Ereturn s;}}*/PersonInteger person2 new PersonInteger(100);person2.show();//Integer/*class Person {Integer s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间就确定E是什么类型public Person(Integer s) {//E也可以是参数类型this.s s;}public Integer f() {//返回类型使用Ereturn s;}}*/}
}
//泛型的作用是可以在类声明时通过一个标识表示类中某个属性的类型
// 或者是某个方法的返回值的类型或者是参数类型
class PersonE {E s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间就确定E是什么类型public Person(E s) {//E也可以是参数类型this.s s;}public E f() {//返回类型使用Ereturn s;}public void show() {System.out.println(s.getClass());//显示s的运行类型}
}泛型的语法
泛型的声明
interface 接囗T{} 和 class 类K,V{} //比如:List ArrayList 说明: 1)其中T,K,V不代表值而是表示类型。 2)任意字母都可以。常用T表示是Type的缩写
泛型的实例化
要在类名后面指定类型参数的值(类型)。如: 1)ListString strList new ArrayListString();[举例说明] 2)lteratorCustomeriterator customers.iterator();
泛型使用举例
举例说明泛型在 HashSet,HashMap 的使用情况, 演示 GenericExercise.java10min练习: 1.创建 3个学生对象 2.放入到Hashset中学生对象使用. 3.放入到 HashMap中要求Key 是 String name, Value就是 学生对象 4.使用两种方式遍历
import java.util.*;SuppressWarnings({all})
public class GenericExercise {public static void main(String[] args) {//使用泛型方式给HashSet 放入3个学生对象HashSetStudent students new HashSetStudent();students.add(new Student(jack, 18));students.add(new Student(tom, 28));students.add(new Student(mary, 19));//遍历for (Student student : students) {System.out.println(student);}//使用泛型方式给HashMap 放入3个学生对象//K - String V-StudentHashMapString, Student hm new HashMapString, Student();/*public class HashMapK,V {}*/hm.put(milan, new Student(milan, 38));hm.put(smith, new Student(smith, 48));hm.put(hsp, new Student(hsp, 28));//迭代器 EntrySet/*public SetMap.EntryK,V entrySet() {SetMap.EntryK,V es;return (es entrySet) null ? (entrySet new EntrySet()) : es;}*/SetMap.EntryString, Student entries hm.entrySet();/*public final IteratorMap.EntryK,V iterator() {return new EntryIterator();}*/IteratorMap.EntryString, Student iterator entries.iterator();System.out.println();while (iterator.hasNext()) {Map.EntryString, Student next iterator.next();System.out.println(next.getKey() - next.getValue());}}
}
/*** 创建 3个学生对象* 放入到HashSet中学生对象, 使用.* 放入到 HashMap中要求 Key 是 String name, Value 就是 学生对象* 使用两种方式遍历*/
class Student {private String name;private int age;public Student(String name, int age) {this.name name;this.age age;}public String getName() {return name;}public void setName(String name) {this.name name;}public int getAge() {return age;}public void setAge(int age) {this.age age;}Overridepublic String toString() {return Student{ name name \ , age age };}
}泛型使用的注意事项和细节
1泛型的数据类型只能填写引用数据类型基本数据类型不可以。
2指定泛型的具体类型之后可以传入该类类型或其子类类型
3如果不手动添加泛型则默认泛型为 Object 。 import java.util.ArrayList;
import java.util.List;SuppressWarnings({all})
public class GenericDetail {public static void main(String[] args) {//1.给泛型指向数据类型是要求是引用类型不能是基本数据类型ListInteger list new ArrayListInteger(); //OK//Listint list2 new ArrayListint();//错误//2. 说明//因为 E 指定了 A 类型, 构造器传入了 new A()//在给泛型指定具体类型后可以传入该类型或者其子类类型PigA aPig new PigA(new A());aPig.f();PigA aPig2 new PigA(new B());aPig2.f();//3. 泛型的使用形式ArrayListInteger list1 new ArrayListInteger();ListInteger list2 new ArrayListInteger();//在实际开发中我们往往简写//编译器会进行类型推断, 老师推荐使用下面写法ArrayListInteger list3 new ArrayList();ListInteger list4 new ArrayList();ArrayListPig pigs new ArrayList();//4. 如果是这样写 泛型默认是 ObjectArrayList arrayList new ArrayList();//等价 ArrayListObject arrayList new ArrayListObject();/*public boolean add(Object e) {ensureCapacityInternal(size 1); // Increments modCount!!elementData[size] e;return true;}*/Tiger tiger new Tiger();/*class Tiger {//类Object e;public Tiger() {}public Tiger(Object e) {this.e e;}}*/}
}
class TigerE {//类E e;public Tiger() {}public Tiger(E e) {this.e e;}
}
class A {}
class B extends A {}
class PigE {//E e;public Pig(E e) {this.e e;}public void f() {System.out.println(e.getClass()); //运行类型}
}
自定义泛型类
基本语法
class 类名T, R...{//..表示可以有多个泛型成员
}
注意细节
1)普通成员可以使用泛型(属性、方法)2)使用泛型的数组不能初始化3)静态方法中不能使用类的泛型4)泛型类的类型是在创建对象时确定的(因为创建对象时需要指定确定类型)5)如果在创建对象时没有指定类型默认为Object
应用案例
import java.util.Arrays;SuppressWarnings({all})
public class CustomGeneric_ {public static void main(String[] args) {//TDouble, RString, MIntegerTigerDouble,String,Integer g new Tiger(john);g.setT(10.9); //OK//g.setT(yy); //错误类型不对System.out.println(g);Tiger g2 new Tiger(john~~);//OK TObject RObject MObjectg2.setT(yy); //OK ,因为 TObject yyString 是Object子类System.out.println(g2 g2);}
}
//解读
//1. Tiger 后面泛型所以我们把 Tiger 就称为自定义泛型类
//2, T, R, M 泛型的标识符, 一般是单个大写字母
//3. 泛型标识符可以有多个.
//4. 普通成员可以使用泛型 (属性、方法)
//5. 使用泛型的数组不能初始化
//6. 静态方法中不能使用类的泛型
class TigerT, R, M {String name;R r; //属性使用到泛型M m;T t;//因为数组在new 不能确定T的类型就无法在内存开空间T[] ts;public Tiger(String name) {this.name name;}public Tiger(R r, M m, T t) {//构造器使用泛型this.r r;this.m m;this.t t;}public Tiger(String name, R r, M m, T t) {//构造器使用泛型this.name name;this.r r;this.m m;this.t t;}//因为静态是和类相关的在类加载时对象还没有创建//所以如果静态方法和静态属性使用了泛型JVM就无法完成初始化
// 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;}Overridepublic 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 CustomInterfaceGeneric {public static void main(String[] args) {}
}
/*** 泛型接口使用的说明* 1. 接口中静态成员也不能使用泛型* 2. 泛型接口的类型, 在继承接口或者实现接口时确定* 3. 没有指定类型默认为Object*/
//在继承接口 指定泛型接口的类型
interface IA extends IUsbString, Double {
}
//当我们去实现IA接口时因为IA在继承IUsu 接口时指定了U 为String R为Double
//在实现IUsu接口的方法时使用String替换U, 是Double替换R
class AA implements IA {Overridepublic Double get(String s) {return null;}Overridepublic void hi(Double aDouble) {}Overridepublic void run(Double r1, Double r2, String u1, String u2) {}
}
//实现接口时直接指定泛型接口的类型
//给U 指定Integer 给 R 指定了 Float
//所以当我们实现IUsb方法时会使用Integer替换U, 使用Float替换R
class BB implements IUsbInteger, Float {Overridepublic Float get(Integer integer) {return null;}Overridepublic void hi(Float aFloat) {}Overridepublic void run(Float r1, Float r2, Integer u1, Integer u2) {}
}
//没有指定类型默认为Object
//建议直接写成 IUsbObject,Object
class CC implements IUsb { //等价 class CC implements IUsbObject,Object {Overridepublic Object get(Object o) {return null;}Overridepublic void hi(Object o) {}Overridepublic void run(Object r1, Object r2, Object u1, Object u2) {}
}
interface IUsbU, R {int n 10;//U name; 不能这样使用//普通方法中可以使用接口泛型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;}
}
自定义泛型方法
基本语法
修饰符 T,R..返回类型 方法名(参数列表){
}
注意细节
泛型方法可以定义在普通类中,也可以定义在泛型类中当泛型方法被调用时类型会确定public void eat(E e)}修饰符后没有T,R..eat方法不是泛型方法而是使用了泛型
import java.util.ArrayList;SuppressWarnings({all})
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- ArrayListFishString, 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());//StringSystem.out.println(r.getClass());//Integer}
}
class FishT, R {//泛型类public void run() {//普通方法}publicU,M void eat(U u, M m) {//泛型方法}//说明//1. 下面hi方法不是泛型方法//2. 是hi方法使用了类声明的 泛型public void hi(T t) {}//泛型方法可以使用类声明的泛型也可以使用自己声明泛型publicK void hello(R r, K k) {System.out.println(r.getClass());//ArrayListSystem.out.println(k.getClass());//Float}
}
泛型的继承和通配符
泛型的继承和通配符说明 import java.util.ArrayList;
import java.util.List;public class GenericExtends {public static void main(String[] args) {Object o new String(xx);//泛型没有继承性//ListObject list new ArrayListString();//举例说明下面三个方法的使用ListObject list1 new ArrayList();ListString list2 new ArrayList();ListAA list3 new ArrayList();ListBB list4 new ArrayList();ListCC 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) { // 通配符取出时就是ObjectSystem.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
为什么需要JUnit
一个类有很多功能代码需要测试为了测试就需要写入到main方法中如果有多个功能代码测试就需要来回注销切换很麻烦如果可以直接运行一个方法就方便很多并且可以给出相关信息就好了-JUnit
基本介绍
JUnit是一个Java语言的单元测试框架多数Java的开发环境都已经集成了JUnit作为单元测试的工具
import org.junit.jupiter.api.Test;public class JUnit_ {public static void main(String[] args) {//传统方式//new JUnit_().m1();//new JUnit_().m2();}Testpublic void m1() {System.out.println(m1方法被调用);}Testpublic void m2() {System.out.println(m2方法被调用);}Testpublic void m3() {System.out.println(m3方法被调用);}
}上一篇
Java 集合CollectionList、SetMap-CSDN博客
