day28--Java泛型01

Java泛型01

1.泛型的理解和好处

看一个需求：

• 请编写程序，在ArrayList中添加三个Dog对象
  
• Dog对象含有name和age，并输出name和age（要求使用getXXX（））
  

先用传统的方法来解决--->引出泛型

传统的方法：

1. package li.generic;
3. import java.util.ArrayList;
5. @SuppressWarnings("all")
6. public class Introduce_ {
7.     public static void main(String[] args) {
8.         
9.         //用传统的方法来解决
10.         ArrayList arrayList = new ArrayList();
11.         arrayList.add(new Dog("旺财",10));
12.         arrayList.add(new Dog("发财",1));
13.         arrayList.add(new Dog("小黄",5));
14.         
15.         for (Object o:arrayList) {
16.             //向下转型
17.             Dog dog = (Dog) o;
18.             System.out.println(dog.getName()+"-"+dog.getAge());
19.         }
21.     }
22. }
24. class Dog {
25.     private String name;
26.     private int age;
28.     public Dog(String name, int age) {
29.         this.name = name;
30.         this.age = age;
31.     }
33.     public String getName() {
34.         return name;
35.     }
37.     public void setName(String name) {
38.         this.name = name;
39.     }
41.     public int getAge() {
42.         return age;
43.     }
45.     public void setAge(int age) {
46.         this.age = age;
47.     }
48. }

复制代码

1. //假设，我们的程序员不小心添加了一只猫
2. arrayList.add(new Cat("招财猫",8));

复制代码

那么 在使用增强for循环输出的时候向下转型时就会抛出异常：类型转换错误

使用传统方法问题的分析：

• 不能对加入到集合ArrayList中的数据进行约束（不安全）
  
• 遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响
  

使用泛型来解决问题：

1. package li.generic;
3. import java.util.ArrayList;
5. @SuppressWarnings("all")
6. public class Introduce_ {
7.     public static void main(String[] args) {
9.         //使用泛型
10.         // 1. 当我们这样写的时候：ArrayList<Dog>  表示集合ArrayList中的元素是Dog类型
11.         // 2. 如果编译器发现添加的类型不满足要求，就会报错
12.         // 3.在遍历的时候，可以直接取出Dog类型而不是Object
13.         ArrayList<Dog> arrayList = new ArrayList<Dog>();
14.         arrayList.add(new Dog("旺财",10));
15.         arrayList.add(new Dog("发财",1));
16.         arrayList.add(new Dog("小黄",5));
18.         //假设，我们的程序员不小心添加了一只猫，就会报错
19.         // arrayList.add(new Cat("招财猫",8));
21.         System.out.println("====使用泛型====");
22.         for (Dog dog:arrayList) {
23.             System.out.println(dog.getName()+"-"+dog.getAge());
24.         }
26.     }
27. }
29. class Dog {
30.     private String name;
31.     private int age;
33.     public Dog(String name, int age) {
34.         this.name = name;
35.         this.age = age;
36.     }
38.     public String getName() {
39.         return name;
40.     }
42.     public void setName(String name) {
43.         this.name = name;
44.     }
46.     public int getAge() {
47.         return age;
48.     }
50.     public void setAge(int age) {
51.         this.age = age;
52.     }
53. }
55. class Cat {
56.     private String name;
57.     private int age;
59.     public Cat(String name, int age) {
60.         this.name = name;
61.         this.age = age;
62.     }
64.     public String getName() {
65.         return name;
66.     }
68.     public void setName(String name) {
69.         this.name = name;
70.     }
72.     public int getAge() {
73.         return age;
74.     }
76.     public void setAge(int age) {
77.         this.age = age;
78.     }
79. }

复制代码

1. package li.generic;
3. import java.util.ArrayList;
5. @SuppressWarnings("all")
6. public class Introduce_ {
7.     public static void main(String[] args) {
9.         //使用泛型
10.         // 1. 当我们这样写的时候：ArrayList<Dog>  表示集合ArrayList中的元素是Dog类型
11.         // 2. 如果编译器发现添加的类型不满足要求，就会报错
12.         // 3.在遍历的时候，可以直接取出Dog类型，而不是Object
13.         ArrayList<Dog> arrayList = new ArrayList<Dog>();
14.         arrayList.add(new Dog("旺财",10));
15.         arrayList.add(new Dog("发财",1));
16.         arrayList.add(new Dog("小黄",5));
18.         //假设，我们的程序员不小心添加了一只猫，就会报错
19.         // arrayList.add(new Cat("招财猫",8));
21.         System.out.println("====使用泛型====");
22.         for (Dog dog:arrayList) {
23.             System.out.println(dog.getName()+"-"+dog.getAge());
24.         }
26.     }
27. }
29. class Dog {
30.     private String name;
31.     private int age;
33.     public Dog(String name, int age) {
34.         this.name = name;
35.         this.age = age;
36.     }
38.     public String getName() {
39.         return name;
40.     }
42.     public void setName(String name) {
43.         this.name = name;
44.     }
46.     public int getAge() {
47.         return age;
48.     }
50.     public void setAge(int age) {
51.         this.age = age;
52.     }
53. }
55. class Cat {
56.     private String name;
57.     private int age;
59.     public Cat(String name, int age) {
60.         this.name = name;
61.         this.age = age;
62.     }
64.     public String getName() {
65.         return name;
66.     }
68.     public void setName(String name) {
69.         this.name = name;
70.     }
72.     public int getAge() {
73.         return age;
74.     }
76.     public void setAge(int age) {
77.         this.age = age;
78.     }
79. }

复制代码

泛型的好处：

• 编译时，检查添加元素的类型，提高了安全型
  
• 减少了类型转换的次数，提高效率
  

  如上面例子所示：不使用泛型的时候，Dog对象放到ArrayList里会先转成Object类型，在取出的时候还要再转换成Dog类型（Dog--加入-->Object--取出-->Dog）
  使用了泛型，则放入和取出时都不需要类型转换，提高效率（Dog-->-Dog-->Dog）
  

  
  
• 不再提示编译警告
  

  不添加@SuppressWarnings("all")编译器也不再警告
  

  
  

2.泛型介绍

泛型是一种可以表示数据类型的 数据类型
如下图：public class ArrayList{}  E 称为泛型

泛（广泛）型（类型）===>integer，String，Dog，……

• 泛型又称参数化类型，是jdk5.0出现的新特性，解决数据类型的安全性问题
  
• 在类声明或者实例化时只要指定好需要的具体类型即可
  
• Java泛型可以保证如果程序在编译时没有发出警告，运行就不会产生ClassCastException异常。同时，代码更加简洁、健壮
  
• 泛型的作用是：可以在类声明时 通过一个标识 表示类中的某个属性，或者是某个方法的返回值的类型，或者是参数类型
  

例子：

1. package li.generic;
3. public class Generic03 {
4.     public static void main(String[] args) {
5.         Person<String> person = new Person<String>("jack");
6.         person.showCalss();//class java.lang.String
7.         /*
8.        可以这样理解：上面的Person类变为了
9.        class Person{
10.             String s;
12.              public Person(String s) {
13.                 this.s = s;
14.             }
16.             public String f() {
17.              return s;
18.             }
19.         }
21.         */
22.         Person<Integer> person1 = new Person<Integer>(100);
23.         person1.showCalss();//class java.lang.Integer
24.         /*  可以这样理解：上面的Person类变为了
25.        class Person{
26.             Integer s;
28.              public Person(Integer s) {
29.                 this.s = s;
30.             }
32.             public Integer f() {
33.              return s;
34.             }
35.         }
36.         */
38.     }
39. }
41. class Person<E> {
42.     E s; // 用 E表示 s的数据类型，该数据类型在定义 Person对象的时候指定，即在编译期间，就确定 E是什么类型
44.     public Person(E s) {//E也可以是参数类型
45.         this.s = s;
46.     }
48.     public E f() {//返回类型使用E
49.         return s;
50.     }
52.     public void showCalss(){
53.         System.out.println(s.getClass());//显示s的运行类型
54.     }
55. }

复制代码

注意：E的数据类型在定义 Person 对象的时候指定，即在编译期间，就确定E是什么类型
泛型是一种可以表示数据类型的 数据类型
3.泛型的语法

3.1泛型的声明

interface 接口{}  和class 类{}//比如：List、ArrayList
说明：
1)其中，T,K,V不代表值，而是表示类型
2)任意字母都可以。常用T表示，是Type的缩写
3.2泛型的实例化

要在类名后面指定类型参数的值（类型），如：
(1)List strList = new ArrayList() ;
(2)Iterator iterator = customer.iterator();
3.3泛型使用举例

例子：泛型使用举例：

练习：

• 创建三个学生对象
  
• 学生对象放入到HashSet中使用
  
• 放入到HashMap中，要求Key是String name ，Value就是学生对象
  
• 使用两种方法遍历
  

练习：

1. package li.generic;
3. import java.util.*;
5. public class GenericExercise {
6.     public static void main(String[] args) {
8.         //使用泛型的方法给HashSet放入三个学生对象
9.         HashSet<Student> students = new HashSet<Student>();
10.         students.add(new Student("jack", 18));
11.         students.add(new Student("marry", 17));
12.         students.add(new Student("link", 123));
14.         //使用HashSet的增强for
15.         System.out.println("===使用HashSet的增强for===");
16.         for (Student student : students) {
17.             System.out.println(student);
18.         }
21.         //使用泛型的方法给HashMap放入三个学生对象
22.         HashMap<String, Student> hm = new HashMap<String, Student>();
23.         hm.put("jack", new Student("jack", 18));
24.         hm.put("lucy", new Student("lucy", 28));
25.         hm.put("olin", new Student("olin", 16));
28.         //迭代器 EntrySet
29.         System.out.println("===迭代器 EntrySet===");
30.         Set<Map.Entry<String,Student>> entries = hm.entrySet();
31.        Iterator<Map.Entry<String,Student>> iterator1 = entries.iterator();
32.         while (iterator1.hasNext()) {
33.             Map.Entry<String, Student> next =  iterator1.next();
34.             System.out.println(next.getKey()+"-"+next.getValue());
36.         }
37.     }
38. }
40. class Student {
41.     private String name;
42.     private int age;
44.     public Student(String name, int age) {
45.         this.name = name;
46.         this.age = age;
47.     }
49.     public String getName() {
50.         return name;
51.     }
53.     public void setName(String name) {
54.         this.name = name;
55.     }
57.     public int getAge() {
58.         return age;
59.     }
61.     public void setAge(int age) {
62.         this.age = age;
63.     }
65.     @Override
66.     public String toString() {
67.         return "Student{" +
68.                 "name='" + name + '\'' +
69.                 ", age=" + age +
70.                 '}';
71.     }
72. }

复制代码

3.4泛型使用的注意事项和细节

• interface List{} ,public class HashSet{}..等等
  说明：T，E只能是引用类型
  

  看看下面语句是否正确？
  

  List list = new ArrayList();//正确
  List list2 = new ArrayList();//错误
  
• 在指定泛型具体类型后，可以传入该类型或者其子类类型
  
• 泛型使用形式
  3.1 在实际的开发中，我们往往简写，编译器会进行类型推断,推荐使用下面的写法
  ArrayList list1 = new ArrayList();
  3.2 泛型默认是Object类型，即如果没有给泛型指定类型，默认就是Object：
  ArrayList arrayList = new ArrayList();//等价为 ArrayList arrayList = new ArrayList();
  

例子：

1. package li.generic;
3. import java.util.ArrayList;
4. import java.util.List;
6. public class GenericDetail {
7.     public static void main(String[] args) {
8.         //1.给泛型指向的数据类型要求是引用类型，不能是基本数据类型
9.         List<Integer> list = new ArrayList<Integer>();//ok
10.         //List<int> list2 = new ArrayList<int>();错误
12.         //2.因为 E指定了A类型，构造器传入了 new A()
13.         Pig<A> aPig = new Pig<A>(new A());//将A类型赋给泛型E，说明Pig构造器可以接收的是A类型的对象
15.         //在指定泛型具体类型后，可以传入该类型或者其子类类型
16.         Pig<A> aPig2 = new Pig<A>(new B());
18.         aPig.showClass();//class li.generic.A
19.         aPig2.showClass();//class li.generic.B
21.         // 3.泛型的使用形式
22.         //在实际的开发中，我们往往简写，编译器会进行类型推断,推荐使用下面的写法
23.         ArrayList<Integer> list1 = new ArrayList<>();
24.         
25.     }
26. }
27. class A{}
28. class B extends A{}
29. class Pig<E>{
30.     E e;
32.     public Pig(E e) {
33.         this.e = e;
34.     }
36.     public void showClass(){
37.         System.out.println(e.getClass());//运行类型
38.     }
39. }

复制代码

4.泛型课堂练习

定义Employee类

• 该类包括：private成员变量name，sal，birthday，其中birthday为MyDate类的对象；
  
• 为每一个属性定义getter、setter方法；
  
• 重写toString方法输出name，sal，birthday；
  
• MyDate类包括：private成员变量year，month，day。并为为每一个属性定义getter、setter方法；
  
• 创建该类的3个对象，并把这些对象放入ArrayList集合中（ArrayList需使用泛型来定义），对集合中的元素进行排序，并遍历输出：
  排序方式：调用ArrayList的sort方法，传入Comparator对象（使用泛型），先按照name排序，如果name相同，则按照生日日期的先后排序。（即定制排序）
  

练习：

1. package li.generic;
3. import java.util.ArrayList;
4. import java.util.Comparator;
6. public class GenericHomework {
7.     public static void main(String[] args) {
8.         ArrayList<Employee> employees = new ArrayList<>();
9.         employees.add(new Employee("tom", 20000, new MyDate(1980, 12, 11)));
10.         employees.add(new Employee("jack", 12000, new MyDate(2001, 12, 12)));
11.         employees.add(new Employee("tom", 50000, new MyDate(1980, 12, 10)));
13.         employees.sort(new Comparator<Employee>() {
14.             @Override
15.             public int compare(Employee o1, Employee o2) {
16.                
17. //                //比较name
18. //                int i = o1.getName().compareTo(o2.getName());
19. //                if (i != 0) {
20. //                    return i;
21. //                }
22. //                //如果name相同，就比较birthday-year
23. //                int yearMinus = o1.getBirthday().getYear()-o2.getBirthday().getYear();
24. //                if (yearMinus !=0) {
25. //                    return yearMinus;
26. //                }
27. //                //如果year相同，就比较month
28. //                int monthMinus = o1.getBirthday().getMonth()-o2.getBirthday().getMonth();
29. //                if (monthMinus !=0) {
30. //                    return monthMinus;
31. //                }
32. //                //如果month相同，就比较mday
33. //                return o1.getBirthday().getDay()-o2.getBirthday().getDay();
35.                 //比较name
36.                 int i = o1.getName().compareTo(o2.getName());
37.                 if (i != 0) {
38.                     return i;
39.                 }
40.                
41.                 //下面是对birthday的比较，因此，我们最好把日期的比较放到MyDate类完成
42.                 //封装后的维护性和复用性更好
43.                return o1.getBirthday().compareTo(o2.getBirthday());
44.             }
45.         });
47.         for (Employee e : employees) {
48.             System.out.println(e);
49.         }
50.     }
51. }
53. class Employee {
54.     private String name;
55.     private int sal;
56.     private MyDate birthday;
58.     public Employee(String name, int sal, MyDate birthday) {
59.         this.name = name;
60.         this.sal = sal;
61.         this.birthday = birthday;
62.     }
64.     public String getName() {
65.         return name;
66.     }
68.     public void setName(String name) {
69.         this.name = name;
70.     }
72.     public int getSal() {
73.         return sal;
74.     }
76.     public void setSal(int sal) {
77.         this.sal = sal;
78.     }
80.     public MyDate getBirthday() {
81.         return birthday;
82.     }
84.     public void setBirthday(MyDate birthday) {
85.         this.birthday = birthday;
86.     }
88.     @Override
89.     public String toString() {
90.         return "Employee{" +
91.                 "name='" + name + '\'' +
92.                 ", sal=" + sal +
93.                 ", birthday=" + birthday +
94.                 '}';
95.     }
96. }
99. class MyDate implements Comparable<MyDate>{
100.     private int year;
101.     private int month;
102.     private int day;
104.     public MyDate(int year, int month, int day) {
105.         this.year = year;
106.         this.month = month;
107.         this.day = day;
108.     }
110.     public int getYear() {
111.         return year;
112.     }
114.     public void setYear(int year) {
115.         this.year = year;
116.     }
118.     public int getMonth() {
119.         return month;
120.     }
122.     public void setMonth(int month) {
123.         this.month = month;
124.     }
126.     public int getDay() {
127.         return day;
128.     }
130.     public void setDay(int day) {
131.         this.day = day;
132.     }
134.     @Override
135.     public String toString() {
136.         return "MyDate{" +
137.                 "year='" + year + '\'' +
138.                 ", month='" + month + '\'' +
139.                 ", day='" + day + '\'' +
140.                 '}';
141.     }
143.     @Override
144.     public int compareTo(MyDate o) {//把 年 月 日 的比较挪到这里
146.         //如果name相同，就比较birthday-year
147.         int yearMinus = year-o.getYear();
148.         if (yearMinus !=0) {
149.             return yearMinus;
150.         }
151.         //如果year相同，就比较month
152.         int monthMinus = month-o.getMonth();
153.         if (monthMinus !=0) {
154.             return monthMinus;
155.         }
156.         //如果month相同，就比较mday
157.         return day-o.getDay();
158.     }
159. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！