Java学习第十四天之泛型概念-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_57944115/article/details/127448618

本文深入浅出地讲解了Java泛型的基础概念，包括类和接口的泛型实例、类型参数的使用、泛型类的特点、继承与接口实现，以及泛型方法和通配符的运用。通过实例演示，展示了如何限制泛型类型并理解通配符在类型兼容中的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

问题引入：

问题解决：

范例:

package 泛型;

class Cls{
	Object  a;
	public Cls(Object  a)
	{
		 this.a = a;
	}
	public Object  Get()
	{
	      return a;
	}
}
/*class Cls1
{
	String  a;
	public Cls1(String  a)
	{
		 this.a=a;
	}
	public String Get()
	{
	      return a;
	}
}*/
public class Test {
public static void main(String[] args) {
	Cls C= new Cls(200);
	System.out.println(C.Get());
	Cls cls1 = new Cls("什么时候才能变强");
	System.out.println(cls1.Get());
	
}
}

输出结果:

200
什么时候才能变强

一、泛型简介 JDK1.5以后引入

泛型类:

例子：

范例:

package 泛型;
class Maker <T>
{
	 T  a ;
	 public void Make(T a)
	 {
		  this.a=a;
	 }
	 public T Get(T a)
	 {
         return a;
 	 }	 
}
public class Test1 {
public static void main(String[] args) {
	    Maker <String> M = new Maker <String>();
	    System.out.println(M.Get("你的体重是:"));
	    Maker <Integer> C = new Maker <Integer> ();
	    System.out.println(C.Get(127));    
	    
}
}

输出结果:

你的体重是:
127
二、泛型类及特点

1. 类型参数是泛型

范例:

package 泛型;
class TT <T> 
{
	T x;
	public TT (T x)
	{
		 this.x=x;
	}
	public T Get()
	{
		return x; 
	}
}



//在同一个包下不要定义同样的类名称

public class Extends {
public static void main(String[] args) {
	   TT<TT<Integer>> E = new TT<TT<Integer>>(new TT<Integer> (10));
	   System.out.println(E.Get().Get());
	   
}
}

输出结果:

2. 同时设定多个类型参数

范例:

package 泛型;

class  People <T1,T2>
{
	 T1 a;
	 T2 b;
	 public void Receive(T1 a, T2 b)
	 {
		 this.a=a;
		 this.b=b;
	 }
	 public T1 Geta(T1 a)
	 {
		 return a;
	 }
	 public T2 Getb(T2 b)
	 {
		 return b;
	 }
}
public class Characterstic {
public static void main(String[] args) {
	  People <Integer,Integer> P = new People <Integer,Integer>();
	  System.out.println(P.Geta(100));
	  System.out.println(P.Getb(10));
	  System.out.println(P.Geta(101)+P.Getb(101));
	  People <String,String> P1 = new People <String,String>();
	  System.out.println(P1.Geta("努力才能变强! ")+P1.Getb("加油吧!"));
}
}

输出结果:

100
10
202
努力才能变强! 加油吧!

3. 泛型类继承

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

范例：

package 泛型;

class TT <T> 
{
	T x;
	public TT (T x)
	{
		 this.x=x;
	}
	public T Get()
	{
		return x; 
	}
}
interface Cs <T>
{
	 public void myPrintf(T t);
}
class XX <T,T1>extends TT <T> implements Cs<T>
{

	T1 y;
	public XX(T x,T1 y) {
		super(x);
		this.y=y;
	}
	public T1 Gety()
	{
		return y;
	}
	@Override
	public void myPrintf(T t) {
		// TODO Auto-generated method stub
		System.out.println("少刷抖音多刷题!");
		System.out.println(""+t);
		
	}
}



//在同一个包下不要定义同样的类名称

public class Extends {
public static void main(String[] args) {
	  // TT<TT<Integer>> E = new TT<TT<Integer>>(new TT<Integer> (10));
	   //System.out.println(E.Get().Get());
	    XX<String,String> Z = new XX<String,String>("抖音 ","记录美好生活");
	    System.out.println(Z.Get()+Z.Gety());
	    Z.myPrintf("下班!");
}
}

输出结果

抖音记录美好生活
少刷抖音多刷题!
下班!

三、限制泛型可用类型

范例：

package 泛型;




class Make
{
	
}
class Mk extends Make
{
	       
}
interface Move
{
	   abstract void ttrs(); 
}
class TT <T  extends Make> //使用接口 Move的话 不能用implements不然会报错 还是要用extends
{
	T x;
	public TT (T x)
	{
		 this.x=x;
	}
	public T Get()
	{
		return x; 
	}
}
interface Cs <T>
{
	 public void myPrintf(T t);
}
class XX <T extends Make,T1>extends TT <T> implements Cs<T>
{

	T1 y;
	public XX(T x,T1 y) {
		super(x);
		this.y=y;
	}
	public T1 Gety()
	{
		return y;
	}
	@Override
	public void myPrintf(T t) {
		// TODO Auto-generated method stub
		System.out.println("少刷抖音多刷题!");
		System.out.println(""+t);
		
	}
}



//在同一个包下不要定义同样的类名称

public class Extends {
public static void main(String[] args) {
	  // TT<TT<Integer>> E = new TT<TT<Integer>>(new TT<Integer> (10));
	   //System.out.println(E.Get().Get());
	    XX<Mk,String> Z = new XX<Mk ,String>(new Mk(),"记录美好生活");
	    System.out.println(Z.Get()+Z.Gety());
	    
}
}

输出结果：

泛型.Mk@33833882记录美好生活

类型通配声明：

范例：

package 泛型通配方式;

class Maker
{
	  
}
class Manufacturer extends Maker
{
	
}
class Make <T,T1>
{ 
	private T x;
	private T1 y;
	public Make(T x, T1 y)
	{
		 this.x = x; 
		 this.y = y;
	}
	public T Getx()
	{
		 return x;
	}
	public T1 Gety()
	{
		 return y;
	}
	 
}
public class Test {
public static void main(String[] args) {
      Make<Integer,Integer> M1 = new Make<Integer,Integer>(10,100);
      Make<Double,Double> M2 = new Make<Double,Double>(10.0,100.11);
      M1=M2;
      
      
}
}

输出结果

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Type mismatch: cannot convert from Make<Double,Double> to Make<Integer,Integer>

	at 泛型通配方式.Test.main(Test.java:34)

public class Test {
public static void main(String[] args) {
      Make<Integer,Integer> M1 = new Make<Integer,Integer>(10,100);
      Make<Double,Double> M2 = new Make<Double,Double>(10.0,100.11);
      Make<Object,String> M3 =  new Make<Object,String>( "asa","dasa");
      M2 = M3;
      M1 = M3;
      M1 = M2;   
   }
}

输出结果：

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
	Type mismatch: cannot convert from Make<Object,String> to Make<Double,Double>
	Type mismatch: cannot convert from Make<Object,String> to Make<Integer,Integer>
	Type mismatch: cannot convert from Make<Double,Double> to Make<Integer,Integer>

	at 泛型通配方式.Test.main(Test.java:35)

三、限制泛型可用类型

范例：

package 泛型通配方式;

class Maker
{
	  
}
class Manufacturer extends Maker
{
	
}
class Make <T,T1>
{ 
	private T x;
	private T1 y;
	public Make(T x, T1 y)
	{
		 this.x = x; 
		 this.y = y;
	}
	public T Getx()
	{
		 return x;
	}
	public T1 Gety()
	{
		 return y;
	}
	 
}
public class Test {
public static void main(String[] args) {
      Make<Integer,Integer> M1 = new Make<Integer,Integer>(10,100);
      Make<Double,Double> M2 = new Make<Double,Double>(10.0,100.11);
      //Make<Object,String> M3 =  new Make<Object,String>( "asa","dasa");
     // M2 = M3;
      //M1 = M3;
      //M1 = M2;
      Make<?,?> M3;
      M3 = M1;
      System.out.println( M3.Getx());
      System.out.println(M3.Gety());
      int sum=0;
      sum= M1.Getx()+M1.Gety();
      //sum=M3.Getx()+M3.Gety();此时会报错;
      System.out.println(""+sum);

输出结果：

10
100
110

五、泛型方法

例子：

范例：

package 泛型方法;

class Test <T>
{
	 public <T> void printMy(T t)
	 {
		 System.out.println(t);
	 }
	 public void printOther(T t)
	 {
		    System.out.println(t);
	 }  
}

public class Method {
public static void main(String[] args) {
	Test TT = new Test();
	TT.printMy(185.5);
	TT.printMy("大帅比");
	TT.printMy("有车有房");
	TT.printMy("100分");
	Test<String> T1 = new Test<String>();
	T1.printOther("真的帅");
	
	
	
}
}

输出结果：

185.5
大帅比
有车有房
100分
真的帅

限定例子：

范例：

package 泛型方法限定;
class Makers 
{
	  public void Make( )
	  {
		   System.out.println("造一台车");
	  }
}
class Rr extends Makers
{
	 public void Make()
	 {
		 System.out.println("造一台劳斯莱斯古斯特");
	 }
}
class Bb extends Makers
{
	  public void Make()
	  {
		   System.out.println("造一台劳斯莱斯库里南BB版");
	  }
}
class Demo <T>
{
	public static <T  extends Makers> void Printf(T t)
	{
		  t.Make();
	}
}

public class RS {
public static void main(String[] args) {
	   Demo D = new Demo();
	   D.Printf(new Makers());
	   D.Printf(new Rr());
	   D.Printf(new Bb());
	   
}
}

输出结果：

造一台车
造一台劳斯莱斯古斯特
造一台劳斯莱斯库里南BB版