第七天筆記總結

一：形式參數問題
    數據類型：
        基本類型：byte,short,int,long,float,double,char,boolean
        引用類型：類,接口,數組
 
    形式參數：
        基本類型：要的是該基本類型的數據值。
        引用類型：要的是該引用類型的對象。
            A:數組 要的是該數據類型數組的對象。(地址值)
            B:類   要的是該類或者其子類的對象。(地址值)
            C:抽象類    要的是該抽象類的子類對象。(地址值)
            D:接口  要的是該接口的實現類對象。(地址值)
 
 
二：返回值問題
    返回值：
        基本類型：byte,short,int,long,float,double,char,boolean
        引用類型：類，接口，數組
 
    返回值之基本類型：
        基本類型：返回的是該基本類型的數據值。
        案例：創建一個加法的方法，返回值就是基本類型的具體的指
   
    返回值之引用類型：
    返回值是類名：其實返回的是該類對象或者其子類對象。(地址值)
    返回值是抽象類名：要的是該抽象類的子類對象。(地址值)
    返回值是接口名：要的是該接口的實現類對象。(地址值)
       
   
三：權限修飾符（代碼進行測試）
    權限修飾符：在哪種情況下可以被訪問到。
                            本類        同一個包下的類    不同包下的子類        不同包下的無關類
        private             yes             no                  no                      no
        默認(什麼都不寫)    yes             yes                 no                      no
        protected           yes             yes                 no                      no
        public              yes             yes                 yes                     yes
 
 
四：常見的內容修飾
1:常見的修飾
       
    類：public
        publicclass HelloWorld {}
 
    成員變量：private
        privateString name;
        privateint age;
 
    構造方法：public
        publicStudent() {}
        publicStudent(String name,int age) {}
 
    成員方法：public
        publicvoid show() {}
        publicvoid eat() {}
 
2:哪些東西可以修飾哪些東西
                類  成員變量    構造方法    成員方法
    private         Y               Y       Y
    默認        Y   Y              Y       Y
    protected       Y               Y       Y
    public      Y   Y               Y       Y
    static          Y                       Y
    final       Y   Y                       Y
    abstract    Y                           Y
 
    注意：
        四種權限修飾符，只能有一種存在。
 
        classDemo {}
 
    常見的組合：
        類：
            publicclass HelloWorld {}
            publicfinal class HelloWorld {}
            publicabstract class HelloWorld {}
 
        成員變量：
            privateString name;
            publicfinal int X = 10;
            publicstatic int y = 20;
            publicstatic final int X = 30;
       
        成員方法：
            publicvoid show(){}
            publicabstract void show();
            publicfinal void show(){}
            publicstatic void show() {}
            publicstatic final void show() {}
           
           
五：內部類
    5.1
    內部類：
        把類A定義在類B的內部，類A就被稱爲內部類。
 
    訪問特點：（代碼驗證只要編譯通過說明就是沒有問題的）
        A:內部類可以直接訪問外部類的成員，包括私有。
        B:外部類要訪問內部類的成員，必須創建對象。
 
    5.2
    內部類分類：
        成員位置：成員內部類
        局部位置：局部內部類
   
    5.2.1
    成員內部類：
        外界如何創建對象
 
        外部類名.內部類名對象名 = 外部類對象.內部類對象;
 
    5.2.2
    內部類的關鍵詞限定：
        內部類舉例：
        Body,Heart
        //A:private爲了我們訪問數據的安全性
        classBody {
            privateclass Heart {
                publicvoid operator() {
                    System.out.println("給心臟搭個橋");
                }          
            }
 
            publicvoid method() {
                if(你是醫生嗎?){
                    Hearth = new Heart();
                    h.operator();
                }
            }
        }
 
    直接訪問：
        Body.Heartbh = new Body().new Heart();
        bh.operator();
 
    爲了身體的安全，外界是不能讓他們直接創建對象。通過private進行修飾。
    這個時候就可以這樣來使用：
        Body b =new Body();
        b.method();
 
    成員內部類的修飾：
        A:private爲了我們訪問數據的安全性
        B:static  爲了我們訪問數據的方便性
   
   
    5.2.3
    //B:static  爲了我們訪問數據的方便性
        classOuter {
 
        publicstatic class Inner {
            publicvoid show() {
                System.out.println("show");
            }
 
            publicstatic void show2() {
                System.out.println("show2");
            }
        }
 
    }
 
    classInnerClassDemo3 {
        publicstatic void main(String[] args) {
            // 限定的新靜態類
            //Outer.Inneroi = new Outer().new Inner();
            //格式：
            Outer.Inneroi = new Outer.Inner();
            oi.show();
            oi.show2();
 
            //Outer.Inner.show();
            Outer.Inner.show2();
        }
    }
   
   
    5.2.4
    面試題：
    /*
    需求：請補齊代碼，在控制檯輸出30,20,10
    */
    class Outer {
        publicint num = 10;
 
        privateclass Inner {
            publicint num = 20;
            publicvoid show() {
                intnum = 30;
                System.out.println(？);//num
                System.out.println(？);//this.num
                System.out.println(？);//newOuter().num或者Outer.this.num
            }
        }
 
        publicvoid method() {
            Inneri = new Inner();
            i.show();
        }
    }
 
    classInnerClassTest {
        publicstatic void main(String[] args) {
            Outero = new Outer();
            o.method();
        }
    }
 
   
    5.3
    局部內部類：
    A:可以直接訪問外部類的成員，包括私有
    B:在成員方法中創建局部內部類的對象，調用局部內部類的功能
 
    面試題：
        從內部類中訪問本地變量number; 需要被聲明爲最終類型?
 
        爲什麼：局部內部類訪問局部變量必須加final修飾呢?
            因爲局部變量會隨着方法的調用完畢而消失，這個時候，局部對象並沒有立馬從堆內存中消失，還要使用那個變量。
            爲了讓數據還能繼續被使用，就用fianl修飾，這樣，在堆內存裏面存儲的其實是一個常量值。
   
    5.4
    匿名內部類
        沒有名字的局部內部類,就是內部類的簡化寫法
 
    前提：
        存在一個類或者接口
        這裏的類可以是具體類也可以是抽象類。
 
    格式：
        new 類名或者接口名() {
            重寫方法;
        };
 
    本質：
        是一個繼承了類或者實現了接口的子類匿名對象。
       
    5.5
    匿名內部類在開發中的實際應用。
    案例演示：傳入的方法的參數是一個接口（方式一：定義一個已經實現了接口的類  方式二：匿名內部類的方式）
       
   
    5.6面試題
    /*
    按照要求，補齊代碼
        interfaceInter { void show(); }
        classOuter { //補齊代碼 }
        classInnerClassTest {
            publicstatic void main(String[] args) {
                  Outer.method().show();
              }
        }
    要求在控制檯輸出”HelloWorld”
    */
    答案：
    interfaceInter {
        voidshow();
    }
 
    class Outer {
        //補齊代碼
    }
 
    classInnerClassTest {
        publicstatic void main(String[] args) {
              Outer.method().show();
        }
    }