• java的面向对象基础（6）——高级泛型

    嵌入式之路，贵在日常点滴

                                                                    ---阿杰在线送代码

    目录

    一、泛型简介

    二、泛型类及特点

    1、泛型的类型参数可以是泛型类

    2、泛型类可以同时设置多个类型参数

    3、泛型类可以继承泛型类

    4、泛型类可以实现泛型接口

    三、限制泛型可用类型 

    四、类型通配的方式

    类型通配声明 例子 

    类型通配的方式 

    五、泛型方法 

    什么时候使用泛型方法，而不是泛型类呢？

    问题：如果我们需要产生多个对象，每个对象的逻辑完全一样，只要对象内的成员变量的类型不同，那我们如何去做？

    • 创建多个类文件，给每个类中的成员变量设置指定的数据类型。

            缺点:这种方式会导致类的膨胀，重用型太差。 

    1.  
    2. class Cls1
    3. {
    4. 	int a;
    5. 	
    6. 	public Cls1(int a){
    7. 		this.a = a;
    8. 	}
    9. 	
    10. 	public int getData(){
    11. 		return a;
    12. 	}
    13. }
    14.  
    15. class Cls2
    16. {
    17. 	String a;
    18. 	
    19. 	public Cls2(String a){
    20. 		this.a = a;
    21. 	}
    22. 	
    23. 	public String getData(){
    24. 		return a;
    25. 	}
    26. }
    27.  
    28. public class Test {
    29. 	public static void main(String[] args) {
    30. 		Cls1 cls1 = new Cls1(10);
    31. 		System.out.println(cls1.getData());
    32. 		
    33. 		Cls2 cls2 = new Cls2("ajie");
    34. 		System.out.println(cls2.getData());
    35. 	}
    36. }

    运行结果：

    10
    ajie 

    • 创建一个类文件，给这个类中的成员变量设置Object数据类型。

           缺点，编译的时候正常，但运行的时候可能会异常。 （因为其类型比较模糊，有时候做了错误得类型转换就会导致运行程序时崩溃，编译没有错误）

    鼠标定位到数据类型，右键 选择 Type Hierarchy

    观察可以看出Object是所有数据类型的父类

    1. class Cls1
    2. {
    3. 	Object a;
    4. 	
    5. 	public Cls1(Object a){
    6. 		this.a = a;
    7. 	}
    8. 	
    9. 	public Object getData(){
    10. 		return a;
    11. 	}
    12. }
    13.  
    14. public class Test {
    15. 	public static void main(String[] args) {
    16. 		Cls1 cls1 = new Cls1(10);
    17. 		System.out.println(cls1.getData());		
    18. 		
    19. 		Cls1 cls2 = new Cls1("ajie");
    20. 		System.out.println(cls2.getData());
    21. 	}
    22. }

    为解决此问题，我们引入 泛型

    一、泛型简介

    • 泛型可以在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的。
    • 泛型的原理就是"类型的参数化"，即把类型看作参数。也就是说把所要操作的数据类型看作参数，就像方法的形式参数是运行时传递的值的占位符一样。
    • 简单的说，类型变量扮演的角色就如同一个参数，它提供给编译器用来类型检查的信息。
    • 泛型可以提高代码的扩展性和重用性。 
    1. class Cls1
    2. {
    3. 	T a;
    4. 	
    5. 	public Cls1(T a){
    6. 		this.a = a;
    7. 	}
    8. 	
    9. 	public T getData(){
    10. 		return a;
    11. 	}
    12. }
    13.  
    14. public class Test {
    15. 	public static void main(String[] args) {
    16. 		Cls1 cls1 = new Cls1(10);
    17. 		System.out.println(cls1.getData());		
    18. 		
    19. 		Cls1 cls2 = new Cls1("ajie");
    20. 		System.out.println(cls2.getData());
    21. 	}
    22. }

    运行结果：

    10
    ajie 

    myeclipse工程环境出错：Set project compiler compliance settings to '1.5'

    解决方案 

    二、泛型类及特点

    1、泛型的类型参数可以是泛型类

    1. class Cls1
    2. {
    3. 	T a;
    4. 	
    5. 	public Cls1(T a){
    6. 		this.a = a;
    7. 	}
    8. 	
    9. 	public T getData(){
    10. 		return a;
    11. 	}
    12. }
    13.  
    14. public class Test {
    15. 	public static void main(String[] args) {
    16. 		Cls1> cls1 = new Cls1>(new Cls1(10));
    17. 		System.out.println(cls1.getData().getData());		
    18. 		
    19. 	}
    20. }

    运行结果： 

    10

    2、泛型类可以同时设置多个类型参数

    1. class Cls2
    2. {
    3. 	T a;
    4. 	T2 b;
    5.  
    6. 	public Cls2(T a,T2 b){
    7. 		this.a = a;
    8. 		this.b = b;
    9. 	}
    10. 	
    11. 	public T getData(){
    12. 		return a;
    13. 	}
    14. 	public T2 getData2(){
    15. 		return b;
    16. 	}
    17. }
    18.  
    19. public class Test {
    20. 	public static void main(String[] args) {
    21. 		
    22. 		Cls2 cls3 = new Cls2(100,"ajie");
    23. 		System.out.println(cls3.getData());
    24. 		System.out.println(cls3.getData2());
    25. 		System.out.println(cls3.getData()+cls3.getData2());
    26. 		
    27. 		Cls2 cls4 = new Cls2(100,10);
    28. 		System.out.println(cls4.getData()+cls4.getData2());//注意，在以前我们这里用到的+都是链接作用
    29. 									//在这里+可以作为加法使用
    30. 		int sum = 0;
    31. 		sum = cls4.getData()+cls4.getData2();
    32. 		System.out.println(sum);
    33. 	}
    34. }

    运行结果：

    100
    ajie
    100ajie
    110
    110 

    3、泛型类可以继承泛型类

    1. abstract class Cls1
    2. {
    3. 	T a;
    4. 	
    5. 	public Cls1(T a){
    6. 		this.a = a;
    7. 	}
    8. 	
    9. 	public T getData(){
    10. 		return a;
    11. 	}
    12. 	
    13. 	abstract void printInfo();
    14. }
    15.  
    16. class Cls2 extends Cls1
    17. {
    18. 	T2 b;
    19. 	
    20. 	public Cls2(T a,T2 b){
    21. 		super(a);//调用了父类的构造方法，这个语句必须放在子类构造方法的第一句
    22. 		this.b = b;
    23. 	}
    24. 	
    25. 	public T2 getData2(){
    26. 		return b;
    27. 	}
    28.  
    29. 	@Override
    30. 	void printInfo() {
    31. 		// TODO Auto-generated method stub
    32. 		System.out.println("print");
    33. 	}
    34. } 
    35.  
    36. public class Test {
    37. 	public static void main(String[] args) {
    38. 			
    39. 		Cls2 cls = new Cls2(10,"ajie");
    40. 		System.out.println(cls.getData());
    41. 		System.out.println(cls.getData2());
    42. 		cls.printInfo();
    43. 	}
    44. }

    运行结果：

    10
    ajie
    print

    4、泛型类可以实现泛型接口

    1. abstract class Cls1
    2. {
    3. 	T a;
    4. 	
    5. 	public Cls1(T a){
    6. 		this.a = a;
    7. 	}
    8. 	
    9. 	public T getData(){
    10. 		return a;
    11. 	}
    12. 	
    13. 	abstract void printInfo();
    14. }
    15.  
    16. interface Cls3
    17. {
    18. 	abstract void printInfoCls3(T t);
    19. }
    20.  
    21. class Cls2 extends Cls1 implements Cls3
    22. {//如果Cls2的T和Cls3T是同名，则在下面主函数使用时，Cls3的类型遵循Cls2，否则会报错
    23.  //即使不同名，也会报错 问题如何解决 在下面展示
    24. 	T2 b;
    25. 	
    26. 	public Cls2(T a,T2 b){
    27. 		super(a);//调用了父类的构造方法，这个语句必须放在子类构造方法的第一句
    28. 		this.b = b;
    29. 	}
    30. 	
    31. 	public T2 getData2(){
    32. 		return b;
    33. 	}
    34.  
    35. 	@Override
    36. 	void printInfo() {
    37. 		// TODO Auto-generated method stub
    38. 		System.out.println("print");
    39. 	}
    40.  
    41. 	@Override
    42. 	public void printInfoCls3(T t) {
    43. 		// TODO Auto-generated method stub
    44. 		System.out.println(t);
    45. 	}
    46. } 
    47.  
    48. public class Test {
    49. 	public static void main(String[] args) {
    50. 			
    51. 		Cls2 cls = new Cls2(10,"ajie");
    52. 		System.out.println(cls.getData());
    53. 		System.out.println(cls.getData2());
    54. 		cls.printInfo();
    55. 		cls.printInfoCls3(100);
    56. 	}
    57. }

    运行结果：

    10
    ajie
    print
    100 

    如何解决 如果Cls2的T和Cls3的T是同名，则在下面主函数使用时，Cls3的T类型遵循Cls2，否则会报错 问题。即使不同名，也会报错

    1. abstract class Cls1
    2. {
    3. 	T a;
    4. 	
    5. 	public Cls1(T a){
    6. 		this.a = a;
    7. 	}
    8. 	
    9. 	public T getData(){
    10. 		return a;
    11. 	}
    12. 	
    13. 	abstract void printInfo();
    14. }
    15.  
    16. interface Cls3
    17. {
    18. 	abstract void printInfoCls3(T3 t);
    19. }
    20.  
    21. class Cls2 extends Cls1 implements Cls3
    22. {//如果Cls2的T和Cls3T是同名，则在下面主函数使用时，Cls3的类型遵循Cls2，否则会报错
    23.  
    24. 	T2 b;
    25. 	
    26. 	public Cls2(T a,T2 b){
    27. 		super(a);//调用了父类的构造方法，这个语句必须放在子类构造方法的第一句
    28. 		this.b = b;
    29. 	}
    30. 	
    31. 	public T2 getData2(){
    32. 		return b;
    33. 	}
    34.  
    35. 	@Override
    36. 	void printInfo() {
    37. 		// TODO Auto-generated method stub
    38. 		System.out.println("print");
    39. 	}
    40.  
    41. 	@Override
    42. 	public void printInfoCls3(T3 t) {
    43. 		// TODO Auto-generated method stub
    44. 		System.out.println(t);
    45. 	}
    46. } 
    47.  
    48. public class Test {
    49. 	public static void main(String[] args) {
    50. 			
    51. 		Cls2 cls = new Cls2(10,"ajie");
    52. 		System.out.println(cls.getData());
    53. 		System.out.println(cls.getData2());
    54. 		cls.printInfo();
    55. 		cls.printInfoCls3("ajie");
    56. 	}
    57. }

    三、限制泛型可用类型 

    在定义泛型类别时，默认在实例化泛型类的时候可以使用任何类型，但是如果想要限制使用泛型类型时，只能用某个特定类型或者是其子类型才能实例化该类型时，可以在定义类型时，使用extends关键字指定这个类型必须是继承某个类，或者实现某个接口。

    当没有指定泛型继承的类型或接口时，默认使用extends Object。所以默认情况下任何类型都可以作为参数传入。 

    1. //默认情况下，以下两种情况是一样的
    2. class Cls1
    3. {
    4. 	T a;
    5. 	
    6. 	public Cls1(T a){
    7. 		this.a = a;
    8. 	}
    9. 	
    10. 	public T getData(){
    11. 		return a;
    12. 	}
    13. }
    14.  
    15. class Cls1
    16. {
    17. 	T a;
    18. 	
    19. 	public Cls1(T a){
    20. 		this.a = a;
    21. 	}
    22. 	
    23. 	public T getData(){
    24. 		return a;
    25. 	}
    26. }
    1. //使用extends关键字指定这个类型
    2.  
    3. abstract class Cls1
    4. {
    5. 	T a;
    6. 	
    7. 	public Cls1(T a){
    8. 		this.a = a;
    9. 	}
    10. 	
    11. 	public T getData(){
    12. 		return a;
    13. 	}
    14. 	
    15. 	abstract void printInfo();
    16. }
    17.  
    18. interface Cls3
    19. {
    20. 	abstract void printInfoCls3(T3 t);
    21. }
    22.  
    23. class Cls2 extends Cls1 implements Cls3
    24. {
    25. 	T2 b;
    26. 	
    27. 	public Cls2(T a,T2 b){
    28. 		super(a);//调用了父类的构造方法，这个语句必须放在子类构造方法的第一句
    29. 		this.b = b;
    30. 	}
    31. 	
    32. 	public T2 getData2(){
    33. 		return b;
    34. 	}
    35.  
    36. 	@Override
    37. 	void printInfo() {
    38. 		// TODO Auto-generated method stub
    39. 		System.out.println("print");
    40. 	}
    41.  
    42. 	@Override
    43. 	public void printInfoCls3(T3 t) {
    44. 		// TODO Auto-generated method stub
    45. 		System.out.println(t);
    46. 	}
    47. } 

    1. //使用extends关键字指定这个类型必须是继承某个类
    2. class Animal
    3. {
    4. 	
    5. }
    6.  
    7. class Dog extends Animal
    8. {
    9. 	
    10. }
    11.  
    12. abstract class Cls1
    13. {
    14. 	T a;
    15. 	
    16. 	public Cls1(T a){
    17. 		this.a = a;
    18. 	}
    19. 	
    20. 	public T getData(){
    21. 		return a;
    22. 	}
    23. 	
    24. 	abstract void printInfo();
    25. }
    26.  
    27. interface Cls3
    28. {
    29. 	abstract void printInfoCls3(T3 t);
    30. }
    31.  
    32. class Cls2 extends Cls1 implements Cls3
    33. {
    34. 	T2 b;
    35. 	
    36. 	public Cls2(T a,T2 b){
    37. 		super(a);//调用了父类的构造方法，这个语句必须放在子类构造方法的第一句
    38. 		this.b = b;
    39. 	}
    40. 	
    41. 	public T2 getData2(){
    42. 		return b;
    43. 	}
    44.  
    45. 	@Override
    46. 	void printInfo() {
    47. 		// TODO Auto-generated method stub
    48. 		System.out.println("print");
    49. 	}
    50.  
    51. 	@Override
    52. 	public void printInfoCls3(T3 t) {
    53. 		// TODO Auto-generated method stub
    54. 		System.out.println(t);
    55. 	}
    56. } 

    1. //使用extends关键字指定这个类型必须是继承某个类，或者实现某个接口。
    2.  
    3. interface Move
    4. {
    5. 	abstract void test();
    6. }
    7.  
    8. class A implements Move//正常继承实现接口的方法使用的是implements
    9. {
    10. 	public void test(){
    11. 		
    12. 	}
    13. }
    14.  
    15. abstract class Cls1//但是在泛型这里需要使用extends限定
    16. {
    17. 	T a;
    18. 	
    19. 	public Cls1(T a){
    20. 		this.a = a;
    21. 	}
    22. 	
    23. 	public T getData(){
    24. 		return a;
    25. 	}
    26. 	
    27. 	abstract void printInfo();
    28. }
    29.  
    30. interface Cls3
    31. {
    32. 	abstract void printInfoCls3(T3 t);
    33. }
    34.  
    35. class Cls2 extends Cls1 implements Cls3
    36. {
    37. 	T2 b;
    38. 	
    39. 	public Cls2(T a,T2 b){
    40. 		super(a);//调用了父类的构造方法，这个语句必须放在子类构造方法的第一句
    41. 		this.b = b;
    42. 	}
    43. 	
    44. 	public T2 getData2(){
    45. 		return b;
    46. 	}
    47.  
    48. 	@Override
    49. 	void printInfo() {
    50. 		// TODO Auto-generated method stub
    51. 		System.out.println("print");
    52. 	}
    53.  
    54. 	@Override
    55. 	public void printInfoCls3(T3 t) {
    56. 		// TODO Auto-generated method stub
    57. 		System.out.println(t);
    58. 	}
    59. }

    以上这些实际编程时很少用，现在是用来科普我们的认知，看到要认识。

    后续编程安卓可能会用到。 

    四、类型通配的方式

    同一泛型类，如果实例化时给定的实际类型不同，则这些实例的类型是不兼容的，不能相互赋值。

    1. Cls1 c1 = new Cls1();
    2. Cls1 c2 = new Cls1();
    3. c1 = c2;//发生编译错误
    4.  
    5. Cls1 c3 = c1;//c3和c1类型并不兼容，发生编译错误
    6. c3 = c2;//c3和c2类型同样不兼容，也会发生编译错误
      7.  

      泛型类实例之间的不兼容性会带来使用的不便。我们可以使用泛型通配符(？)声明泛型类的变量就可以解决这个问题。 
       

      类型通配声明 例子 
       

      类型通配的方式 
       

      • "?"代表任意一个类型 
       

      1. class Animal
      2. {
      3. 	
      4. }
      5.  
      6. class Dog extends Animal
      7. {
      8. 	
      9. }
      10.  
      11.  
      12. class Cls1
      13. {
      14. 	T a;
      15. 	
      16. 	public Cls1(T a){
      17. 		this.a = a;
      18. 	}
      19. 	
      20. 	public T getData(){
      21. 		return a;
      22. 	}
      23. } 
      24.  
      25. public class Test {
      26. 	public static void main(String[] args) {
      27. 		Cls1 c1 = new Cls1(10);
      28. 		Cls1 c2 = new Cls1(10.0);
      29. 		Cls1 c3;
      30. 		
      31. 		c3 = c1;
      32. 		c3 = c2;
      33. 	}
      34. }
       

      • 和限制泛型的上限相似，同样可以使用extends关键字限定通配符匹配类型的上限 
       

      1. class Animal
      2. {
      3. 	
      4. }
      5.  
      6. class Dog extends Animal
      7. {
      8. 	
      9. }
      10.  
      11.  
      12. class Cls1
      13. {
      14. 	T a;
      15. 	
      16. 	public Cls1(T a){
      17. 		this.a = a;
      18. 	}
      19. 	
      20. 	public T getData(){
      21. 		return a;
      22. 	}
      23. } 
      24.  
      25. public class Test {
      26. 	public static void main(String[] args) {
      27. 		Cls1 c1 = new Cls1(new Dog());
      28. 		Cls1 c2;
      29. 		
      30. 		c2 = c1;
      31. 	}
      32. }
       

      • 还可以使用super关键词限定通配符匹配类型的下限
       

      1. class Animal
      2. {
      3. 	
      4. }
      5.  
      6. class Dog extends Animal
      7. {
      8. 	
      9. }
      10.  
      11.  
      12. class Cls1
      13. {
      14. 	T a;
      15. 	
      16. 	public Cls1(T a){
      17. 		this.a = a;
      18. 	}
      19. 	
      20. 	public T getData(){
      21. 		return a;
      22. 	}
      23. } 
      24.  
      25. public class Test {
      26. 	public static void main(String[] args) {
      27. 		Cls1 c1 = new Cls1(new Dog());
      28. 		Cls1 c2;
      29. 		//Cls1 c1 = new Cls1(new Dog());
      30. 		//Cls1 c2;
      31. 		c2 = c1;
      32. 	}
      33. }
       

      五、泛型方法 
       

      • 不仅类可以声明泛型，类中的方法也可以声明仅用于自身的泛型，这种方法叫做泛型方法。其定义格式为：
       

      1. 访问修饰符 <泛型列表> 返回类型 方法名(参数列表){
      2.     实现代码
      3. }
       

      • 在泛型列表中声明的泛型，可用于该方法的返回类型声明、参数类型声明和方法代码中的局部变量的类型声明。
      • 类中的其他方法不能使用当前方法声明的泛型。
       

      提示： 是否拥有泛型方法与其所在的类是否泛型没有关系。要定义泛型方法，只需将泛型参数列表置于返回值前。
       

      1. class A
      2. {
      3. 	public void printInfo(T t){
      4. 		System.out.println(t);
      5. 	}
      6. }
      7.  
      8. class B
      9. {
      10. 	public  void printInfo(T t){
      11. 		System.out.println(t);
      12. 	}
      13. }
      14.  
      15. public class Test {
      16. 	public static void main(String[] args) {
      17. 		A a = new A();
      18. 		a.printInfo("ajie");//此泛型中的方法参数类型被类的泛型类型限制住
      19. 		
      20. 		B b = new B();
      21. 		b.printInfo("ajiezaixian");//泛型方法不应该被类的泛型类型限制住
      22. 		b.printInfo(1234);
      23. 		b.printInfo(0.5);
      24. 	}
      25. }
       

      运行结果：
       

       
 
      ajie
       ajiezaixian
       1234
       0.5 
       

       

      1. class A
      2. {
      3. 	public void printInfo(T t){
      4. 		System.out.println(t);
      5. 	}
      6. }
      7.  
      8. class B
      9. {
      10. 	//泛型方法
      11. 	public  void printInfo(T t){
      12. 		System.out.println(t);
      13. 	}
      14. 	//泛型方法的重载
      15. 	public  void printInfo(T t,T2 t2){
      16. 		System.out.println(t);
      17. 		System.out.println(t2);
      18. 		//System.out.println(t+t2);会报错 只有实例化确定类型后才让加 跟我们之前遇到的要区分开
      19. 	}
      20. }
      21.  
      22. public class Test {
      23. 	public static void main(String[] args) {
      24. 		A a = new A();
      25. 		a.printInfo("ajie");//此泛型中的方法参数类型被类的泛型类型限制住
      26. 		
      27. 		B b = new B();
      28. 		b.printInfo("ajiezaixian");//泛型方法不应该被类的泛型类型限制住
      29. 		b.printInfo(1234);
      30. 		b.printInfo(0.5);//比方法重载好用多了
      31. 		
      32. 		b.printInfo("ajie", "这是泛型方法的重载");
      33. 	}
      34. }
       

      运行结果
       

       
 
       ajie
       ajiezaixian
       1234
       0.5
       ajie
       这是泛型方法的重载
       

       

      什么时候使用泛型方法，而不是泛型类呢？
       

      添加类型约束只作用于一个方法的多个参数之间、而不涉及到类中的其他方法时。
       

      施加类型约束的方法为静态方法，只能将其定义为泛型方法，因为静态方法不能使用其所在类的类型参数。 
       

      1. class Animal
      2. {
      3. 	public void eat(){
      4. 		System.out.println("动物吃");
      5. 	}
      6. }
      7.  
      8. class Dog extends Animal
      9. {
      10. 	public void eat(){
      11. 		System.out.println("啃骨头");
      12. 	}
      13. }
      14.  
      15. class Cat extends Animal
      16. {
      17. 	public void eat(){
      18. 		System.out.println("吃鱼肉");
      19. 	}
      20. }
      21.  
      22. class B
      23. {
      24. 	//泛型方法
      25. 	public  void printInfo(T t){
      26. 		System.out.println(t);
      27. 	}
      28. 	
      29. 	public static void printInfo(T t){
      30. 		t.eat();
      31. 	}
      32. }
      33.  
      34. public class Test {
      35. 	public static void main(String[] args) {		
      36. 		B b = new B();		
      37. 		b.printInfo(new Dog());
      38. 		b.printInfo(new Cat());
      39. 		b.printInfo(new Animal());
      40. 		B.printInfo(new Dog());
      41. 	}
      42. }
       

      运行结果：
       

       
 
      啃骨头
       吃鱼肉
       动物吃
       啃骨头 
       

      
                
                    
                

                
    7. 

                    相关阅读:
      
                    
Go并发可视化解释 - sync.WaitGroup                            
      
【js】JavaScript清除所有（多个）定时器的方法：                            
      
电子科大软件系统架构设计——系统规划                            
      
React ts学习重点（组件状态，Hooks，路由）                            
      
分布式消息通信之Kafka的实现原理                            
      
实战SpringMVC之CRUD                            
      
软件性能瓶颈问题之数据库性能问题定位                            
      
来看看火爆全网的ChatGPT机器人写的武侠小说，我直呼内行！                            
      
4-1 张量的结构操作                            
      
使用 Docker 部署 instantbox 轻量级 Linux 系统                            
      
                          
                
      8. 
                
    8. 
                    原文地址：https://blog.csdn.net/weixin_50546241/article/details/126891863
                
      9.