Java内部類與接口、抽象

Java接口、抽象類、内部類  

1.接口(interface)，接口被用來建立類與類之間關聯的标準。

public interface ITest{

      public void test();

}

public class TestImpl implements ITest{

      public void test(){

             System.out.println("test");

      }

}

2.抽象類(abstract class)，隻要類中有一個抽象方法，此類就被标記為抽象類。實際上抽象類除了被繼承之外沒有任何意義。

差別

1.

接口是公開(public)的，裡面不能有私有的方法或變量,是用于讓别人使用的,實作接口的一定要實作接口裡定義的所有方法。

而抽象類是可以有私有方法或私有變量的，實作抽象類可以有選擇地重寫需要用到的方法，但是必須實作裡面所有的抽象方法。

2.

抽象類在 Java 語言中表示的是一種繼承關系，一個類隻能使用一次繼承關系。

但是，一個類卻可以實作多個interface(java中實作多重繼承的方法之一)。

3.

抽象類中可以有自己的資料成員，也可以有非abstarct的成員方法。

而在接口中，隻能夠有靜态的不能被修改的資料成員（也就是必須是 static final的，不過在 interface中一般不定義資料成員），而且所有的成員方法都是抽象的。

4.

抽象類和接口所反映出的設計理念不同。

其實abstract class表示的是"is-a"關系，interface表示的是"like-a"關系。（組合是"has a"關系）

5.

接口中定義的變量預設是public static final 型，且必須給其初值，是以實作類中不能重新定義，也不能改變其值。

抽象類中的變量預設是 friendly 型，其值可以在子類中重新定義，也可以重新指派。

一般的應用裡，最頂級的是接口，然後是抽象類實作接口，最後才到具體類實作。不是很建議具體類直接實作接口的。還有一種設計模式是面向接口程式設計，而非面向實作程式設計。

其實接口是抽象類的延伸，可以将它看做是純粹的抽象類，就是說接口比抽象類還抽象，還有設計接口的目的就是為了實作C++中的多重繼承，不過java團隊設計的一樣更有趣的東西來實作這個功能，那就是内部類(inner class)。

public class OuterClass{//外部類

       private class InnerClass{}//内部類

}

一.定義

放在一個類的内部的類我們就叫内部類。

二.作用

1.内部類可以很好的實作隐藏,也就是封裝性。一般的非内部類，是不允許有 private 與protected權限的，但内部類可以

2.内部類擁有外圍類的所有元素的通路權限

3.可是實作多重繼承(這個特點非常重要，個人認為它是内部類存在的最大理由之一)

4.可以避免修改接口而實作同一個類中兩種同名方法的調用

三、   例子

1.實作隐藏

   平時我們對類的通路權限，都是通過類前面的通路修飾符來限制的，一般的非内部類，是不允許有 private 與protected權限的，但内部類可以，是以我們能通過内部類來隐藏我們的資訊。可以看下面的例子

接口

package insidecategory;

public interface Incrementable

{

  void increment();

}

具體類

package insidecategory;

public class Example {

    private class InsideClass implements InterfaceTest

    {

         public void test()

         {

             System.out.println("這是一個測試");

         }

    }

    public InterfaceTest getIn()

    {

        return new InsideClass();

    }

}

上面加粗的部分是内部類，通路修飾符是private

用戶端程式

package insidecategory;

public class TestExample {

  public static void main(String args[])

  {

    Example a=new Example();

    InterfaceTest a1=a.getIn();

    a1.test();

  }

}

加粗的那部分就是用戶端調用的代碼，從這段代碼裡面我隻知道Example的

getIn()方法能傳回一個InterfaceTest 執行個體但我并不知道這個執行個體是這麼實作的。而且由于InsideClass 是private的，是以我們如果不看代碼的話根本看不到這個具體類的名字，是以說它可以很好的實作隐藏。

2.可以無條件地通路外圍類的所有元素

package insidecategory;

public class TagBean {

 private String name="liutao";

   private class InTest

   {

      public InTest()

      {

          System.out.println(name);

      }

   }

   public void test()

   {

    new InTest();

   }

   public static void main(String args[])

   {

       TagBean bb=new TagBean();

       bb.test();

   }

}

看上面加粗部分，name這個變量是在TagBean裡面定義的私有變量。這個變量在内部類中可以無條件地通路System.out.println(name);

 3.可以實作多重繼承

    個特點非常重要，個人認為它是内部類存在的最大理由之一。正是由于他的存在使得Java的繼承機制更加完善。大家都知道Java隻能繼承一個類，它的多重繼承在我們沒有學習内部類之前是用接口來實作的。但使用接口有時候有很多不友善的地方。比如我們實作一個接口就必須實作它裡面的所有方法。而有了内部類就不一樣了。它可以使我們的類繼承多個具體類或抽象類。大家看下面的例子。

類一

  package insidecategory;

public class Example1 {

   public String name()

   {

       return "liutao";

   }

}

類二

package insidecategory;

public class Example2 {

    public int age()

    {

        return 25;

    }

}

類三

 package insidecategory;

public class MainExample

{

   private class test1 extends Example1

    {

        public String name()

        {

          return super.name();

        }

    }

    private class test2 extends Example2

    {

       public int age()

       {

         return super.age();

       }

    }

   public String name()

    {

    return new test1().name();

   }

   public int age()

   {

       return new test2().age();

   }

   public static void main(String args[])

   {

       MainExample mi=new MainExample();

       System.out.println("姓名:"+mi.name());

       System.out.println("年齡:"+mi.age());

   }

}

大家注意看類三，裡面分别實作了兩個内部類 test1,和test2 ，test1類又繼承了Example1，test2繼承了Example2，這樣我們的類三MainExample就擁有了Example1和Example2的方法和屬性，也就間接地實作了多繼承。

四、 避免修改接口而實作同一個類中兩種同名方法的調用。

  大家假想一下如果，你的類要繼承一個類，還要實作一個接口，可是你發覺你繼承的類和接口裡面有兩個同名的方法怎麼辦？你怎麼區分它們？？這就需要我們的内部類了。看下面的代碼

接口

 package insidecategory;

public interface Incrementable

{

  void increment();

}

類  MyIncrement

   package insidecategory;

public class MyIncrement {

    public void increment()

    {

      System.out.println("Other increment()");

    }

    static void f(MyIncrement f)

    {

        f.increment();

    }

}

大家看上面加黑的部分，兩個方法都是一樣的。在看下面這個類要繼承這兩個類

如果不用内部類

package insidecategory;

public class Callee2 extends MyIncrement implements Incrementable

{

public void increment()

      {

        //代碼

       }

}

想問一下大家increment()這個方法是屬于覆寫MyIncrement這裡的方法呢？還是Incrementable這裡的方法。我怎麼能調到MyIncrement這裡的方法？顯然這是不好區分的。而我們如果用内部類就很好解決這一問題了。看下面代碼

package insidecategory;

public class Callee2 extends MyIncrement

{

  private int i=0;

  private void incr()

  {

       i++;

       System.out.println(i);

  }

  private class Closure implements Incrementable

  {

      public void increment()

      {

        incr();

      }

  }

  Incrementable getCallbackReference()

  {

      return new Closure();

  }

}

我們可以用内部類來實作接口，這樣就不會與外圍類的方法沖突了。

内部類的深入學習 

一、内部類自動擁有對其外圍類的所有成員的通路權。

當某個外圍類對象建立了一個内部類對象時，此内部類對象必定會秘密地捕獲一個指向那個外圍類對象的引用。然後，在你通路此外圍了的成員時，就是用那個引用來選擇外圍類的成員。但是如果内部類是非static的，内部類的對象隻能在與其外圍類的對象相關聯的情況下才會被建立。繼承内部類的時候也需要其外圍類的對象引用，否則繼承無效。

二、.this和.new關鍵字

.this：在内部類中生成對其外圍類的引用。一般可以使用外圍類的名字後面緊跟圓點和this。

.new：如果想告知某些其他對象，去建立某個内部類的對象，必須在new表達式中提供對其他外部類對象的引用，這就需要使用.new文法。例如：

Public class DotNew{}

       Public class Inner{}

}

Public static void main(String args[]){

       DotNew dn=new DotNew();

       DotNew.Inner dni=dn.new Inner();

       //dn.new DotNew.Inner(); 這是錯誤的

}//在擁有外部了對象之前是不可能建立内部類對象的（非Static内部類）

三、内部類可以向上轉型（Upcasting）為其基類，或者接口。這時，内部類得到了對接口的引用，能夠友善地隐藏實作細節。

四、内部類可以定義在方法和作用域中（需要慢慢地了解）

a)         可以定義在一個方法中

b)        可以定義在作用域中

c)         匿名内部類可以實作一個接口

d)        匿名類可以擴充有非預設構造器的類

e)         匿名類可以執行字段初始化

f)         匿名類可以通過執行個體初始化實作構造（匿名類不可能有構造器）

五、 嵌套類

如果不需要内部類對象與其外圍類對象之間有聯系，那麼可以将内部類聲明為static普通的内部類自動擷取對外圍類的引用，而嵌套類具有static的特性，不依賴外圍類對象的建立，也沒有指向外圍類的對象。

1、  要建立嵌套類的對象，不需要外圍類的對象；嵌套類中不可以使用this引用；

2、  不能從嵌套類的對象中通路非static的外圍類對象；

3、  嵌套類有許多類似static的屬性，因為嵌套類本身就是static的，嵌套類可以有static的資料和static字段，還可以包含static的嵌套類，而普通内部類是不可以的。

4、  嵌套類可以作為接口的一部分，而一般情況下，接口内是不允許有任何具體的代碼的；

5、  嵌套類可以作為一些公共代碼，使得他們可以被某個接口的所有不同實作所共用；

6、  可以使用嵌套類在每個類中都寫一個Main（）方法，來測試這個類。

7、  在多層嵌套類中，最深層的嵌套類可以透明底通路它所嵌入的外圍類的所有成員

六、為什麼需要内部類？

每個内部類都能獨立地繼承自一個（接口）的實作，是以無論外圍類是否已經繼承了某個（接口的）的實作，對于内部類都沒有影響。

普通的類無法實作對抽象類和普通類的多重繼承，而采用内部類可以實作，這在有時候是很有用的。内部類使得多重繼承的解決方案變得更加完整。接口的實作解決了部分問題，而内部類有效地實作了“多重繼承”，即：内部類可以繼承非接口類型。

用内部類實作多個接口的意義：

1、  内部類可以有多個執行個體，每個執行個體都有自己的狀态資訊，并且與其外圍類對象的資訊互相獨立；

2、  在當個外圍類中，可以讓多個内部類以不同的方式實作同一個接口，或者繼承同一個類；

3、  建立内部類對象的時刻并不依賴于外圍類對象的建立；

4、  内部類并沒有令人迷惑的“is-a”關系，它就是一個獨立的類。