你真的了解interface和內部類么

java 訪問控制符

---

private     ： 只能被當前類訪問

protected ： 可以被同包的類和任何子類訪問（包內，包外）

default    ： 可以被包內的任何內訪問

public     ： 任何類都可以訪問

Java重載可以改變類的訪問控制符么？

可以！ 但只能將訪問權限變大，不能縮小。比如

A extends B ，B中有一個M方法是 則M支持如下擴充：（private不支持重載）

default  —— protected

default  —— public

protected —— public

接口

---

接口是類么？

由下圖可以看出，接口和類同屬於java數據類型的引用數據類型，他們是同等級的，接口並不是類。類是用class定義，而接口是inteface定義。

接口中可以定義成員變量么？

接口的含義理解:接口可以理解成統一的"協議",而接口中的屬性也屬於協議中的內容;但是接口的屬性都是公共的,靜態的,最終的

接口的成員特點：
A:成員變量 只能是常量。默認修飾符 public static final
B:成員方法 只能是抽象方法。默認修飾符 public abstract

接口內的函數 需要 public，private，protected，abstract 修飾么？

如果我們在定義一個接口時，給內部的某個接口加上“public” 修飾符，不會報錯，但是編譯器會提示如下：

意思是“public” 修飾符是多余的。

那么我們加 private，protected會怎么樣呢？

可以看出 接口的內部函數默認就是public的。

1. 如果接口方法是private 只有當前接口能訪問，哪還有什么意義。

2. 如果是default或者protected ： 因為接口談不上子類只有implement關系，protected不能修飾。那能不能不加任何訪問控制符呢？實際編譯不加任何 控制符會自動變為public。（接口設計的初衷就是大家都能調用訪問）

在接口前加 abstract字段：

和增加“public” 結果相同，接口內的函數默認就是抽象public函數，不需要增加 abstart public關鍵字

定義接口時 public,private,protected 含義？我們定義一個class會用這幾種訪問控制符修飾。

接口不能用 private  和 protected 修飾：

1、 private 接口只能自身訪問自身，讓接口失去了任何意義。

2、protected 修飾則表示只能被子類訪問和同一個包內的其它類訪問。protected比default多部分類可以訪問：包外的子類。

那么對於接口來說，它沒有任何子類，所以protected對它無效。

public接口和 default接口

default接口只能在包內寫一個內去implement，包外則不能去implement。

內部接口

---

內部接口是定義在一個類的內部的接口。

內部接口的優點：

1.一種對那些在同一個地方使用的接口進行邏輯上分組；
2.封裝思想的體現；
3.嵌套接口可以增強代碼的易讀性和可維護性；

在Java標准庫中使用內部接口的一個例子是java.util.Map和Java.util.Map.Entry。這里java.util.Map同樣被當成命名空間使用。Entry並不屬於全局作用域范圍.

內部接口需要加上static么

比如封裝的一個Request類，用於請求后台的某個參數，那我們肯定需要設置一個監聽器接口來監聽請求的狀態及返回的結果，設置結構如下：

public class Request {

    private ListenerInterface listener;

    static public interface ListenerInterface{
        void onResult();
    }

    public void request(){
        doResest();
        listener.onResult();
    }

    private void doResest(){

    }
}

其實定義在一個類內部的接口，默認就是static的，所以再加一個static關鍵字修飾是多余的。假如一個類接口可以定義成非static類型的，那么外部去實現這個接口之前必須要實例一個外部類的對象才能去實現該接口，上述代碼中要初始化一個Request對象 Request requet = new Request(); 然后 new request.ListenerInterface(){ void onResut(){} } ，這樣就不能做到接口和類的分割，不符合接口功能的獨立性思想。

內部類

---

public class test {

    private Object []obj;
    private int next = 0 ;

    test(int i){
        obj = new Object[i];
    }

    public void addObject(Object j){
        obj[next++] = j;
    }

    int getLength(){
        return obj.length;
    }
    public class inerObject {
        private int i=0;
        public boolean end(){
            return i==obj.length;
        }
        public Object current(){
            if(i>=obj.length)
                return null;
            else
                return obj[i];
        }
        public Object next(){
            if(obj.length==0||i>=obj.length){
                System.out.print("i is : "+i+"");
                return null;
            }

            else {
                System.out.print("i is : "+i+"");
            }
                return obj[++i];
        }
    }


    public  static void main(String []args){
        test t = new test(10);
        for(int i=0;i<t.getLength();i++){
            t.addObject(Integer.toString(i));
        }
        inerObject ir = t.new inerObject();
        while(!ir.end()){
            System.out.println(ir.next());
        }
    }
}

在Main中構建 內部類時必須有一個 外部類的對象，否者不能實例化

         inerObject ir = t.new inerObject();
1、因為構建內部類對象時，需要一個指向其外部類對象的引用，如果編譯器訪問不到這個引用時就會報錯。（static除外）

2、由上述代碼可知，內部類可以訪問所在類的成員變量。

嵌套類

　　如果不需要 內部類對象與外圍對象之間有聯系，那么可以將內部類聲明為static，通常稱為嵌套類。

嵌套類的作用：

　　1、從作用域的角度看，嵌套類被隱藏在外圍類之中，該類名只能在外圍類中使用（即是作為外圍類的成員變量一樣使用）。如果在外圍類的作用域外使用該類名時，需要加名字限定。

       2、從訪問權限的角度來看，嵌套類名與它的外圍類的對象成員名具有相同的訪問權限規則。不能訪問嵌套類的對象中的私有成員函數，也不能對外圍類的私有部分中的嵌套類建立對象。

匿名內部類

---

匿名內部類也就是沒有名字的內部類正因為沒有名字，所以匿名內部類只能使用一次，它通常用來簡化代碼編寫但使用匿名內部類還有個前提條件：

必須繼承一個父類或實現一個接口

實例1:不使用匿名內部類來實現抽象方法

abstract class Person {
    public abstract void eat();
}

class Child extends Person { public void eat() { System.out.println("eat something"); } }

public class Demo {
    public static void main(String[] args) {
        Person p = new Child();
        p.eat();
    }
}

運行結果：eat something

可以看到，我們用Child繼承了Person類，然后實現了Child的一個實例，將其向上轉型為Person類的引用

但是，如果此處的Child類只使用一次，那么將其編寫為獨立的一個類豈不是很麻煩？這個時候就引入了匿名內部類

 

實例2：匿名內部類的基本實現

abstract class Person {
    public abstract void eat();
}

public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}