內部類

作用特點

• 隱藏程式碼
• 可以訪問外圍類 訪問外圍類
• 和組合是完全不同的概念
• 內部類和屬性一樣有訪問許可權的修飾
• 內部類訪問外圍類不受訪問許可權的影響
• 例項化類時,內部類不會被例項化;c++ sizeof()不會計算內部類大小
• 匿名內部類 c和c++是實現是有所區別的
• 匿名內部類只能實現或者繼承 二選一
• 內部類隱含一個外部類的引用 但是加上static就會發生改變 它會消失
  但是也不是毫無益處,它就可以單獨new了
• 普通內部類(沒有static修飾)的類持有一個外部類的引用,內部類中不允許出現static欄位或方法
• 在方法中定義類結構,返回內部類 java可以正常實現 c++卻不行,能返回但是沒有控制代碼
• 巢狀類(普通內部類持有一個外部類的引用):一個內部類通過static關鍵之修飾就是巢狀類
• 巢狀類注意點:失去普通內部類對外部類的引用,失去了訪問外部類的許可權
• 介面中可以實現內部類,它是一個巢狀類.
• 使用這個內部類,可以實現多重繼承
  private public只是在編譯器起作用

匿名內部類其實有一個繼承或者實現的過程

package Innerclasses;
//普通的匿名內部類 和Parcel7還是有一定差別的
public class Parcel8 {
    public Wrapping wrapping(int x){          //這是一個匿名內部類  而且還是隱式的繼承
 

        return new Wrapping(x){     //這裡其實實現了一種繼承的機制很厲害
            public int value(){
                return super.value() * 47;
            }
            public void print(){      //這裡可以實現但是和c++一樣無法正常引用  哈哈
                System.out.println(value());
            }
        };     //這裡是表明表示式結束  這玩意算是一個表示式
 

    }
    public static void Parcel8main(String[] argv){
        Parcel8 parcel8 = new Parcel8();
        Wrapping wrapping = parcel8.wrapping(18);
        System.out.println(wrapping.value());
    }
}


///////////////////////////////////////////////分隔符
package Innerclasses;
//匿名內部類
public class Parcel7 {
 public Contents contents(){
     return new Contents() {    //匿名內部類
         private int i = 11;
        @Override
        public int value() {
            // TODO Auto-generated method stub
            return i;
        }
    };
 }

 public static void main(String[] argv){
     Parcel7 parcel7 = new Parcel7();
     Contents contents = parcel7.contents();
     System.out.println(contents.value());         //成功執行
 }
}

/*-----------------------------------------------------*/
package Innerclasses;
//匿名內部類  定義欄位並初始化 以及無參構造方法
public class Parcel9 {
    public Destination destination(final String dest){  
        //下面使用 這裡必須這樣定義
        return new Destination() {
            { //匿名程式碼塊的就是建立時開始執行 == static   我們就可以把他當成一種無參的構造方法啦
                System.out.println("匿名內部類建立");
                System.out.println(this.readLabel());
            }
            private String lable = dest;
            @Override
            public String readLabel() {
                // TODO Auto-generated method stub
                return this.lable;
            }
        };
    }
    public static void main(String[] args) {
        Parcel9 parcel9 = new Parcel9();
        Destination destination = parcel9.destination("xiaochen");
        System.out.println(destination.readLabel());      
    }
}
/****************************************************/
package Innerclasses;

public class Parcel11 {
    private static class ParcelContents implements Contents{ 
        //巢狀內部類  
        private int i = 11;
        @Override
        public int value() {
            // TODO Auto-generated method stub
            return i;
        }
    }

    protected static class ParcelDestination implements Destination{
        private String label;
        public ParcelDestination(String whereTo) {
            // TODO Auto-generated constructor stub
            this.label = whereTo;
        }
        @Override
        public String readLabel() {
            // TODO Auto-generated method stub
            return label;
        }
        public static void fun(){}
        static int x  =  100;
        static class AnotherLevel{
            public static void f(){}
            static int x = 10;
        }
    }
    public static Destination  destination(String s){
        return new ParcelDestination(s);
    }
    public static Contents contents(){
        return new ParcelContents();
    }
    public static void main(String[] argv){
        Contents contents = contents();
        Destination destination = destination("xiaochen");
        System.out.println(contents.value());
        System.out.println(destination.readLabel());
    }
}

/*********************************/
package Innerclasses;
//類中實現巢狀類main正常執行
public class TestBed {
    public void f(){System.out.println("f()");}
    public static class Tester{
        public static void TestBedmain(String[] args){
            TestBed testBed = new TestBed();
            testBed.f();
        }
    }
}

/**************************************/
package Innerclasses;
//正常執行
public abstract class TestSt {
    abstract void fun();
    public static class Tester extends TestSt{
        @Override
        void fun() {
            // TODO Auto-generated method stub
            System.out.println("fun Function!");
        }
        public static void main(String[] argv){
            TestSt testSt = new Tester();
            testSt.fun();
        }
    }

}

/******************************************/
package 內部類呼叫;

public abstract class Plane {
    abstract void flying();
    public static class fly extends Plane{
        @Override
        void flying() {
            // TODO Auto-generated method stub
            System.out.println("起飛");
        }
        void play(){
            System.out.println("開始起飛");
        }

    }
}
package 內部類呼叫;

public interface Inter {
    void move();
    class car implements Inter{
        @Override
        public void move() {
            // TODO Auto-generated method stub
            System.out.println("move function!");
        }
    }
}
package 內部類呼叫;

public class Main {
    public static void main(String[] args){
        Inter inter  =  new Inter.car();
        inter.move();
        Plane plane = new Plane.fly();
        Plane.fly fly = (Plane.fly) plane;
        fly.play();
        fly.flying();
    }
}

/*******************************/
package Innerclasses;
//內部類繼承
class WithInner{
    class Inner{}
}
public class InheritInner extends WithInner.Inner {
    public InheritInner(WithInner w) { //必須這樣寫
        // TODO Auto-generated constructor stub
        w.super();
    }
    public static void InheritInnermain(String[] args) {
        WithInner withInner = new WithInner();
        InheritInner inheritInner = new InheritInner(withInner); //這樣才可以正常初始化
        System.out.println("main");
    }
}

/***************************************/
//區域性類是否可以被覆蓋  不會
//package Innerclasses;

class Egg{
    private Yolk y;
    protected class Yolk {
        // TODO Auto-generated constructor stub
        public Yolk() {
            // TODO Auto-generated constructor stub
            System.out.println("Egg Yolk");
        }
    }
    public Egg() {
        // TODO Auto-generated constructor stub
        System.out.println("Egg.yolk");
        y = new Yolk();  //這裡不會被子類覆蓋
    }
}
public class BigEgg extends Egg {
    public class Yolk{
        public Yolk() {
            // TODO Auto-generated constructor stub
            System.out.println("BigEgg.Yolk init");
        }
    }
    public static void main(String[] args) {
    new BigEgg(); //這樣直接初始化父類的內部類和外部類  因為內部類會被直接初始化
    System.out.println("----------------------------------------");
    new BigEgg().new Yolk();  //這裡也可以看出來  gigedd不會直接初始化
    }
}
/* Egg.yolk
Egg Yolk
----------------------------------------
Egg.yolk
Egg Yolk
BigEgg.Yolk init

 */

巢狀類小結

• 介面中實現巢狀類 編譯成功 但是實現main方法會報錯,找不到main
• 抽象類 普通類都能實現巢狀類 並且實現main正常執行
• 巢狀類的呼叫還是蠻簡單的就是外部類.巢狀類 包括介面抽象類

介面

介面:介面預設所有方法都是public static修飾的