package minner_class;
/*
 * 關於靜態內部類
 *         1、靜態內部類可以等同看作靜態變數
 * 
 *         內部類重要的作用：可以訪問外部類中私有的資料
 * 
 *         2、靜態內部類可以直接訪問外部類的靜態資料，無法直接訪問成員
 */
public class OuterClass {

    //靜態變數
    private static String s1 = "A";
    
    //成員方法
    private String s2 = "B";
    
    //靜態方法
    private static void
 
 m1(){
        System.out.println("static's m1 method execute!");
    }
    
    //成員方法
    private void m2(){
        System.out.println("m2 method execute!");
    }
    
    //靜態內部類
    //可以用訪問控制權限的修飾符修飾
    static class InnerClass{
        
        //靜態方法
        public static void m3(){
            System.out.println(s1);
            m1();
            
            
 
//System.out.println(s2);
            //m2();
        }
        
        //成員方法
        public void m4(){        
            System.out.println(s1);
            //System.out.println(s2);
            m1();
            //m2();
        }
    }
    
    //入口
    public static void main(String[] args){
        
        
 
//執行m3
        OuterClass.InnerClass.m3();
        
        //執行m4
        InnerClass inner = new OuterClass.InnerClass();
        inner.m4();
    }
}

package minner_class;

/*
 * 關於成員內部類
 *         1.成員內部類可以等同看做成員變數
 * 
 *         2.成員內部類中不能有靜態宣告
 * 
 *         3.成員內部類可以訪問外部類所有資料
 */

public class InnerClass {

    //靜態變數
    private static String s1 = "A";
    
    //成員方法
    private String s2 = "B";
    
    //靜態方法
    private static void m1(){
        System.out.println("static's m1 method execute!");
    }
    
    //成員方法
    private void m2(){
        System.out.println("m2 method execute!");
    }
    
    //成員內部類
    //可以用訪問控制權限的修飾符修飾
    class InnerClass2{
        
        //靜態方法
        //public static void m3(){}
        
        //成員方法
        public void m4(){
            
            System.out.println(s1);
            System.out.println(s2);
            m1();
            m2();
        }
    }
    
    //入口
    public static void main(String[] args){
        
        //建立外部類物件
        InnerClass ic = new InnerClass();
        
        InnerClass2 inner = ic.new InnerClass2();
        
        inner.m4();
    }
}

package minner_class;

/*
 * 區域性內部類等同於區域性變數
 * 
 * 重點：區域性內部類在訪問區域性變數的時候，區域性變數必須使用final修飾。
 */
public class JubuClass {

    public void m1(){
        //區域性變數
        //可以，但不能被訪問
        //int i = 10;
        final int i = 10;
        
        //區域性內部類
        //區域性內部類、區域性內部類不能用訪問控制權限修飾符修飾，
        //因為已經是區域性變量了，只在區域性有效果，不必要加修飾符
        class InnerClass{
            
            //內部類不能有靜態宣告
            //public static void m1(){}
            
            //成員方法
            public void m2(){
                System.out.println(i);
            }
        }
        
        //假如沒有final，此處修改i的值
        //程式至上而下的執行，會產生衝突
        
        //呼叫m2
        InnerClass inner = new InnerClass();
        inner.m2();
    }

    
    //入口
    public static void main(String[] args){
        //想要呼叫m2方法，只能在上面的類建立物件，
        //因為區域性內部類出了大括號就不認識了
        JubuClass jubu = new JubuClass();
        jubu.m1();
    }
}

package minner_class;

/*
 * 匿名內部類：指的是類沒有名字
 */
public class NimingClass {

    //靜態方法
    public static void t(CustomerService cs){
        cs.logout();
    }
    
    //入口
    public static void main(String[] args) {

        //呼叫t方法，方法一
        //父型別的引用指向子型別的方法
        //t(new CustomerServiceImpl());
        
        //使用匿名內部類的方式執行t方法
        //整個這個"t(new CustomerService(){}"就是匿名內部類
        t(new CustomerService(){
            public void logout(){
                System.out.println("系統已安全退出");
            }
        });
        
        //匿名內部類的優點：少定義一個類
        //缺點：無法重複使用！
    }

}

//介面
interface CustomerService{
    
    //退出系統
    void logout();
}

//方法一
//編寫一個類實現CustomerService介面
/*
class CustomerServiceImpl implements CustomerService{
    
    public void logout(){
        System.out.println("系統已安全退出");
    }
}
*/