Java 随堂笔记XXV --泛型类

泛型

1.泛型概述

泛型：是JDK5 中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型，它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数
一提到参数， 最熟悉的就是定义方法时由形参，然后调用此方法时传递实参，那么参数化类型怎么理解？
顾名思义， 就是将类型由原来的具体的类型参数化，然后使用/调用时传入具体的类型
这种参数类型可以用在类、方法和接口中，分别称为泛型类，泛型方法，泛型接口
泛型是一种参数的类型，可以将类或者具体的类型参数化，在使用过程中可以传入具体的类型

java形参和实参复习：
1.形参：用来接收调用该方法时传递的参数。
只有在被调用的时候才分配内存空间，一旦调用结束，就释放内存空间。因此仅仅在方法内有效。
public void swap(int a, int b) {
int temp = a;
a = b;
b = temp;
System.out.println(“a:” + a + “ b:” + b);
}
这里边的a,b就是形参，temp是一个局部变量，方法结束，在栈空间中就会被销毁
2.实参：传递给被调用方法的值，预先创建并赋予确定值。
1 调用上面的
2 swap(1,2);
3 其中1和2就是实际的参数值，就叫实参

泛型定义格式：

     1. <类型>： 指定一种类型的格式。这里的类型可以看成是形参
     1. <类型1，类型2>： 指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
     1. 将来具体调用时给定的参数可以看成是实参，并且实参的类型只能是引用数据类型

泛型的好处：

     1. 把运行时期的问题提前到了编译期间
     1. 避免了强制类型转换

public class GenericDemo {
// 需求： Collection集合存储字符串并遍历
public static void main(_String[] args) {
// 创建集合对象
// Collection c = new ArrayList();
// 使用泛型可避免类型转换异常的隐形错误发生
Collection<_String_> c = new ArrayList<>()_;

    // 添加元素,没有指定集合中类型的时候，默认引用类未object类型，因为所有类型都指向object类<br />        // 指定的object类，输入字符串或者整数都属于是向上转型，因为object是所有类的父类<br />        c.add_(_"hello"_)_;<br />        c.add_(_"world"_)_;<br />        c.add_(_"java"_)_;<br />//        c.add(11); 使用泛型后，字符串类型提示整数类型报错
    // 使用Iterator遍历集合<br />        //  Iterator it = c.iterator();<br />        // 使用带泛型的迭代器遍历，泛型和集合指定的类型是对应的<br />        Iterator_<_String_> _it = c.iterator_()_;<br />        while _(_it.hasNext_()){<br />    _/*   生成的类型不是String类型，是Object类型，因为添加object类型<br />             Object o = it.next();<br />         将object父类向下转型称为String类<br />         如果添加整形类将报错 ClassCastException 类型转换异常<br />            String s = (String) it.next();<br />            System.out.println(s);      */<br />            String s = it.next_()_;<br />            System._out_.println_(_s_)_;    _}  }  }_

2. 泛型类

泛型类的定义格式：
格式：修饰符 class 类名<类型>{ }
格式：public class Generic{ }
Tips： 类名中的表示是随便任意表示，常见的如T\E\K\V等形式的参数常用于表示泛型
// 定义一个教师类,里面有String类型的成员变量
public class Teacher {
_private int age;
public int getAge() { return age; }
public void setAge(int age) { this.age = age; } }
————————————-
// 定义一个学生类,里面有String类型的成员变量
public class Student {
private String name;
public String getName() { return name; }
public void setName(String name) { this.name = name; } }
——————————————————————
// 创建一个T类型的成员变量，表示可以未任意变量
public class Generic <_T_>{
private T t;
public T getT() { return t; }
public void setT(T t) { this.t = t; } }
—————————————————
public class GenericDemo {
public static void main(String[] args) {
// 创建学生类，但是只能设置单一String类型变量
Student s = new Student();
s.setName(“李畅”);
System._out.println(_s.getName());
// 创建教师类，但是只能设置单一int类型变量
Teacher t = new Teacher();
t.setAge(13);
System._out.println(_t.getAge());
System._out.println(“———————“);
// 创建泛型类，自定义String类型
Generic<_String> gs = new Generic<>();
gs.setT(“赵明”);
System._out.println(_gs.getT());
// 创建泛型类，自定义Integer类型
Generic<_Integer_> gi = new Generic<>();
gi.setT(23);
System._out.println(_gi.getT());
System._out.println(“———————“);
// 创建泛型类，自定义Boolean类型
Generic<_Boolean> gb = new Generic<>();
gb.setT(true);
System._out.println(_gb.getT());
// 创建泛型类,指定多个类型,不可行
// Generic generic = new Generic<>(); } }_

3. 泛型方法

泛型方法的定义格式
格式：修饰符<类型> 方法的返回值类型 方法名(类型 变量名){ }
实例：public void show(T t){ }
void :表示空类型(任意类型)
/ public class Generic {
// 该类中含有三个相同名,但是参数类型不同的方法— > 方法重载
public void show(String s){ System.out.println(s); }
public void show(Integer i){ System.out.println(i); }
public void show(Boolean b){ System.out.println(b); } }/
/ 使用泛型类改进类中的方法
public class Generic{
public void show(T t){ System.out.println(t); } }/
// 在main方法中调用本类方法，static方法需要加泛型
public static<_T> void play(T t){ System._out.println(_t); }
// 创建一个类,其中带有泛型方法
public class Generic { public<_T_> void show(T t){ System._out.println(_t); } }
————————————————-
public class GenericDemo {
public static void main(String[] args) {
/ Generic g = new Generic();
g.show(“李畅”);
g.show(23);
g.show(true);
Generic g = new Generic<>();
g.show(“李畅”);
Generic g1 = new Generic<>();
g1.show(23);
Generic g2 = new Generic<>();
g2.show(true); /
// 调用泛型犯法，参数可以传递何类型
Generic g = new Generic();
g.show(“李畅”); // String
g.show(11); // Integer
g.show(true); // Boolean
g.show(12.45); // Float } }_

4. 泛型接口

泛型接口的定义格式
格式：修饰符 interface 接口名<类型> { }
实例：public interface Generic{ }
// 泛型类接口
public interface Generic<_T> {
// 接口类的方法不能有方法体, 默认public abstract修饰
void show(T t); }
———————————————————————-
// 定义一个接口的实现类GenericImpl 实现泛型接口类Generic
public class GenericImpl<_T_> implements Generic<_T_>{
// 因为Generic接口类是抽象类, 所以实现类必须要重写Generic接口中的show()方法
@Override
public void show(T t) { System._out.println(_t); } }
———————————————————————————-
/public class GenericDemo {
public static void main(String[] args) {
Generic