• 泛型

    泛型

    一、引例

        如创建个人信息类：包含String name、int age、double sorce;由于类型涵盖比较多我们不由会想起用Object类型来保存所有的类型。

    1. class Information{
    2. 	private Object name;
    3. 	private Object age;
    4. 	private Object sorce;
    5. 	public Object getName() {
    6. 		return name;
    7. 	}
    8. 	public void setName(Object name) {
    9. 		this.name = name;
    10. 	}
    11. 	public Object getAge() {
    12. 		return age;
    13. 	}
    14. 	public void setAge(Object age) {
    15. 		this.age = age;
    16. 	}
    17. 	public Object getSorce() {
    18. 		return sorce;
    19. 	}
    20. 	public void setSorce(Object sorce) {
    21. 		this.sorce = sorce;
    22. 	}
    23. }
    24. public class genericity4_24 {
    25. 	public static void main(String[] args) {
    26. 		Information info = new Information();
    27. 		//自动转型并向上转型为Object
    28. 		info.setName("lemon");
    29. 		info.setAge("20");
    30. 		info.setSorce(88);
    31. 		int age = (int)info.getAge();//强制向下转型为int
    32. 		System.out.println(age);
    33. 	}
    34. }

                         

    在上述例子中我们明显可以看出正式由于设置为Object类型，由于设置方设置了错误的类型数据但接收方并不知情所以就会出现ClassCastExceptoion（两个没有关系的对象进行强制类型转换出现的异常）错误。

    而在此时编译阶段并没有报错，而是在运行时出现了此类错误，则我们可以得知向下转型是不安全的操作，会带来一些隐患。

    二、泛型

    为了解决上述问题我们接下来引入泛型：

    泛型是在jdk1.5引入的，泛型其实指得就是参数化类型，使得代码可以适应多种类型。

    1、泛型类

    泛型类指的是在类定义时不会设置类中属性和方法中参数的具体类型，而在类使用时再进行定义。

    基本语法      

    1. // 其中 <>中的T被称为类型参数，可用来代指任意类型；
    2. //T可任意写，但出于规范，一般用单个大写字母来代表类型参数.
    3. //T 代表一般的任何类。
    4. //E 代表 Element 的意思，或者 Exception 异常的意思。
    5. //K 代表 Key 的意思
    6. //V 代表 Value 的意思，通常与 K 一起配合使用。
    7. //S 代表 Subtype 的意思
    8. class Information <T>{
    9. 	private T name;
    10. }

    若一个类被<T>定义,则称其为泛型类.

    （1）泛型类的使用

    1.泛型类中只包含一个类型参数

    1. /*
    2.  * 泛型类中只包含一个类型参数
    3.  * */
    4. class Information <T>{
    5. 	//T可为任意类型，在实例化时给出
    6. 	private T name;
    7.  
    8. 	public T getName() {
    9. 		return name;
    10. 	}
    11. 	//setting方法中，形式参数类型仍然为T，具体类型以实例化为准
    12. 	public void setName(T name) {
    13. 		this.name = name;
    14. 	}
    15. }
    16. public class genericity4_24{
    17. 	public static void main(String[] args) {
    18. 		//形式化参数为String类型
    19.       //在jdk1.7以后，下述语句可以改写为Information info = new Information <String,Integer>();
    20. 		Information <String>  info = new Information <String>();
    21. 		info.setName("lemon");
    22.        //取出数据时避免了向下转型
    23. 		System.out.println(info.getName());
    24. 	}
    25. }

                        

    2.泛型类中包含多个类型参数

    1. /*
    2.  * 泛型类中包含多个类型参数
    3.  * */
    4. //在泛型类中定义多个类型参数，T,E均表示一个占位符，若有更多的参数继续在其后追加
    5. class Information <T,E>{
    6. 	//T，E可为任意类型，在实例化时给出
    7. 	private T name;
    8. 	private E age;
    9. 	public T getName() {
    10. 		return name;
    11. 	}
    12. 	public E getAge() {
    13. 		return age;
    14. 	}
    15. 	//setter方法中，形式参数类型仍然为T，E，具体类型以实例化为准
    16. 	public void setName(T name) {
    17. 		this.name = name;
    18. 	}
    19. 	public void setAge(E age) {
    20. 		this.age = age;
    21. 	}
    22. }
    23. public class genericity4_24{
    24. 	public static void main(String[] args) {
    25. 		//形式化参数为多个，在<>用，隔开
    26. 		//且泛型只能接受类，所有基本数据类型都要使用其包装类
    27. 		Information <String,Integer>  info = new Information <String,Integer>();
    28. 		info.setName("lemon");
    29. 		info.setAge(20);
    30. 		System.out.println(info.getName());
    31. 		System.out.println(info.getAge());
    32. 	}
    33. }

                                     

               当传入参数错误时就会在编译阶段报错，消除了安全隐患。

                              

    由此我们可以得出泛型的引入彻底改变了向下转型的需求。引入泛型后，若明确设置了类型，则为设置类型；若没有设置类型，则默认为Object类型。

    2、泛型方法

    泛型不仅可以在类中定义同时也可在方法中定义。

    （1）泛型方法的基本语法

    1. class Information<E>{
    2. 	private E name;
    3. 	private E classBelongs;
    4. 	//泛型类中定义泛型方法<>中的E被称为类型参数，而方法中的T被称为参数化类型，不是运行时真正的参数
    5. 	public <T> void printInformation(T name,T classBelong) {
    6. 		System.out.println("姓名："+this.name+",班级："+this.classBelongs);
    7. 	}
    8. }

    （2）泛型方法的使用

        泛型方法与泛型类有所不同，泛型类在类名之后加<E>,而泛型方法是在返回值之前加<E>.

    泛型方法始终以自己定义的类型参数为准。且声明的类型参数，也可以当作返回值的类型来使用。

    1. /*
    2.  * 泛型类中定义泛型方法和普通方法
    3.  * */
    4. //泛型类
    5. class Information<E>{
    6. 	private E name;
    7. 	private E classBelongs;
    8. 	public E getName() {
    9. 		return name;
    10. 	}
    11. 	public void setName(E name) {
    12. 		this.name = name;
    13. 	}
    14. 	public E getClassBelongs() {
    15. 		return classBelongs;
    16. 	}
    17. 	public void setClassBelongs(E classBelongs) {
    18. 		this.classBelongs = classBelongs;
    19. 	}
    20. 	//泛型类中的泛型方法,泛型类中的类型参数与泛型方法中的类型参数是没有相应的联系的，形式化参数中的E不是运行时真正的参数
    21. 	public <E> void printInformation(E name,E classBelong) {
    22. 		System.out.println("姓名"+this.name+"，班级："+this.classBelongs);;
    23. 	}
    24. 	public <E> E print(E e) {
    25. 		return e;
    26. 	}
    27. 	//泛型类中的普通方法
    28. 	public void printInformation1(E name,E classBelong) {
    29. 		System.out.println("姓名："+this.name+",班级："+this.classBelongs);
    30. 	}
    31. 	public void print1(E e) {
    32. 		System.out.println(e);
    33. 	}
    34. 	
    35. }
    36. public class genericity4_24{
    37. 	public static void main(String[] args) {
    38. 		Information <String> info = new Information <String>();
    39. 		info.setName("lemon");
    40. 		info.setClassBelongs("数学152");
    41. 		info.printInformation(info.getName(),info.getClassBelongs());
    42. 		info.printInformation1(info.getName(),info.getClassBelongs());
    43. 		//泛型方法种的参数化类型为整形
    44. 		System.out.println(info.print(100));
    45. 		//普通方法种的参数化类型必须为实例化时所对应的类型,若此时像泛型方法中一样给其赋值为int型，则会出现错误，如下图
    46. 		info.print1("100");	
    47. }
    48. }

                         

    结论：

    泛型类中的类型参数与泛型方法中的类型参数是没有相应的联系的，泛型方法始终以自己定义的类型参数为准。

    泛型类的实际类型参数是 String，而传递给泛型方法的类型参数是 Integer，两者不相干。一般为了避免混淆，若一个泛型类中存在泛型方法，那么两者的类型参数最好不要同名。

    3、泛型接口

    泛型除了可以定义在类，方法中外，还可以定义在接口中，我们称之为泛型接口。

    泛型接口有两种实现方式：子类实现时继续使用泛型；子类实现接口时给定类型。

    1. /*
    2.  * 泛型接口
    3.  * */
    4. //定义泛型接口
    5. interface IMessage<T>{
    6. 	public void print(T t);
    7. }
    8. //子类实现接口继续使用泛型
    9. class MessageImpl <T> implements IMessage<T>{
    10. 	@Override
    11. 	public void print(T t) {
    12. 		System.out.println(t);
    13. 	}
    14. }
    15. //子类实现接口时明确给定类型
    16. class MessageImpl1 implements IMessage<String>{
    17.  
    18. 	@Override
    19. 	public void print(String t) {
    20. 		System.out.println(t);
    21. 	}
    22. 	
    23. }
    24. public class genericity4_24{
    25. 	public static void main(String[] args) {
    26. 		//向上转型
    27. 		IMessage <String> message = new MessageImpl();
    28. 		message.print("hello");
    29. 		IMessage <String> message2 = new MessageImpl1();
    30. 		message2.print("world");
    31. 	}
    32. }
                             

    4、通配符

    （1）通配符的引入

    1. class Message<T>{
    2. 	private T message;
    3. 	public T getMessage() {
    4. 		return message;
    5. 	}
    6. 	public void setMessage(T message) {
    7. 		this.message = message;
    8. 	}
    9. }
    10. public class genericity4_24{
    11. 	public static void main(String[] args) {
    12. 		Message message = new Message<String>();
    13. 		message.setMessage("Hello World");
    14. //若将以上语句更改为 message.setMessage(99) 即泛型的类型由String设置为Integer则会出现如下图所示的错误信息
    15. 		fun(message);
    16. 	}
    17.         public static void fun(Message<String> t) {
    18. 		System.out.println(t.getMessage());
    19. 	}
    20. }

                     

                      

    （2）通配符的使用

    由上述情况得出，不能用来接受任意类型，所以我们要对其进行扩展使其可以接受任意类型。由此就有了通配符的概念：

    1. class Message<T>{
    2. 	private T message;
    3. 	public T getMessage() {
    4. 		return message;
    5. 	}
    6. 	public void setMessage(T message) {
    7. 		this.message = message;
    8. 	}
    9. }
    10. public class genericity4_24{
    11. 	public static void main(String[] args) {
    12. 		Message message = new Message<String>();
    13. 		//若将以上语句更改为 message.setMessage(99) 则会出现如下图所示的错误信息
    14. 		message.setMessage(99);
    15. 		fun(message);
    16. 	}
    17. 	//此时使用通配符？描述的是它可以接受任意类型，
    18. 	//但是由于类型是不确定的所以无法对内容进行修改
    19. 	public static void fun(Message <?> t) {
    20. 		//t.setMessage("ooo");
    21. 		System.out.println(t.getMessage());
    22. 	}
    23. }
    24.
                          

                                   

    （3）通配符的扩展

    在通配符即基础上又可扩展出两个子通配符：

    a. 设置泛型上限  _extends 类

    b. 设置泛型下限  _super 类

    例如：

    ? extends Number，表示只能够设置Number或其子类，例如：Integer、Double等；

    ? super String，表示只能够设置String及其父类Object。

    1. //设置泛型上限，则实例化时只能实例化为Number及其子类
    2. class Message<T extends Object>{
    3. 	private T message;
    4. 	public T getMessage() {
    5. 		return message;
    6. 	}
    7. 	public void setMessage(T message) {
    8. 		this.message = message;
    9. 	}
    10. }
    11. public class genericity4_24{
    12. 	public static void main(String[] args) {
    13. 		Message message = new Message<Number>();
    14. 		message.setMessage(99);
    15. 		System.out.println("我为设置泛型上限的测试用例");
    16. 		fun(message);
    17. 		System.out.println("我为设置泛型下限的测试用例");
    18. 		fun1(message);
    19. 	}
    20. 	//此时 ？extends Number 表示可以接受的类型为Number及其子类
    21. 	//但还是不确定其具体类型，所以仍然无法对其内容进行修改
    22. 	public static void fun(Message <? extends Number> t) {
    23. 		//t.setMessage("ooo");
    24. 		System.out.println(t.getMessage());
    25. 	}
    26. 	//此时 ？super Number 表示可以接受的类型为String及其父类
    27. 	//但我们可以已经大概知道其类型，可发生自动向上转型所以可以对其内容进行更改
    28. 	public static void fun1(Message<? super String> t1) {
    29. 		t1.setMessage("hello");
    30. 		System.out.println(t1.getMessage());
    31. 	}
    32. }

                        

    5、类型擦除

    泛型的概念是jdk1.5才引进的，在其之前没有泛型的概念，由此可以看出泛型对之前的版本具有很好的兼容性。

    那是因为泛型信息只存在于代码编译阶段，在进入JVM 之前，与泛型相关的信息会被擦除掉，专业术语叫做类型擦除。（即在进入JVM之前，泛型类和普通类在本质上没有什么区别）

    1. class Message<T>{
    2. 	private T message;
    3. 	public T getMessage() {
    4. 		return message;
    5. 	}
    6. 	public void setMessage(T message) {
    7. 		this.message = message;
    8. 	}
    9. }
    10. public class genericity4_24{
    11. 	public static void main(String[] args) {
    12. 		Message message = new Message<String>();
    13. 		Message message2 = new Message<Object>();
    14. 		System.out.println(message.getClass());
    15. 		System.out.println(message2.getClass());
    16. 		System.out.println(message.getClass()==(message2.getClass()));
    17. 	}
    18. }

                                

    在JVM中Class 都是class struct.Message所以打印结果是true.

    1. //T指定泛型上限，E 未指定
    2. class Message<T extends String,E>{
    3. 	private T name;
    4. 	private E age;
    5. 	public T getName() {
    6. 		return name;
    7. 	}
    8. 	public void setName(T name) {
    9. 		this.name = name;
    10. 	}
    11. 	public E getAge() {
    12. 		return age;
    13. 	}
    14. 	public void setAge(E age) {
    15. 		this.age = age;
    16. 	}
    17. 	public void print(T name) {
    18. 		this.name = name;
    19. 	}
    20. 	public void testMessage(T t) {
    21. 		System.out.println(t);
    22. 	}
    23. }
    24. public class genericity4_24{
    25. 	public static void main(String[] args) {
    26. 		Message mes = new <String,Integer> Message();
    27. 		Class class1 = mes.getClass();
    28. 		Field[] fields = class1.getDeclaredFields();
    29. 		for (Field field : fields) {
    30. 		System.out.println(field.getType());
    31. 		}
    32.     }
    33. }

                              

    在泛型类被类型擦除的时候，之前泛型类中的类型参数部分如果没有指定上限，如<E> 则会被转译成普通的Object 类型，T指定了上限T extends String> 则类型参数就被替换成类型上限。
  • 相关阅读:
    logging模块
    configparser模块
    hashlib模块
    shutil模块
    json与pickle模块
    random模块
    OS模块
    如何不使用共享内存实现windows与虚拟机中进行文件的传输
    结构体的定义方式（仅定义）
    数据结构练习之寻找顺序表中的主要元素
  • 原文地址：https://www.cnblogs.com/edda/p/12601330.html
Copyright © 2020-2023  润新知