package com.java.exp11;

import java.util.Random;
import static java.lang.System.out;

/**
 * 1、Java類包
 *  1.1、類名衝突
 *      將兩個類放在不同的包下
 *  1.2、完整的類路徑
 *      同一個包彙總的類相互訪問時，可以不指定包名
 *  1.3、建立包
 *      Java包的命名規則是全部使用小寫字母
 *  1.4、匯入包
 *      import關鍵字
 *      還可以匯入靜態成員  import static 靜態成員
 * 2、final變數
 *  final宣告的變數不能改變，通常，有final定義的變數為常量
 *  final關鍵字定義的變數必須在宣告的時候對其進行賦值操作
 *  在Java中宣告全域性常量，通常使用 public static final 修飾，這樣的常量只能在定義是賦值
 * 3、final方法
 *  final方法不能被重寫
 * 4、final類
 * 5、內部類
 *  5.1、成員內部類
 *      1.成員內部類簡介
 *      在一個類中使用內部類，可以再內部類中直接存取其所在類的私有成員變數
 *      在內部類中可以隨意使用外部類的方法以及成員變數，儘管這些類成員被修飾為private。
 *      如果在外部類和非靜態方法之外例項化內部類物件，需要使用外部類。內部類的形式指定該物件的型別。
 *      內部類物件會依賴與外部類物件，除非已經存在一個外部類物件，否則類中不會出現內部類物件。
 *      2.內部類向上轉型為介面
 *      非內部類不能被宣告為private或protected訪問型別
 *      3.使用this關鍵字獲取內部類與外部類的引用
 *  5.2、區域性內部類
 *  5.3、匿名內部類
 *  5.4、靜態內部類
 *  5.5、內部類的繼承
 * */
 


class Parents{
    private final void doit(){
        System.out.println("父類.doit()");
    }
    final void doit2(){
        System.out.println("父類.doit2()");
    }
    public void doit3(){
        System.out.println("父類.doit3()");
    }
}
class Sub extends Parents{
    public final void doit(){       //在子類中定義一個doit()方法
 

        System.out.println("子類.doit()");
    }
//  final void doit2(){             //final方法不能被覆蓋
//      System.out.println("子類.doit2()");
//  }
    public void doit3(){
        System.out.println("子類.doit3()");
    }
}
public class Demo {
    public static void main(String[] args) {
        Sub s = new Sub();
        s.doit();
        Parents p = s;
//      p.doit();           //不能呼叫private方法
 

        p.doit2();
        p.doit3();
    }
}

InterfaceInner類

package com.java.exp11;

/**
 * 成員內部類--向上轉型為介面
 * */
interface OutInterface{
    public void f();
}

class OuterClass2{
    //定義一個內部類實現Out Interface介面
    private class InnerClass implements OutInterface{
        InnerClass(String s){       //內部類構造方法
            System.out.println(s);
        }
        public void f(){            //實現介面中的f()方法
            System.out.println("訪問內部類中的f()方法");
        }
    }
    public OutInterface doit(){     //  定義一個方法，返回值型別為OutInterface 介面
        return new InnerClass("訪問內部類構造方法");
    }
}


/**
 * 區域性內部類
 * */
interface OutInterface2{

}
class OuterClass3{
    public OutInterface2 doit(final String x){      //doit()方法引數為final型別
        //在doit()方法中定義一個內部類
        class InnerClass2 implements OutInterface2{
            InnerClass2(String s){
                s = x;
                System.out.println(s);
            }
        }
        return new InnerClass2("doit");
    }
}

/**
 * 匿名內部類
 * */
class OuterClass4{
    public OutInterface2 doit(){
        return new OutInterface2(){
            private int i = 0;
            public int getValue(){
                return i;
            }
        };
    }
}

public class InterfaceInner{
    public static void main(String[] args){
        OuterClass2 out = new OuterClass2();    //例項化一個OuterClass2物件
        //呼叫doit()方法，返回一個OutInterface介面
        OutInterface outinter = out.doit();
        outinter.f();
    }
}

OuterClass類

package com.java.exp11;

public class OuterClass {
    InnerClass in = new InnerClass();   //在外部類例項化內部類物件引用
    public void ouf(){
        in.inf();                       //在外部類方法中呼叫內部類方法
    }
    class InnerClass{
        InnerClass(){                   //內部類構造方法
        }
        public void inf(){              //內部類成員方法
        }
        int y = 0;
    }
    public InnerClass doit(){           //外部類方法，返回值為內部類引用
    //  y = 4;                          //外部類方法不能直接訪問內部類成員變數
        in.y = 4;
        return new InnerClass();        //返回內部類引用
    }
    public static void main(String[] args) {
        OuterClass out = new OuterClass();
        //內部類的物件例項化操作必須在外部類或外部類的非靜態方法中實現
        OuterClass.InnerClass in = out.doit();
        OuterClass.InnerClass in2 = out.new InnerClass();
    }
}

OutputInnerClass類

package com.java.exp11;

/**
 * 內部類的繼承
 * 
 * 當某個類繼承內部類時，必須硬性給予這個類一個帶引數的構造方法，
 * 並且這個構造方法的引數為需要繼承內部類的外部類的引用，
 * 同時在構造方法體中使用 外部類引用.super()語句，這樣才為繼承提供了必要的物件引用
 * */
public class OutputInnerClass extends ClassA.ClassB{
    public OutputInnerClass(ClassA a){
        a.super();
    }

}
class ClassA{
    class ClassB{

    }
}

StaticInnerClass類

package com.java.exp11;

/**
 * 靜態內部類
 * 靜態內部類不可以使用外部類的非靜態成員
 * 如果建立靜態內部類的物件，不需要其外部類的物件
 * 不能從靜態內部類的物件中訪問非晶態外部類的物件
 * */
public class StaticInnerClass{
    int x = 100;
    static class Inner{
        void doitInner(){
//          System.out.println("外部類"+x);
        }
        public static void main(String[] args){
            System.out.println("a");
        }
    }
}

TheSameName類

package com.java.exp11;

public class TheSameName {
    private int x; 
    private class inner{
        private int x = 9;
        public void doit(int x){
            x++;                    //呼叫的時形參x
            this.x++;               //呼叫內部類的變數x
            TheSameName.this.x++;   //呼叫外部類的變數x
        }
    }
}