您當前位置：首頁 > php開源 > 綜合技術 > JAVA之旅（九）——Object類，equals，toString，getClass，內部類訪問規則，靜態內部類,內部類原則，匿名內部類

JAVA之旅（九）——Object類，equals，toString，getClass，內部類訪問規則，靜態內部類,內部類原則，匿名內部類

來源：程序員人生發布時間：2016-06-15 15:05:06 閱讀次數：3997次

JAVA之旅（9）——Object類，equals，toString，getClass，內部類訪問規則，靜態內部類,內部類原則，匿名內部類

每天被1些雜事騷擾，學習還得繼續

1.Object類

Object是甚么呢？我們可以翻閱JAVA API文檔看他的介紹

這里寫圖片描述

上面介紹說，object是類層次結構的根類，也就是超類

Object：是所有對象的直接后者間繼承關系，傳說中的老祖宗，你父親還有父親，你父親的父親還有父親是爺爺，這是繼承關系，但是你的祖宗卻只有1位，該類中定義的肯定是所有對象都具有的功能

class Demo { // extends Object

}

1.equals

我們可以用equals去比較兩個對象是不是相同

//公共的   類   類名
public class HelloJJAVA {
    // 公共的 靜態 無返回值 main方法 數組
    public static void main(String[] str) {
        // 比較
        Demo1 demo1 = new Demo1();
        Demo2 demo2 = new Demo2();
        System.out.println(demo1.equals(demo2));
    }
}

class Demo1 {

}

class Demo2 {

}

結果肯定返回的是false

這里寫圖片描述

這里我們要注意的是，他比較的是內存地址

假定我們需要定義1個比較內容

//公共的   類   類名
public class HelloJJAVA {
    // 公共的 靜態 無返回值 main方法 數組
    public static void main(String[] str) {
        // 比較
        Demo demo1 = new Demo(5);
        Demo demo2 = new Demo(8);
        System.out.println(demo1.Comper(demo2));
    }
}

class Demo {

    private int num;

    public Demo(int num) {
        this.num = num;
    }

    public boolean Comper(Demo d) {
        return this.num == d.num;
    }
}

他返回的也是false，但是我們有必要這樣去做嗎？

object類中已提供了對對象是不是相同的比較方法，如果自定義類中也有相同的功能，沒有必要重新定義，只要沿襲父類的功能，簡歷自己的特有內容便可，這就是覆蓋，所以我們已復寫

//公共的   類   類名
public class HelloJJAVA {
    // 公共的 靜態 無返回值 main方法 數組
    public static void main(String[] str) {
        // 比較
        Demo demo1 = new Demo(5);
        Demo demo2 = new Demo(5);
        System.out.println(demo1.equals(demo2));
    }
}

class Demo {

    private int num;

    public Demo(int num) {
        this.num = num;
    }

    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return this.num == ((Demo)obj).num;
    }
}

這里應用了多態的向下轉型

這里寫圖片描述

2.toString

轉換成字符串

//公共的   類   類名
public class HelloJJAVA {
    // 公共的 靜態 無返回值 main方法 數組
    public static void main(String[] str) {
        // 比較
        Demo demo = new Demo(5);
        System.out.println(demo.toString());
    }
}

class Demo {

    private int num;

    public Demo(int num) {
        this.num = num;
    }
}

轉換的結果10甚么呢？

這里寫圖片描述

這個是甚么值呢？

類名@哈希值

甚么是哈希值？我們可以用toHexString來轉換

System.out.println(demo.toString());
System.out.println(Integer.toHexString(demo.hashCode()));

這里寫圖片描述

3.getClass

這個就不用多說，返回當前運行的Class，所以

//公共的   類   類名
public class HelloJJAVA {
    // 公共的 靜態 無返回值 main方法 數組
    public static void main(String[] str) {
        // 比較
        Demo demo = new Demo(5);
        /*
         * System.out.println(demo.toString());
         * System.out.println(Integer.toHexString(demo.hashCode()));
         */

        System.out.println(demo.getClass());
    }
}

class Demo {

    private int num;

    public Demo(int num) {
        this.num = num;
    }
}

我們這里就直接返回了Demo

這里寫圖片描述

方法還有很多，比如getName

System.out.println(demo.getClass().getName());

得到的就是Demo這個名稱了

2.內部類

這是1個小知識點，我們先看1下概念

將1個類定義在另外一個類里面，對峙面那個類就稱為內部類（內置類，嵌套類）
訪問特點
- 內部類可以直接訪問外部類的成員，包括私有成員
- 而外部類要訪問內部類中的成員就必須建立內部類的對象

我們來寫1個內部類

class Outer {
    int x = 3;

    void show() {
        System.out.println("x = " + x);
        new Inner().fini();
    }

    /**
     * 內部類
     * 
     * @author LGL
     *
     */
    class Inner {
        void fini() {
            System.out.println("內部類"+x);
        }
    }
}

內部類的訪問規則上面已體現了

內部類可以直接訪問外部類的成員，包括私有成員
而外部類要訪問內部類中的成員就必須建立內部類的對象

那我們可以不可以直接訪問內部類中的成員呢？

Outer.Inner inner = new Outer().new Inner();
inner.fini();

這樣就能夠訪問了，不過我們1般都不這樣做，由于大多數的情況我們會將內部類私有

那你有無想過？為何匿名內部類可以訪問外部的成員？我們可以做1個這樣的小測試，在內部類里面定義1個x分別是成員變量和局部變量

//公共的   類   類名
public class HelloJJAVA {
    // 公共的 靜態 無返回值 main方法 數組
    public static void main(String[] str) {
        Outer.Inner inner = new Outer().new Inner();
        inner.fini();
    }
}

class Outer {
    int x = 3;

    void show() {
        System.out.println("x = " + x);
        new Inner().fini();
    }

    /**
     * 內部類
     * 
     * @author LGL
     *
     */
    class Inner {
        int x = 5;

        void fini() {
            int x = 6;
            System.out.println("內部類" + x);
        }
    }
}

我們現在輸出的這個x你知道是多少嗎？結果不言而喻，是6

這里寫圖片描述

那我現在想打印這個5怎樣打？用this就好了

這里寫圖片描述

那我們想打印這個3呢？this是內部類的，那我們需要外面的this，就用Outer.this.x，輸出的就是3了

這里寫圖片描述

之所以可以直接訪問外部類中的成員是由于內部類中持有了1個外部類的援用，該援用寫法是：外部類名.this

3.靜態內部類

當內部類在成員位置上，就能夠被成員修飾符所修飾，比如：

private,將內部類在外部類中進行封裝
static,內部類就具有了static的特性，當內部類被static修飾后，只能直接訪問外部類中的static的成員，出現了訪問局限，但是靜態內部類出現的不是很多，畢竟有訪問局限

這里寫圖片描述

在外部類中，我們是如何訪問靜態內部類呢？

//公共的   類   類名
public class HelloJJAVA {
    // 公共的 靜態 無返回值 main方法 數組
    public static void main(String[] str) {
        new Outer.Inner().fini();
    }
}

class Outer {
    private static int x = 3;

    /**
     * 內部類
     * 
     * @author LGL
     *
     */
    static class Inner {

        void fini() {
            System.out.println("內部類" + x);
        }
    }
}

這樣就能夠訪問了

4.內部類原則

我們來分析下內部類是怎樣來的，為何這樣用

當描寫事物時，事物的內部還有事物，該事物用內部類描寫，由于內部事物在使用外部事物

內部類就是能直接訪問外部類中的具體事物，1般都用于程序設計上

5.匿名內部類

1般內部類不會被公有實現，我們內部類可以定義在任意位置，也能夠這樣做

class Outer {

    int x = 3;

    void fini() {

        class fini {

            void show() {

                System.out.println("內部類");
            }
        }

    }
}

這段程序，內部類會運行嗎？答案是不會，由于沒有對象，我們就給他new1個對象唄

//公共的   類   類名
public class HelloJJAVA {
    // 公共的 靜態 無返回值 main方法 數組
    public static void main(String[] str) {
        new Outer().fini();
    }
}

class Outer {

    int x = 3;

    void fini() {

        class fini {

            void show() {

                System.out.println("內部類");
            }
        }
        new fini().show();
    }
}

這樣就能夠訪問了，內部類定義在局部

1.不可以被成員修飾符修飾
2.可以直接訪問外部類中的成員，由于還持有類中的援用，但是不可以訪問他所在的局部變量，只能訪問被final修飾的局部變量

而我們的匿名內部類，是甚么概念？我們顧名思義，匿名內部類，是沒著名字的

1.匿名內部類其實就是內部類的簡寫格式
2.定義匿名內部類的條件，就是內部類必須繼承1個類或實現接口

正常的邏輯代碼

//公共的   類   類名
public class HelloJJAVA {
    // 公共的 靜態 無返回值 main方法 數組
    public static void main(String[] str) {
        new Outer().function();
    }
}

class Outer {

    int x = 3;

    class Inner extends AdsDemo {
        @Override
        void show() {
            System.out.println("method:" + x);
        }
    }

    public void function() {
        new Inner().show();
    }
}

abstract class AdsDemo {

    abstract void show();
}

而我們現在要使用匿名內部類，就簡化了代碼，具體怎樣做？

//公共的   類   類名
public class HelloJJAVA {
    // 公共的 靜態 無返回值 main方法 數組
    public static void main(String[] str) {
        new Outer().function();
    }
}

class Outer {

    int x = 3;

    // class Inner extends AdsDemo {
    // @Override
    // void show() {
    // System.out.println("method:" + x);
    // }
    // }

    public void function() {
        // new Inner().show();
        new AdsDemo() {
            @Override
            void show() {
                System.out.println("x:" + x);
            }
        };

    }
}

abstract class AdsDemo {

    abstract void show();
}