Java第十一天（內部類、、訪問權限修飾符、Object類包括toString和equals方法重寫）

51.內部類（瞭解）

類內部的類就是內部類，能夠無限層。

位置：把一個類定義到另外一個類中，那麼內部的類就是內部類。

注意：內部類不能直接建立

建立內部類的語法：

外部類.內部類 變量名 = new 外部類對象().new內部類對象()

內部類的外部類的方法若是想要訪問內部類的方法，必須建立內部類的對象，根據內部類的對象來訪問。

（1）普通內部類

內部類的特色：本類或者本類方法中能夠直接建立內部類的對象,經過內部類對象能夠調用內部類的屬性和方法；

內部類和外部類對象都不能直接訪問彼此的屬性和方法

內部類的方法能夠訪問外部類的屬性和方法，外部類的方法不能直接訪問內部類的屬性和方法可是能夠經過內部類對象間接訪問

//建立一個外部類
class Outter{
    String name;
    public void printOutter(){
            System.out.println("外部類方法！");
    }
    //建立一個內部類，內部類能夠無限層
    class Inner{
        int age;
        //內部類的方法能夠訪問外部類的方法，可是外部類的方法不能訪問內部類的方法
        public void printInner(){
            //調用外部類方法（不要加this）
            printOutter();
            System.out.println("內部類方法!");
        }
        //內部類的方法能夠訪問外部類的屬性，可是外部類的方法不能訪問內部類的屬性
        public void introduceIn(){
            System.out.println("內部類方法打印姓名："+name+"年齡："+age);
        }
    }
    //本類之中能夠直接建立內部類，可是內部類對象不能直接調用外部類的屬性和方法
    public void method(){
        Inner i=new Inner();
        i.age=10;
        i.printInner();
        i.introduceIn();
    }

}
public class Test5{
    public static void main(String[] args){
        //建立一個內部類對象：外部類.內部類 變量名 = new 外部類對象().new內部類對象()
        Outter.Inner p=new Outter().new Inner();
        //內部類對象不能直接調用外部類的方法和屬性
        p.age=12;
        p.printInner();
        p.introduceIn();
        //外部類對象不能直接調用內部類的屬性和方法，可是能夠間接調用
        Outter o=new Outter();
        o.name="pp";
        o.method();
    }
}

（2）匿名內部類（接口或者抽象類）

沒有名字須要在接口或者抽象上實現的內部類

接口名 變量名=new 接口名（）{實現接口的方法};這個大括號就至關於一個內部類，別忘了分號

另一種表現方式，new 接口名（）{實現接口的方法}.方法名（）;

interface Dog{
    public void speek();
}
public class Test{
    public static void main(String[] args){
        //接口名 變量名=new 接口名（）{實現接口的方法};這個大括號就至關於一個內部類，別忘了分號
        Dog p=new Dog(){
            String name="二哈";
            public void speek(){
                System.out.println(name+"衝着你汪汪汪!");
            }
        //別忘了這裏的分號
        };
        p.speek();
        //另一種表現方式，new 接口名（）{實現接口的方法}.方法名（）;
        new Dog(){
            public void speek(){
                System.out.println("衝着你汪汪汪!");
            }
        }.speek();
    }
}

abstract class Dog1{
    //抽象類中能夠設置屬性
    private String name;
    public Dog1(String name){
        this.name=name;
    }
    public void setName(String nm){
        name=nm;
    }
    public String getName(){
        return name;
    }
    public abstract void speek();
}
public class Test1{
    public static void main(String[] args){
        //接口名 變量名=new 接口名（）{實現接口的方法};這個大括號就至關於一個內部類，別忘了分號
        Dog1 p=new Dog1("二哈"){
            public void speek(){
                //調用封裝方法獲得私有屬性
                System.out.println(getName()+"衝着你汪汪汪!");
            }
        //別忘了這裏的分號
        };
        p.speek();
        //另一種表現方式，new 接口名（）{實現接口的方法}.方法名（）;
        new Dog1("泰迪"){
            public void speek(){
                System.out.println(getName()+"衝着你汪汪汪!");
            }
        }.speek();
    }
}

52.訪問權限修飾符

權限修飾符就是用來控制類屬性，方法的訪問的權限的標識

訪問權限的修飾符一共有四種：private, 默認, protected, public

（1）訪問權限修飾符修飾在類上：public修飾的類是能夠隨便訪問，若是是默認修飾的同包能夠訪問，跨包不可訪問

（包的知識點中已經講過了，只有public的類不一樣包能夠導入包再訪問類）

（2）訪問權限修飾符修飾在方法和屬性上：

修飾同一個類中的方法或者屬性能夠被直接或者間接訪問

修飾的方法或者屬性，在同包不一樣類中能夠被直接或間接訪問

 

不一樣包不一樣類但爲父子類的

無關類

類通常會用public修飾

屬性通常用private修飾

方法通常用public，少數用protected、private修飾

53.Object類

Object是全部類的根類（默認隱藏地繼承了objct類），全部的類都是直接或者間接的去繼承Object類。

根類：最上層的類

超類：根類和父類之間的類

類 Object 是類層次結構的根類。每一個類都使用 Object 做爲超類。全部對象（包括數組）都實現這個類的方法。

（1）toString方法

public String toString()

返回該對象的字符串表示。一般，toString 方法會返回一個「以文本方式表示」此對象的字符串。結果應是一個簡明但易於讀懂的信息表達式。建議全部子類都重寫此方法。

Object 類的 toString 方法返回一個字符串，該字符串由類名（對象是該類的一個實例）、at 標記符「@」和此對象哈希碼的無符號十六進制表示組成。換句話說，該方法返回一個字符串，它的值等於：

getClass().getName() + '@' + Integer.toHexString(hashCode())

返回： 該對象的字符串表示形式。

toString方法在Object中的源碼實現：

public String toString(){

     return getClass().getName()+'@'+Integer.toHexString(hashCode())

}

getClass().getName()    得到toString的方法的類的類名

Integer.toHexString(hashCode())   得到這個對象的hash值的16進制

hashCode方法      每個對象都有惟一的一個hash值，不一樣的整數。

getClass方法     得到一個類的類對象

class Person{
    
}
public class Test2{
    public static void main(String[] args){
        Person p=new Person();
        int h=p.hashCode();
        System.out.println(h);
        System.out.println(Integer.toHexString(h));
        System.out.println(p.getClass());
        System.out.println(p.getClass().getName());
    }
}

（2）重寫toString方法

class Person1{
    String name;
    String habit;
    public void speek(){
        System.out.println("你好！");
    }
    /*重寫toString方法
    public String toString(){
        return getClass().getName()+'@'+Integer.toHexString(hashCode());
    }
    
    */
    public String toString(){
        speek();
        return "我是"+name+"個人愛好是"+habit;
    }
}
public class Test3{
    public static void main(String[] args){
        Person1 p=new Person1();
        p.name="小可愛";
        p.habit="撩小哥哥";
        //默認的調用了toString方法
        System.out.println(p);
    }
}

（3）finalize() 

面試題：

final、finally、finalize的區別

final做用在類上表示最後一個類不可被繼承，修飾在方法上方法不可被覆寫，修飾在屬性上屬性和變量上不可修改，屬性能夠在建立的時候賦予初始值或者構造器中賦予初始值（每一個構造器都必須顯示final這個屬性的初始化）

（4）equals方法

==雙等號

在Object中源碼：

public boolean equals(Object obj){

    return  (this==objets);

}

基本數據類型比較的是值，各自有各自的默認值；

引用數據類型比較的是地址，默認值是null

（5）重寫equals方法

class Child{
    String fa;
    String mo;
    int age;
    String face;
    /*重寫equals方法
    public boolean equals(Object obj){
        return(this==obj);
    }
    */
    //重寫規則:兩個孩子的父親和母親同樣，年齡相等、長相同樣的是一胎生的
    public boolean equals(Object obj){
        //建立一個返回類型做爲判斷標識
        boolean flag=false;
        //判斷是否來自於子類
        if(obj instanceof Child){
            //將自動轉成父類的子類對象再轉回子類，方便調用子類中的屬性
            Child c=(Child)obj;
            //字符串類型調用equals方法須要判斷字符串不爲默認值
            if(this.fa==c.fa&&this.mo==c.mo&&this.age==c.age&&this.face!=null&&c.face!=null&&this.face.equals(c.face)){
                flag=true;
            }    
        }
        return flag;
    }
}
public class Test4{
    public static void main(String[] args){
        Child a=new Child();
        Child b=new Child();
        a.fa="dady";
        a.mo="mama";
        a.age=8;
        a.face="beautiful";
        b.fa="dady";
        b.mo="mama";
        b.age=8;
        b.face="beautiful";
        boolean x=a.equals(b);
        System.out.println(x);
        
    }
}