13泛型
目录
泛型的好处
1.编译时，检查添加元素的类型，提高了安全性
2.减少了类型转换的次数，提高效率
不使用泛型：
DOg-加入→Object→Dog//放入到ArrayList会先转成Object，再取出时，还需要转成Dog
使用泛型：
Dog→Dog→Dog//放入时，和取出时，不需要类型转换，提高效率
3.不再提示编译警告
点击查看代码
public class Generic02 {
public static void main(String[] args) {
//使用泛型
//1.当我们 ArrayList<Dog> 表示存放到ArrayList集合中的元素是Dog
//2.如果编译器发现添加的类型，不满足要求，就会报错
//3.在遍历的时候，可以直接取出Dog类型而不是Object
//4.public class ArrayList<E>{}E称为泛型，那么Dog→E
ArrayList<Dog1> arrayList = new ArrayList<Dog1>();
arrayList.add(new Dog1("旺财",9));
arrayList.add(new Dog1("发财",6));
arrayList.add(new Dog1("大黄",9));
//加入我们不小心，添加了一只猫
//arrayList.add(new Cat1("招财猫",80));
for (Dog1 dog1 : arrayList) {
System.out.println(dog1.getName()+"-"+dog1.getAge());
}
}
}
/***
* 编写程序，在ArrayList中，添加3个Dog对象。
* Dog对象含有name和age，并输出name和age(要求使用getXxx()
*/
class Dog1 {
private String name;
private int age;
public Dog1(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 Cat1 {
private String name;
private int age;
public Cat1(String name, int age) {
this.name = name;
this.age = age;
}
}
泛型介绍
泛型=> Integer,String,Dog
1.泛型又称参数化类型，是Jdk5.0出现的新特性，解决数据类型的安全性问题
2.在类声明或实例化时只要指定号需要的具体的类型即可
3.Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮
4.泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型。
泛型语法
泛型的声明：
interface接口<T>{}和class类<K,V>{}
说明：
1.其中，T,K,V不代表值，而是表示类型
2.任意字母都可以。常用T表示,是Type的缩写
泛型的实例化
要在类名后面指定类型参数的值(类型)。如：
1.List<String> strList = new ArrayList<String>();
2.Iterator<Customen> iterator = customers.iterator();
点击查看代码
public static void main(String[] args) {
Person<String> person = new Person<>("java初学者");
person.show();
/***
* 可以这样理解，上面的Person类
* class Person<E>{
* E s;//E表示 s的数据类型，该数据类型是在定义Person对象的时候指定，即在编译期间，就确定E是什么
*
* public Person(E s) {//E也可以是参数类型
* this.s = s;
* }
*
* public E f(){//返回类型使用E
* return s;
* }
* }
*/
Person<Integer> integerPerson = new Person<>(100);
integerPerson.show();
/***
* class Person<Integer>{
* E s;//E表示 s的数据类型，该数据类型是在定义Person对象的时候指定的，即在编译期间，就确定E是什么
*
* public Person(Integer s) {//E也可以是参数类型
* this.s = s;
* }
*
* public Integer f(){//返回类型使用E
* return s;
* }
* }
*/
}
}
//泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，
// 或者是某个方法的返回值的类型，或者是参数类型。
class Person<E>{
E s;//E表示 s的数据类型，该数据类型是在定义Person对象的时候指定的，即在编译期间，就确定E是什么
public Person(E s) {//E也可以是参数类型
this.s = s;
}
public E f(){//返回类型使用E
return s;
}
public void show(){
System.out.println(s.getClass());
}
}
泛型的使用
点击查看代码
public class GenericExercise {
public static void main(String[] args) {
//1.创建三个学生对象
Student student1 = new Student("张三", 18);
Student student2 = new Student("李四", 19);
Student student3 = new Student("王二", 17);
//2.放入到HashSet中学生对象使用
HashSet<Student> hashSet = new HashSet<Student>();
hashSet.add(student1);
hashSet.add(student2);
hashSet.add(student3);
//使用两种方式遍历
for (Student student : hashSet) {
System.out.println(student);
}
// Iterator<Student> iterator = hashSet.iterator();
// while (iterator.hasNext()) {
// Student next = iterator.next();
// System.out.println(next);
// }
//3.放入到HashMap中，要求Key是String name，Value就是学生对象
HashMap<String, Student> hashMap = new HashMap<>();
hashMap.put("张三", student1);
hashMap.put("李四", student2);
hashMap.put("王二", student3);
//遍历
Set<Entry<String, Student>> entries = hashMap.entrySet();
/***
* public Set<Map.Entry<K,V>> entrySet() {
* Set<Map.Entry<K,V>> es;
* return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
* }
*/
Iterator<Entry<String, Student>> iterator = entries.iterator();
while (iterator.hasNext()) {
Entry<String, Student> next = iterator.next();
System.out.println(next.getKey() + "-" + next.getValue());
}
}
}
/***
* 1.创建三个学生对象
* 2.放入到HashSet中学生对象使用
* 3.放入到HashMap中，要求Key是String name，Value就是学生对象
* 4.使用两种方式遍历
*/
class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
泛型的使用细节
1.interface List<T>{},public class HashSet<E>{}...等等
看看下面语句是否正确？：
List<Integer> list = new ArrayList<Integer>();//OK
List<int> list2 = new ArrayList<int>();//错误
2.在指定泛型具体类型后，可以传入该类型或其子类类型
3.泛型使用形式：
List<Integer> list1 = new ArrayList<Integer>();
List<Integer> list2 = new ArrayList<>();
4.如果这样写 List list3 = new ArrayList();默认给他的泛型是[<E>就是Object]
点击查看代码
public class GenericDetail {
public static void main(String[] args) {
// 1.给泛型指向数据类型是，要求是引用类型，不能是基本数据类型
List<Integer> list = new ArrayList<Integer>();
// List<int> list2 = new ArrayList<int>();
//2.说明
//因为E指定了A类型，构造器传入了new A()
//在给泛型指定具体类型可以传入该类型或者其子类类型
Pig<A> aPig = new Pig<A>(new A());
aPig.f();
Pig<A> aPig2 = new Pig<A>(new B());
aPig2.f();
//3.泛型的使用形式
//在实际开发中，我们往往简写
//编译器会进行类型推断
ArrayList<Integer> integers = new ArrayList<Integer>();
List<Integer> integers1 = new ArrayList<>();
//4.如果这样写 泛型默认是Object
ArrayList list3 = new ArrayList();//等价 ArrayList<Object> list3 = new ArrayList<Object>();
list3.add("XX");
/***
* public boolean add(E e) {
* ensureCapacityInternal(size + 1); // Increments modCount!!
* elementData[size++] = e;
* return true;
* }
*/
}
}
class A{}
class B extends A{}
class Pig<E>{
E e;
public Pig(E e) {
this.e = e;
}
public void f(){
System.out.println(e.getClass());
}
}
泛型练习题：
1定义Employee类
1.该类包含：private成员变量name,sal,brithday，其中birthday为MyDate类的对象
2.为每一个属性定义getter，setter方法
3.重写toString方法输出name，sal，birthday
4.MyDate类包含：private成员变量month，day，year：并为每一个属性定以getter，setter方法
5.创建该类的3个对象，并把这些对象放入ArrayList集合中(ArrayList需使用泛型来定义)，对集合中的元素进行排序，并遍历输出：
排序方式：调用ArrayList的sort方法，传入Comparator对象[使用泛型]，先按照name排序，如果name相同，则按生日日期的先后排序。
点击查看代码
public class GenericExercise02 {
public static void main(String[] args) {
ArrayList<Employee> employees = new ArrayList<>();
employees.add(new Employee("tom", 20000, new MyDate(2000, 11, 11)));
employees.add(new Employee("jack", 20000, new MyDate(2001, 10, 20)));
employees.add(new Employee("zs", 20000, new MyDate(1998, 10, 12)));
employees.add(new Employee("zs", 20000, new MyDate(1998, 10, 11)));
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的比较，因此我们最好把这个比较放在MyDa类完成
//封装后，将来可维护性大大增强
return emp1.getBirthday().compareTo(emp2.getBirthday());
}
});
System.out.println(employees);
}
}
/**
* 1定义Employee类 1.该类包含：private成员变量name,sal,brithday，其中birthday为MyDate类的对象 2.为每一个属性定义getter，setter方法
* 3.重写toString方法输出name，sal，birthday 4.MyDate类包含：private成员变量month，day，year：并为每一个属性定以getter，setter方法
* 5.创建该类的3个对象，并把这些对象放入ArrayList集合中(ArrayList需使用泛型来定义)，对集合中的元素进行排序，并遍历输出： 排序方式：调用ArrayList的sort方法，传入Comparator对象[使用泛型]，先按照name排序，如果name相同，则按生日日期的先后排序。
*/
class Employee {
private String name;//姓名
private double sal;//薪资
private MyDate birthday;//生日
public Employee(String name, double 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 double getSal() {
return sal;
}
public void setSal(double 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 +
"}\n";
}
}
class MyDate implements Comparable<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 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;
}
//如果year和month相同 比较day
return day - o.getDay();
}
@Override
public String toString() {
return "MyDate{" +
"year=" + year +
", month=" + month +
", day=" + day +
'}';
}
}
自定义泛型
基本语法：
class 类名<T,R...>{//表示可以有多个泛型
成员
}
注意细节：
1.普通成员可以使用泛型(属性，方法)
2.使用泛型和数组，不能初始化
3.静态方法中不能使用类的泛型
4.泛型类的类型，是在创建对象时确定的(因为创建对象时，需要指定确定类型)
5.如果在创建对象时，没有指定类型，默认为Object
点击查看代码
public class CustomGeneric_ {
public static void main(String[] args) {
//T=double，R=String，M=Integer
Tiger<Double, String, Integer> g = new Tiger<>("john");
g.setT(10.9);//OK
//g.setT("YY");//错误，类型不正确
System.out.println(g);
Tiger g2 = new Tiger("john");//OK T=Object，R=Object，M=Object
g2.setT("YY");//OK,因为T=Object "YY"=String 是Object子类
System.out.println("g2 = "+g2);
}
}
//解读：
//1.Tiger 后面泛型，索引我们吧Tiger成为自定义泛型类
//2.T,R,M 泛型的标识符，一般是单个大写字母
//3.泛型标识符可以有多个
//4.普通成员可以使用泛型(属性、方法)
//5.使用泛型的数组，不能被初始化
//6.静态方法中不能使用类的泛型
class Tiger<T,R,M>{
String name;
R r;//属性使用到泛型
T t;
M m;
//因为数组在new 不能确定T的类型，就无法在内存开空间
//T[] ts = new T[8];
T[] ts;
public Tiger(String name) {
this.name = name;
}
public Tiger(String name, R r, T t, M m) {//构造器使用泛型
this.name = name;
this.r = r;
this.t = t;
this.m = m;
}
//因为静态是和类相关的，在类加载时，对象还没有创建
//所以如果静态方法和静态属性使用了泛型，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 T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
public M getM() {
return m;
}
public void setM(M m) {
this.m = m;
}
}
自定义泛型接口
基本语法：
interface 接口名<T,R...>{}
注意细节：
1.接口中，静态成员也不能使用泛型(这个和泛型类规定一样)
2.泛型接口的类型，在继承接口或者实现接口时确定
3.没有指定类型，默认为Object
点击查看代码
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) {
}
}
//实现接口时，直接指定泛型接口的类型
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) {
}
}
//3.没有指定类型，默认为Object
class CC implements IUsb{//等价 class CC implement 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) {
}
}
interface IUsb<U,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...>返回类型 方法名(参数列表){}
注意细节：
1.泛型方法，可以定义在普通类中，也可以定义在泛型类中
2.当泛型方法被调用时，类型会确定
3.public void eat(E e){}修饰符后没有<T,R...>eat 方法不是泛型方法，而是使用了泛型
点击查看代码
//泛型方法的使用
public class CustomMethodGeneric {
public static void main(String[] args) {
Car car = new Car();
car.fly("宝马",200);//当调用方法时，传入参数，编译器，就会确定类型
Fish<String, ArrayList> fish = new Fish<>();
fish.hello(new ArrayList(),11.3f);
}
}
//1.泛型方法，可以定义在普通类中，也可以定义在泛型类中
class Car{
public void run(){//普通方法
}
//1.<T,R>就是泛型
//2.是提供给 fly使用的
public<T,R> void fly(T t, R r){//泛型方法
System.out.println(t.getClass());
System.out.println(r.getClass());
}
}
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
}
}
自定义泛型练习
class Apple<T,R,M>{
public<E> void fly(E e){//泛型方法
System.out.println(e.getClass().getSimpleName());
}
public void eat(U u){}//错误，因为U没有声明
public void run(M m){}//OK
class Dog{}
//下面代码输出什么？
Apple<String,Integer,Double> apple = new Apple<>();
apple.fly(10);//10 会被自动装箱 Integer 10，输出 Integer
apple.fly(new Dog());//Dog
泛型的继承和通配符
1.泛型不具备继承性
List<Object> list = new ArrayList<String>();//不对
2.<?>：支持任意泛型类型
3.<? extends A>：支持A类以及A类的子类，规定了泛型的上限
4.<? super A>：支持A类以及A类的父类，不限于直接父类，规定了泛型的下限
点击查看代码
public class GenericExtends {
public static void main(String[] args) {
Object o = new String("xx");
//泛型没有继承性
//List<Object> strings = 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<>();
//如果是List<?> c，可以接受任意的泛型类型
printCollection1(list1);
printCollection1(list2);
printCollection1(list3);
printCollection1(list4);
printCollection1(list5);
//List<? extends AA> c:表示 上限，可以接受 AA 或者 AA 子类
// printCollection2(list1);//F
// printCollection2(list2);//F
printCollection2(list3);//T
printCollection2(list4);//T
printCollection2(list5);//T
//List<? super AAA> c:支持AA类以及AA类的父类，不限于直接父类，规定了泛型的下限
printCollection3(list1);//T
// printCollection3(list2);//F
printCollection3(list3);//T
// printCollection3(list4);//F
// printCollection3(list5);//F
}
//说明：List<?> 表示 任意的泛型类型都可以接受
public static void printCollection1(List<?> c){
for (Object o : c) {//通配符，取出时，就是Object
System.out.println(o);
}
}
//？ extends AA 表示 上限，可以接受 AA 或者 AA 子类
public static void printCollection2(List<? extends AAA> c){
for (Object o :c) {
System.out.println(o);
}
}
//? super 子类类名AA：支持AA类以及AA类的父类，不限于直接父类，规定了泛型的下限
public static void printCollection3(List<? super AAA> c){
for (Object o :c) {
System.out.println(o);
}
}
}
class AAA{}
class BBB extends AAA{}
class CCC extends BBB{}
作业
定义个泛型类DAO<T>,在其中定义一个Map成员变量，Map的键为String类型，值为T类型。
分别创建以下方法：
1.public void save(String id,T entity)：保存T类型的对象到Map成员变量中
2.Public T get(String id)：从map中获取id对应的对象
3.public void update(String id，T entity)：替换map中key为id的内容，改为entity对象
4.public List<T> list（）：返回map中存在的所有T对象
5.public void delete(String id)：删除指定id对象
定义一个User类：
该类包含:private成员变量(int类型)id,age;(String类型)name;
创建DAO类的对象，分别调用其save、get、update、list、delete方法来操作User对象，使用Junit单元测试类进行测试
点击查看代码
public class Homework01 {
public static void main(String[] args) {
}
@Test
public void testList(){
DAO<User> dao = new DAO<>();
dao.save("001",new User(1,10,"jack"));
dao.save("002",new User(2,20,"king"));
dao.save("003",new User(3,30,"tom"));
List<User> list = dao.list();
System.out.println(list);
dao.update("003",new User(3,40,"smith"));//修改
dao.delete("001");//删除
list = dao.list();
System.out.println(list);
System.out.println("id = 002\t"+dao.get("002"));
}
}
点击查看代码
public class User {
private int id;
private int 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 + '\'' +
'}';
}
}
点击查看代码
public class DAO<T> {
private Map<String,T> map = new HashMap<>();
public T get(String id){
return map.get(id);
}
public void update(String id,T entity){
map.put(id,entity);
}
//遍历map，将map的所有value(entity)，封装到ArrayList返回即可
public List<T> list(){
//创建 ArrayList
List<T> list = new ArrayList<>();
//遍历map
Set<String> keySet = map.keySet();
for (String key : keySet) {
//mao.get(key)返回的就是 User对象→ArrayList
list.add(map.get(key));//也可以直接使用本类的 get(String id)
}
return list;
}
public void delete(String id){
map.remove(id);
}
public void save(String id,T entity){//包entity保存到map
map.put(id, entity);
}
}
浙公网安备 33010602011771号