java 工程模式 构建泛型 java泛型构造函数

今天学习了泛型的相关知识，笔记记录如下，与大家分享：

 

泛型：JDK 1.5 之后增加的新功能，最初Java是把C++中的泛型摒弃掉的，后来由于很多开发者提议要使用，后来又加回来了~ 

泛型，可以解决数据类型的安全性问题；
原理：在类声明的时候，通过一个标识，表示类中某个属性的类型；
         或者是某个方法的返回值及参数类型；
格式：
访问权限 class 类名称<泛型，泛型>{
属性
方法()
}

对象的创建：
类名称<具体类型> 对象名称 = new 类名称<具体类型>

class Point<T>{// T 代表泛类型，可以严格指定传入的参数类型
// 避免产生原因不明的错误
private T x;
private T y;
}

1、构造方法使用泛型：
　　构造方法可以为类中的属性初始化，如果类中的属性通过泛型指定，
　　而又需要通过构造方法设置属性内容的时候，那么构造方法的定义与之前并
　　无不同，不需要像声明类那样，指定泛型；

 

1. /* 
2.  * 经纬度 
3.  * int 
4.  * float 
5.  * String 
6.  *  
7.  * 定义 Object类型。创建 set 和 get 方法      Source——Genterator Getters Setters 
8.  *  
9.  */  
10. class Point<T>{           // T 代表泛类型，可以严格指定传入的参数类型  
11. private T x;  
12. private T y;  
13. public Object getX() {  
14. return x;  
15.     }  
16. public void setX(T x) {  
17. this.x = x;  
18.     }  
19. public Object getY() {  
20. return y;  
21.     }  
22. public void setY(T y) {  
23. this.y = y;  
24.     }  
25. }  
26.   
27. public class GenericDemo01 {  
28.   
29. public static void main(String[] args) {  
30.           
31. new Point<String>();  
32. "经度： 10");  
33. "维度： 20");  
34. "  "+pt.getY());  
35. /*      Point pc = new Point(); 
36.         pc.setX(10); //给Object X 传入10 
37.         pc.setY(10); 
38.         int px = (Integer)pc.getX();  // Integer拆箱、装箱,把 Object转为 int 
39.         int py = (Integer)pc.getY(); 
40.         System.out.println("x = " +px+"  \r"+"y = "+py);*/  
41.     }  
42. }

2、指定多个泛类型：

class Gen<T, K>{
private T toke;
private K key;
记住定义 get 和 set
}

1. class Con2<T>{        //定义泛型  
2. private T value;  
3. public Con2(T value) {  
4. this.value = value;  
5.     }  
6. public T getValue() {   //获取 实例化时，传入构造器的参数值  
7. return value;  
8.     }  
9. public void setValue(T value) {  
10. this.value = value;  
11.     }  
12. }  
13.   
14. public class GenericDemo02 {  
15.   
16. public static void main(String[] args) {  
17. new Con2<String>("这是构造方法的泛型用法！");//传入构造器的参数  
18.         System.out.println(c2.getValue());  
19.     }  
20. }

3、通配符的使用 
通配符： ？
格式：   Info<?> i
使用通配符可以让泛型匹配任何格式；

 

 

1. class Gen<T, K>{  //定义两个泛类型  
2. private T toke;  
3. private K key;  
4. public T getToke() {  
5. return toke;  
6.     }  
7. public void setToke(T toke) {  
8. this.toke = toke;  
9.     }  
10. public K getKey() {  
11. return key;  
12.     }  
13. public void setKey(K key) {  
14. this.key = key;  
15.     }  
16. }  
17.   
18. public class GenericDemo03 {  
19.   
20. public static void main(String[] args) {  
21. new Gen<String, Integer>();  
22. "T is String");  
23. 100);  
24. "Toke is:"+g.getToke()+"\rKey is:"+g.getKey());  
25.     }  
26. }

1. <span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">       </span>

 

4、泛型接口： 
JDK 1.5 之后，不仅仅可以声明泛型类，也可以声明接口，声明泛型类
和声明接口的语法类似，也是在接口名称后面加上<T>
  格式：
interface 接口名称<泛型标识> {
}
接口直接指定泛型的类型，然后子类继承泛型类型

 

1. <span style="font-size:18px;">interface GenInter<T>{ //泛型接口  
2. public void say();  
3. }  
4. // 创建子类  继承接口  
5. class Gin implements GenInter<String>{  // 继承泛型接口，直接指定String类型  
6. private String info;  
7. public Gin(String info){  
8. this.info = info;  
9.     }  
10. // 复写say()方法  
11. public void say(){  
12.     }  
13. //set get  
14. public String getInfo() {  
15. return info;  
16.     }  
17. public void setInfo(String info) {  
18. this.info = info;  
19.     }  
20. }  
21.   
22. public class GenericDemo05 {  
23. public static void main(String[] args) {  
24. new Gin("泛型类");     // 如果在类中没有指定String，而用<T>  
25. // 则需要在此指定  
26. // g.getInfo() 获取的是 泛型接口的指定类型  
27.     }  
28. }</span><span style="font-size:18px; font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span><span style="font-size:18px; font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">  </span>

 

5、泛型方法：

1、泛型方法中可以定义泛型参数
此时，参数的类型就是传入的数据类型
2、格式：
访问权限 <泛型标识> 泛型标识 方法名称([泛型标识 参数名称])

1. class Gener{  
2. // 创建 泛 型 方 法  
3. public <T>T tell(T t){  
4. return t;  
5.     }  
6. }  
7.   
8. public class GenericDemo06 {  
9.   
10. public static void main(String[] args) {  
11. new Gener();  
12. // 直接赋予 字符串  
13. "我是泛型打印的~");  //调用 泛型方法  
14.         System.out.println(s);  
15. // 泛型也可以直接赋予整形  
16. int i = g.tell(10);  // 泛型，可以传递任意数据类型给 泛型方法  
17.         System.out.println(i);  
18.     }  
19. }

6、泛型数组： GenericDemo07.java

需要和泛型方法搭配使用；

 

1、在使用泛型方法的时候，也可以传递或返回一个泛型数组

 

1. <span style="font-size:18px;">public class GenericDemo07 {  
2. // 泛型数组 需要配合 泛型方法， 所以定义一个泛型方法  
3. public static <T> void tell(T arr[]){  
4. //打印 泛型数组 每个元素  
5. for (int i = 0; i < arr.length; i++) {  
6. " ");  
7.         }  
8.     }  
9.   
10. public static void main(String[] args) {  
11. // 给数组赋值  
12. "asd","126","jack"};  
13. // 调用泛型方法  
14.         tell(arr);  
15.     }     
16. }</span>