Java学习笔记————泛型程序设计
2012-11-26 21:59
295 查看
1. 泛型程序设计
1.1 泛型的引出
要求设计一个可以表示坐标的类(X,Y)但是此坐标要可以同时满足以下三种集中要求:·X=10、Y=100 ·X=10.3、Y=50.2 ·X=”东经180°”、Y=”北纬210°”
分析:
因为现在的程序中需要接受三种数据类型的数据,所以呢为了保证程序的正确性,最好使用Object类完成,因为Object可以接受任意的引用数据类型:
·数字 à 自动装箱操作 à Object ·字符串 à Object
按照以上的特点,完成程序:
class Point { private Object x; private Object y; public Object getX() { return x; } public void setX(Object x) { this.x = x; } public Object getY() { return y; } public void setY(Object y) { this.y = y; } } |
public class GenDemo01 { public static void main(String[] args) { Point p = new Point(); p.setX(10); // 设置坐标。int --> Integer --> Object p.setY(10);// 设置坐标。int --> Integer --> Object int x = (Integer)p.getX() ; // 取出X:Object --> Integer --> int int y = (Integer)p.getY() ; // 取出X:Object --> Float --> float System.out.println("x = " + x); System.out.println("y = " + y); } } |
public class GenDemo02 { public static void main(String[] args) { Point p = new Point(); p.setX(10.3f); // 设置坐标。float --> Float --> Object p.setY(10.6f);// 设置坐标。float --> Float --> Object float x = (Float)p.getX() ; // 取出X:Object --> Float --> float float y = (Float)p.getY() ; // 取出X:Object --> Float --> float System.out.println("x = " + x); System.out.println("y = " + y); } } |
public class GenDemo03 { public static void main(String[] args) { Point p = new Point(); p.setX("东经120度"); // 设置坐标。String --> Object p.setY("北纬230度");// 设置坐标。String --> Object String x = (String)p.getX() ; // 取出X:Object --> String String y = (String)p.getY() ; // 取出X:Object --> String System.out.println("x = " + x); System.out.println("y = " + y); } } |
在此操作之中,可以发现所有的内容都是Object进行操作的,那么就意味着,可以设置任意的类型,即:X可以使整型,Y可以使字符串类型。
public class GenDemo04 { public static void main(String[] args) { Point p = new Point(); p.setX(10); // 设置坐标。int --> Integer --> Object p.setY("北纬230度");// 设置坐标。int --> Integer --> Object int x = (Integer)p.getX() ; // 取出X:Object --> Integer --> int int y = (Integer)p.getY() ; // 取出X:Object --> Float --> float System.out.println("x = " + x); System.out.println("y = " + y); } } |
Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer at com.java.genericsdemo01.GenDemo04.main(GenDemo04.java:20) |
但是从之前所学过的全部代码来看,此处孩子能应用到这里了。没有更好的方法了
1.2 泛型<1>基础知识
JDK 1.5 之后出现了新的技术 —— 泛型,此技术的最大特点就是类中的属性的类型可以由外部决定,而且声明的时候应该采取如下形式:class 类名称 <泛型类型,泛型类型,……>{ } |
package com.java.genericsdemo02; public class Point<T> { // 表示坐标类 private T x; // X 的属性类型有外部决定 private T y; // Y 的属性类型由外部决定 public T getX() { return x; } public void setX(T x) { this.x = x; } public T getY() { return y; } public void setY(T y) { this.y = y; } } |
package com.java.genericsdemo02; public class GenDemo05 { public static void main(String[] args) { Point<Integer> p = new Point<Integer>(); p.setX(10); // 设置坐标。int --> Integer --> Object p.setY(20);// 设置坐标。int --> Integer --> Object System.out.println("x = " + p.getX()); System.out.println("y = " + p.getY()); } } |
而且,使用上面的操作有一点点最方便之处,如果此时设置的内容不是整型,那么程序中将出现错误。
package com.java.genericsdemo02; public class GenDemo06 { public static void main(String[] args) { Point<Integer> p = new Point<Integer>(); p.setX(10); // 设置坐标。int --> Integer --> Object p.setY[1]("北纬230度");// 设置坐标。int --> Integer --> Object System.out.println("x = " + p.getX()); System.out.println("y = " + p.getY()); } } |
1.3 泛型<2>注意点
在使用泛型操作的时候,实际上有很多小的注意点,例如:构造方法上依然可以使用泛型或者有一种可以成为泛型的擦除。1.3.1 在构造方法上引用泛型
一般在开发中,经常使用造方法设置属性的内容,那么此时实际上依然可以使用泛型的类型。package com.java.demo03; public class Point<T> { private T x; private T y; public Point(T x, T y) { this.setX(x); this.setY(y); } public T getX() { return x; } public void setX(T x) { this.x = x; } public T getY() { return y; } public void setY(T y) { this.y = y; } } |
package com.java.demo03; public class GenDemo07 { public static void main(String[] args) { Point<Integer> p = new Point<Integer>(10, 20); int x = p.getX(); int y = p.getY(); System.out.println("x = " + x); System.out.println("y = " + y); } } |
1.3.2 擦除泛型
如果在使用的时候没有指定泛型类型的话,则表示擦除泛型类型。泛型一旦擦除之后,就按照Object进行接收,以保证程序不发生任何错误。
package com.java.demo03; public class GenDemo08 { public static void main(String[] args) { Point p = new Point(10, 20); int x = (Integer) p.getX(); int y = (Integer) p.getY(); System.out.println("x = " + x); System.out.println("y = " + y); } } |
package com.java.demo03; public class GenDemo08 { public static void main(String[] args) { Point<Object> p = new Point<Object>(10, 20); int x = (Integer) p.getX(); int y = (Integer) p.getY(); System.out.println("x = " + x); System.out.println("y = " + y); } } |
1.4 通配符
在泛型的操作中通配符的使用较多,而且在日后的系统类库中有很多地方都要使用这些操作例如,现在又如下代码:
package com.java.demo04; public class Test { public static void main(String[] args) { Object obj ="Hello World!!!"; } } |
1.4.1 ?
在进行对象转型的时候可以使用自动的向上转型,但是在使用泛型的时候却没有此种操作。package com.java.demo04; public class Point<T> { private T x; private T y; public T getX() { return x; } public void setX(T x) { this.x = x; } public T getY() { return y; } public void setY(T y) { this.y = y; } } |
package com.java.demo04; public class GenDemo09 { public static void main(String[] args) { Point<Object> p1 = new Point<Object>(); Point<Integer> p2 = new Point<Integer>(); p1 = p2; // 此时根本无法进行转换。 } } |
例如:将“Point<Object> p1 = new Point<Object>();”表示为商场的全部商品,而“Point<Integer> p2 = new Point<Integer>();”表示每一个顾客购买的商品,如果现在执行“p1 = p2;”那么就意味着,此顾客所购买的商品就是商场的全部商品,这样肯定说不通,所以说不能接收。
不能使用以上的方式接收最大的影响在于方法的参数接收。
package com.java.demo04; public class GenDemo10 { public static void main(String[] args) { Point<Object> p1 = new Point<Object>(); Point<Integer> p2 = new Point<Integer>(); fun(p1); fun(p2); } public static void fun(Point point){ // 表示此时可以接受任意的类型。 System.out.println(point.getX()); System.out.println(point.getY()); } } |
package com.java.demo04; public class GenDemo10 { public static void main(String[] args) { Point<Object> p1 = new Point<Object>(); Point<Integer> p2 = new Point<Integer>(); fun(p1); fun(p2); } public static void fun(Point<?> point){ // 表示此时可以接受任意的类型。 System.out.println(point.getX()); System.out.println(point.getY()); } } |
1.4.2 泛型的上限
上限就是指一个操作泛型的最大的操作父类,例如,现在最大的上限设置成“Number”那么此时,所能够就收的类型只能是Number及其子类(Integer)。泛型上限通过以下语法完成:
? extends 类 |
package com.java.demo05; public class Point<T extends Number> { // 最高只能是Number类型。 private T x; private T y; public T getX() { return x; } public void setX(T x) { this.x = x; } public T getY() { return y; } public void setY(T y) { this.y = y; } } |
package com.java.demo05; public class GemDemo11 { public static void main(String[] args) { Point<Integer> p1 = new Point<Integer>(); // 设置的是Number的子类。 } } |
package com.java.demo05; public class GemDemo12 { public static void main(String[] args) { Point<String> p1 = new Point<String>(); // 设置的是Number的子类。 } } | |
|
package com.java.demo05; public class GenDemo13 { public static void main(String[] args) { Point<Integer> p2 = new Point<Integer>(); fun(p2); } public static void fun(Point<? extends Number> point){ //此时可以接受Number的子类。 System.out.println(point.getX()); System.out.println(point.getY()); } } |
1.4.3 泛型的下限
泛型的下限指的是只能设置其具体的类或者父类,设置语法如下:? super 类 |
package com.java.demo06; public class Point<T> { private T x; private T y; public T getX() { return x; } public void setX(T x) { this.x = x; } public T getY() { return y; } public void setY(T y) { this.y = y; } } |
package com.java.demo06; public class GenDemo14 { public static void main(String[] args) { Point<String> p1 = new Point<String>(); Point<Object> p2 = new Point<Object>(); fun(p1); fun(p2); } public static void fun(Point<? super String> point){ System.out.println(point.getX()); System.out.println(point.getY()); } } |
1.5 泛型接口
泛型不管可以在类上使用,还可以在接口中进行定义。操作的语法如下:Interface 类口名称<泛型类型,泛型类型,…>{} |
package com.java.demo07; public interface Demo<T> { // 定义泛型接口。 public void print(T param); // 此抽象方法中使用了泛型类型 } |
范例:第一种实现手段
package com.java.demo07; public class DemoImpl01<T> implements Demo<T> { public void print(T param) { System.out.println("Param = " + param); } } |
package com.java.demo07; public class GenDemo15 { public static void main(String[] args) { Demo<String> demo = new DemoImpl01<String>(); demo.print("Hello"); } } |
package com.java.demo07; public class DemoImpl02 implements Demo<DemoImpl02> { // 设置具体类型 public void print(DemoImpl02 param) { System.out.println("Param = " + param); } } |
package com.java.demo07; public class GenDemo16 { public static void main(String[] args) { Demo<DemoImpl02> demo = new DemoImpl02(); demo.print(new DemoImpl02()); } } |
1.6 泛型方法
泛型除了可以再类中定义之外,还可以在方法中定义,而且在方法上使用泛型,此方法所在的类不一定是泛型的操作。package com.java.demo08; public class Demo { public <T> T print(T param){ // 定义泛型方法 return param; } } |
package com.java.demo08; public class GenDemo17 { public static void main(String[] args) { Demo demo = new Demo(); System.out.println(demo.print(1)); } } |
package com.java.demo08; public class GenDemo18 { public static void main(String[] args) { Integer i[] = fun(1, 2, 3, 4, 5, 6, 7, 8, 9); for(int x : i){ System.out.print(x + "\t"); } } public static <T> T[] fun(T... param) { return param; // 返回数组 } } |
1.7 泛型的嵌套操作
现在只是突出语法,具体操作的意义要等到后面学习到类库才能够更加明白。package com.java.demo09; public class Info<T> { private T param; public T getParam() { return param; } public void setParam(T param) { this.param = param; } } |
package com.java.demo09; public class Person<T> { private T info; public T getInfo() { return info; } public void setInfo(T info) { this.info = info; } } |
package com.java.demo09; public class Test { public static void main(String[] args) { Person<Info<String>> person = new Person<Info<String>>(); person.setInfo(new Info<String>()); person.getInfo().setParam("Hello World!!!"); System.out.println(person.getInfo().getParam()); } } |
1.8 泛型的操作范例
现在有如下的题目要求:要求设计一个程序,定义一个Person类,Person类中药存放具体的信息,但是信息分为基本信息或者联系方式等等,那么此时该如何设计呢?
此时最好的设计就是需要定义一个好事信息的操作标准,但是此时这个标准肯定使用接口实现,但是现在接口中并不编写任何的操作。
package com.java.demo10; public interface Info { } |
package com.java.demo10; public class Person<T extends Info> { private T info; public T getInfo() { return info; } public void setInfo(T info) { this.info = info; } } |
package com.java.demo10; public class Basic implements Info { private String name; private int age; public Basic() { super(); } public Basic(String name, int age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String toString() { return "人的信息:" + "\n\t|-姓名:" + this.getName() + "\n\t|-年龄:" + this.getAge(); } } |
package com.java.demo10; public class Contact implements Info { private String address; private String zipcode; public Contact() { super(); } public Contact(String address, String zipcode) { super(); this.address = address; this.zipcode = zipcode; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } public String getZipcode() { return zipcode; } public void setZipcode(String zipcode) { this.zipcode = zipcode; } public String toString() { return "联系信息:" + "\n\t|-家庭住址:" + this.getAddress() + "\n\t|-邮政编码:" + this.getZipcode(); } } |
package com.java.demo10; public class TestPerson01 { public static void main(String[] args) { Person<Basic> person = new Person<Basic>(); person.setInfo(new Basic("张三", 30)); System.out.println(person.getInfo()); } } |
package com.java.demo10; public class TestPerson02 { public static void main(String[] args) { Person<Contact> person = new Person<Contact>(); person.setInfo(new Contact("开封市", "475001")); System.out.println(person.getInfo()); } } |
[1] 下划线表示有错误出现
相关文章推荐
- Java学习笔记【泛型程序设计】
- java学习笔记---第13章泛型程序设计
- Bravo!Java学习笔记(2)---泛型程序设计
- [学习笔记] Java核心技术 卷一:基础知识 泛型程序设计(五)
- JAVA学习笔记之泛型接口
- java学习笔记——泛型Generic
- java基础学习笔记之泛型
- Java学习笔记----事件驱动程序设计
- java学习笔记00_泛型的(完成)
- 学习笔记之Java程序设计实用教程
- 【Java学习笔记】36:泛型的类型变量的限定
- java 泛型学习笔记(一)
- java 学习笔记--利用反射实现泛型数组的复制
- Java学习笔记-Java程序设计环境(Windows)
- Java学习笔记之泛型
- 学习笔记:Java中的泛型
- Java基础学习笔记【08】泛型限定、泛型操作
- Java核心技术(第8版)学习笔记_Java程序设计环境
- Java学习笔记(泛型)
- java—学习笔记(java语言程序设计基础篇&java程序设计)