目錄
泛型
class Test <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;
}
}
public class Point {
public static void main(String[] args) {
Test<String> t = new Test<>();
t.setX("東京");
t.setY("巴黎");
String x = t.getX();
String y = t.getY();
System.out.println("x=" + x + ",y="+y);
}
}
通配符
class Test <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;
}
}
public class Point {
public static void main(String[] args) {
Test<String> t = new Test<>();
t.setX("東京");
t.setY("巴黎");
fun(t);
}
//如果沒有設置類型，默認類型就是Object
public static void fun(Test t) {
t.setX(90);
System.out.println("t=" + t.getX());
}
}
輸出結果爲"t=90"，內容“東京”被隨意修改了。
在類型不確定的時候，但是又希望方法能接收所有類型，所以使用通配符”?“。通配符”?”能接收一切，但是不能修改。
class Test <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;
}
}
public class Point {
public static void main(String[] args) {
Test<String> t = new Test<>();
t.setX("東京");
t.setY("巴黎");
fun(t);
}
//此時使用的通配符“?”描述的是它可以接收任意類型，但是由於不確定類型，所以無法修改
public static void fun(Test<?> t) {
System.out.println("t=" + t.getX());
}
}
輸出結果爲”t=東京“。
通配符”？“的兩個子通配符：
- ？ extends 類：設置泛型上限
例：? extends Number：表示只能夠設置Number或其子類，例如: Integer、Double等；
- ？ super 類：設置泛型下限
例： ？ super String：表示只能夠設置String或其父類：Object
範例：設置泛型上限
class Test <T extends 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;
}
}
public class Point {
public static void main(String[] args) {
Test<Integer> t = new Test<>();
t.setX(1);
t.setY(2);
fun(t);
}
//此時使用的通配符“?”描述的是它可以接收任意類型，但是由於不確定類型，所以無法修改
public static void fun(Test<? extends Number> t) {
System.out.println("t=" + t.getX());
}
}
輸出結果：t=1。
範例：設置泛型下限
class Test <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;
}
}
public class Point {
public static void main(String[] args) {
Test<String> t = new Test<String>();
t.setX("Hello World!");
fun(t);
}
//此時使用的通配符“?”描述的是它可以接收任意類型，但是由於不確定類型，所以無法修改
public static void fun(Test<? super String> t) { //設置泛型下限
System.out.println("t=" + t.getX());
}
}
輸出結果爲：t=Hello World!
泛型接口
泛型既可以定義在類中，也可以定義在接口裏，這種情況稱爲泛型接口。
interface IMessage<T> { //在接口上定義了泛型
public void print(T t);
}
該接口的實現子類有兩種：
- 子類定義時繼續使用泛型
class MessageImpl<T> implements IMessage<T> {
@Override
public void print(T t) {
// TODO Auto-generated method stub
}
}
調用該方法：
interface IMessage<T> { //在接口上定義了泛型
public void print(T t);
}
class MessageImpl<T> implements IMessage<T> {
@Override
public void print(T t) {
System.out.println(t);
}
}
public class TestDemo {
public static void main(String[] args) {
IMessage<String> msg = new MessageImpl<String>();
msg.print("Hello World!");
}
}
輸出結果爲：Hello World!
- 子類實現接口時明確給出具體類型
class MessageImpl implements IMessage<String> {
@Override
public void print(String t) { //此處的參數自動被轉換爲String
// TODO Auto-generated method stub
}
}
調用該方法：
interface IMessage<T> { //在接口上定義了泛型
public void print(T t);
}
class MessageImpl implements IMessage<String> {
@Override
public void print(String t) {
System.out.println(t);
}
}
public class TestDemo {
public static void main(String[] args) {
IMessage<String> msg = new MessageImpl();
msg.print("Hello World!");
}
}
輸出結果：Hello World！
泛型方法
public class TestDemo {
public static void main(String[] args) {
Integer data[] = fun(1,2,3,4);
for(int temp: data) {//迭代和自動拆箱
System.out.println(temp);
}
}
//T描述的是泛型標記的聲明
public static <T> T[] fun(T ... args) {
return args;
}
}
