//這是定義的坐標(biāo)點(diǎn)類
class Point {
    private Object x;
    private Object y;

    //用Object來(lái)表示不確定的類型
    public Point(Object x, Object y) {
        this.setX(x);
        this.setY(y);
    }
    public void setX(Object x) {
        this.x = x;
    }
    public Object getX() {
        return x;
    }
    public void setY(Object y) {
        this.y = y;
    }
    public Object getY() {
        return y;
    }

}

//測(cè)試類
public class Demo {
    public static void main(String[] args) {
        System.out.println("用浮點(diǎn)數(shù)表示坐標(biāo): ");
        Point p = new Point(12.23,23.21);
        //這里把Object類轉(zhuǎn)為Double類，然后自動(dòng)拆箱，下面兩種一樣
        System.out.println("X的坐標(biāo) " + (Double)p.getX());
        System.out.println("Y的坐標(biāo) " + (Double)p.getY());
        System.out.println();

        System.out.println("用整數(shù)表示坐標(biāo): ");
        Point p2 = new Point(12, 23);
        System.out.println("X的坐標(biāo) " + (Integer)p2.getX());
        System.out.println("Y的坐標(biāo) " + (Integer)p2.getY());
        System.out.println();

        System.out.println("用字符串表示坐標(biāo): ");
        Point p3 = new Point("北緯29度", "東經(jīng)113度");
        System.out.println("X的坐標(biāo) " + (String)p3.getX());
        System.out.println("Y的坐標(biāo) " + (String)p3.getY());
    }
}

這樣就可以代入不同類型數(shù)據(jù)了，但你別忘了，此時(shí)的數(shù)據(jù)還是Object型，也就是所有類型的父類

你必須清醒的明白自己傳入的是什么類型，然后將其做向下轉(zhuǎn)型處理才能使用

雖然這樣做滿足了需求，不過(guò)卻隱含了一個(gè)不安全因素，為什么說(shuō)是隱含呢？

比如我們用new Point(12.23,"北緯29度")來(lái)構(gòu)造一個(gè)Point對(duì)象

然后都用(Double)將其向下轉(zhuǎn)型，會(huì)產(chǎn)生什么結(jié)果？

沒(méi)錯(cuò)，編譯會(huì)通過(guò)，但是一旦運(yùn)行則會(huì)發(fā)生類型轉(zhuǎn)換異常

要避免類轉(zhuǎn)換異常也很簡(jiǎn)單，把Object聲明換成固定類型聲明（如：String x，String y）即可，這樣編譯時(shí)就會(huì)報(bào)錯(cuò)

然后你就可以尋找出錯(cuò)的地方進(jìn)行修改

不過(guò)如此一來(lái)，我們就滿足不了需求了

為了達(dá)到不存在安全隱患和代入各種數(shù)據(jù)類型的目的，那些牛人們?cè)贘DK1.5當(dāng)中引入了泛型這一概念

我們來(lái)看看如何用泛型改寫上面的代碼

實(shí)例2：泛型類

復(fù)制代碼代碼如下:

class Point<T> {
    //這里用T來(lái)表示不確定的類型
    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;
    }
}

public class Demo {
    public static void main(String[] args) {
        System.out.println("用浮點(diǎn)數(shù)表示坐標(biāo): ");
        //用泛型改寫后，使用數(shù)據(jù)無(wú)需再做向下轉(zhuǎn)型處理
        Point<Double> p = new Point<Double>(12.23,23.21);
        System.out.println("X的坐標(biāo) " + p.getX());
        System.out.println("Y的坐標(biāo) " + p.getY());
        System.out.println();

        System.out.println("用整數(shù)表示坐標(biāo): ");
        Point<Integer> p2 = new Point<Integer>(12, 23);
        System.out.println("X的坐標(biāo) " + p2.getX());
        System.out.println("Y的坐標(biāo) " + p2.getY());
        System.out.println();

        System.out.println("用字符串表示坐標(biāo): ");
        Point<String> p3 = new Point<String>("北緯29度", "東經(jīng)113度");
        System.out.println("X的坐標(biāo) " + p3.getX());
        System.out.println("Y的坐標(biāo) " + p3.getY());
    }
}

使用泛型過(guò)后，可減少安全隱患的存在

如果此時(shí)我們刻意傳入不一樣的數(shù)據(jù)類型：

Point<Double> p = new Point<Double>("北緯29度",12.22);

那么，在編譯時(shí)就會(huì)報(bào)錯(cuò)

雖然定義了泛型，但如果你在構(gòu)造函數(shù)中并未使用泛型機(jī)制的話，那么它便會(huì)把數(shù)據(jù)當(dāng)作Object處理

這樣做的目的主要是為了兼容JDK1.4以前的老代碼，如

Point p = new Point(22.11,23.21);

最終運(yùn)行結(jié)果是一樣的，但在編譯時(shí)卻會(huì)提示警告信息

實(shí)例3：泛型方法

由上面的例子可以看到，一旦在構(gòu)造方法中明確對(duì)象類型，那么整個(gè)類中就將使用同一種類型

最典型的例子是運(yùn)用在集合框架里面，如：ArrayList<Integer> al = new ArrayList<Integer>();

此時(shí)，al中操作的所有對(duì)象類型便都是Integer了

可是，有時(shí)候我們并不希望固定死操作的對(duì)象，而是希望更夠更加靈活的使用泛型技術(shù)

這個(gè)時(shí)候就可以嘗試泛型方法

復(fù)制代碼代碼如下:

//類名后面不再定義泛型
class Print {
    //在方法中定義泛型
    public <T> void print(T t) {
        System.out.println(t);
    }

    public <E> void show(E e) {
        System.out.println(e);
    }
}

public class Demo {
    public static void main(String[] args) {
        Print p = new Print();
        p.print(12);
        p.print("hello");
        p.show(new Integer(33));
        p.show(23);
    }
}

其實(shí)這樣一來(lái)，與在方法中使用Object對(duì)象已經(jīng)沒(méi)有什么太大區(qū)別了

何況，JDK1.5之后加入了自動(dòng)拆裝箱功能，省去了需要向下轉(zhuǎn)型的麻煩

實(shí)例4：泛型接口

復(fù)制代碼代碼如下:

//定義一個(gè)泛型接口
interface Inter<T>
{
    public void print(T t);
}

//實(shí)現(xiàn)方式一：
class InterDemo1 implements Inter<String> {
    public void print(String t) {
        System.out.println("print: " + t);
    }
}

//實(shí)現(xiàn)方式二：
class InterDemo2<T> implements Inter<T> {
    public void print(T t) {
        System.out.println("print: " + t);
    }
}

class Demo {
    public static void main(String[] args) {
        InterDemo1 id1 = new InterDemo1();
        id1.print("hello");
        InterDemo2<Integer> id2 = new InterDemo2<Integer>();
        id2.print(new Integer(23));
    }
}