泛型类,泛型方法,泛型接口

泛型类：在没有泛型之前，定义一个操作对象的工具类是这样的

 1 public class Tools {

 2     public static void main(String[] args) {

 3         Tool t = new Tool();

 4         t.setWorker(new Worker());

 5         t.getWorker();

 6     }

 7 }

 8 class Tool{

 9     private Worker w;

10     public void setWorker(Worker w){

11         this.w = w;

12     }

13     public Worker getWorker(){

14         return w;

15     }

16 }

17 class Worker{

18     

19 }

20 

21 class Student{

22     

23 }

但是这样很麻烦每定义一个类就要定义一个操作类的工具，所以就优化成（泛型出现之前的做法）：不管传的是什么对象都能接受，就不用每定义一个类就要定义一个操作类的工具了

 1 public class Tools {

 2     public static void main(String[] args) {

 3         Tool t = new Tool();

 4         t.setObject(new Worker());

 5         Worker w = (Worker)t.getObject();

 6     }

 7 }

 8 class Tool{

 9     private Object obj;

10     public void setObject(Object obj){

11         this.obj = obj;

12     }

13     public Object getObject(){

14         return obj;

15     }

16 }

17 class Worker{

18     

19 }

20 

21 class Student{

22     

23 }

 

 泛型出现后的做法,定义一个泛型类,将错误转移到编译时期，当类中要操作的引用数据类型不确定的时候就用泛型类，早期定义Object来完成扩展现在定义泛型类来完成

 1 public class GenericDefineDemo {

 2     public static void main(String[] args) {

 3         Utils<Worker> u = new Utils<Worker>();

 4         u.setObject(new Worker());

 5         Worker w = u.getObject();

 6     }

 7 }

 8 class Utils<QQ>{

 9     private QQ q;

10     public void setObject(QQ q){

11         this.q = q;

12     }

13     public QQ getObject(){

14         return q;

15     }

16 }

17 class Worker{

18     

19 }

20 

21 class Student{

22     

23 }

 

 

泛型方法：泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了.为了让不同方法可以操作不同类型，而且类型还不确定那么可以将泛型定义在方法上

 1 public class GenericFactionDemo1 {

 2     public static void main(String[] args) {

 3         Demo<String> d = new Demo<String>();

 4         d.show("huangjianfeng");

 5         d.print("haungjianfei");

 6         //d.print(new Integer(4));//报错，该类的类型在创建该类对象的时候已经确定了

 7     }

 8 

 9 }

10 class Demo<T>{

11     public void show(T t){

12         System.out.println("show:"+t);

13     }

14     public void print(T t){

15         System.out.println("print:"+t);

16     }

17 }

 

 1 public class GenericFactionDemo1 {

 2     public static void main(String[] args) {

 3         Demo  d = new Demo();

 4         d.show(new Integer(4));

 5         d.show("huangjiafnds");

 6     }

 7 

 8 }

 9 class Demo{

10     public <T> void show(T t){

11         System.out.println("show:"+t);

12     }

13     public <Q> void print(Q q){

14         System.out.println("print:"+q);

15     }

16 }

可以将泛型定义在类中又可以将泛型定义在类中的部分方法上，这样没有定义泛型的方法，跟着类中的类型，定义了泛型的方法可以随意类型

静态方法不可以访问类上定义的泛型，如果静态方法操作的引用数据类型不确定，可以将泛型定义在静态方法中

 1 public class GenericFactionDemo2 {

 2     public static void main(String[] args) {

 3         Demo<String> d = new Demo<String>();

 4         d.show("huangjianfeng");

 5         //d.show(new Integer(3));编译错误，show方法随着类的泛型，类型已经确定了

 6         d.print("haungjianfei");//可以传任意的类型，因为该方法上定义了泛型

 7     }

 8 }

 9 class Demo<T>{

10     public void show(T t){

11         System.out.println("show:"+t);

12     }

13     public <Q> void print(Q q){

14         System.out.println("print:"+q);

15     }

16     public static <w> void method(w t){

17         System.out.println("method:"+t);

18     }

19 }

 

 

泛型接口：

 1 public class GenericInterfaceDemo {

 2     public static void main(String[] args) {

 3         InterImpl i = new InterImpl();

 4         i.show("huangjianfei");

 5     }

 6 }

 7 //泛型定义在接口上

 8 interface Inter<T>{

 9     void show(T t);

10 }

11 class InterImpl implements Inter<String>{

12     public void show(String t){

13         System.out.println("show:"+t);

14     }

15 }

 

 1 public class GenericInterfaceDemo {

 2     public static void main(String[] args) {

 3         InterImpl<Integer> i = new InterImpl<Integer>();

 4         i.show(4);

 5     }

 6 }

 7 interface Inter<T>{

 8     void show(T t);

 9 }

10 class InterImpl<T> implements Inter<T>{

11     public void show(T t){

12         System.out.println("show:"+t);

13     }

14 }