內部類與匿名類

*內部類定義

將類的定義 class xxx{...}放入一個類的內部，編譯器生成 xxx$xxx的class檔案 //內部類不能與外部類同名

*內部類使用

封裝它的類的內部使用內部類，與普通類的使用方式相同

在其他地方，類名前要冠以外部類的名字 在用new建立內部類時，也要在new前面冠以物件變數

外部物件名.new.內部類名(引數)

class TestInnerClass{
public static void main( String[] args ){
Parcel p = new Parcel();
p.testShip(); Parcel.Contents c = p.new Contents(33);
Parcel.Destination d = p.new Destination( "Hawii" );
p.setProperty( c, d );
p.ship();
}
} class Parcel {
private Contents c;
private Destination d;
class Contents {
private int i;
Contents( int i ){ this.i = i; }
int value() { return i; }
}
class Destination {
private String label;
Destination(String whereTo) {label = whereTo;}
String readLabel() { return label; }
}
void setProperty( Contents c, Destination d ){
this.c =c; this.d = d;
}
void ship(){
System.out.println( "move "+ c.value() +" to "+ d.readLabel() );
}
public void testShip() {
c = new Contents(22);
d = new Destination("Beijing");
ship();
}
} *在內部類中使用外部類成員 可以直接訪問外部類的欄位及方法 如果內部類有與外部類同名的欄位或方法，可用 外部類名.this.欄位及方法 public class TestInnerThis
{
public static void main(String args[]){
A a = new A();
A.B b = a.new B();
b.mb(333);
}
} class A
{
private int s = 111; public class B {
private int s = 222;
public void mb(int s) {
System.out.println(s); // 區域性變數s
System.out.println(this.s); // 內部類物件的屬性s
System.out.println(A.this.s); // 外層類物件屬性s
}
}
} *內部類的修飾符 訪問控制符 ： public protected 預設 private //外部類只能使用修飾或者預設 ，也可以用final，abstract等等 *static修飾符 用static修飾內部類，表面這個內部類實際是一種外部類 static使用時 ： （1）例項化static類時，在new前面不需要用物件例項變數；（2）static類只能訪問static成員 （3）static方法不能訪問非static域及方法，也不能不帶字首new一個非static的內部類 class TestInnerStatic
{
public static void main(String[] args)
{
A.B a_b = new A().new B(); // ok
A a = new A();
A.B ab = a.new B();
Outer.Inner oi = new Outer.Inner();
//Outer.Inner oi2 = Outer.new Inner(); //錯誤
//Outer.Inner oi3 = new Outer().new Inner(); //錯誤
}
}
class A
{
private int x;
void m(){
new B();
}
static void sm(){
//new B(); // error!!!!
}
class B
{
B(){ x=5; }
}
}
class Outer
{
static class Inner
{
}
} （2）區域性類 在一個方法中丁玉磊，這種類稱為區域性類或者“方法中的內部類” class TestInnerInMethod
{
public static void main(String[] args)
{
Object obj = new Outer().makeTheInner(47);
System.out.println("Hello World!" + obj.toString() );
}
} class Outer
{
private int size = 5;
public Object makeTheInner( int localVar )
{
final int finalLocalVar = 99;
class Inner {
public String toString() {
return ( " InnerSize: " + size +
// " localVar: " + localVar + // Error!
" finalLocalVar: " + finalLocalVar
);
}
}
return new Inner();
}
} *使用區域性類 可以訪問外部類成員，不能訪問該方法的區域性變數，除非是final區域性變數 （3）匿名類 特殊的內部類，沒有名字，在定義類的同時生成該物件的一個例項，算“一次性使用”的類 class TestInnerAnonymous
{
public static void main(String[] args)
{
Object obj = new Outer().makeTheInner(47);
System.out.println("Hello World!" + obj.toString() );
}
} class Outer
{
private int size = 5;
public Object makeTheInner( int localVar )
{
final int finalLocalVar = 99;
return new Object() {
public String toString() {
return ( " InnerSize: " + size +
" finalLocalVar: " + finalLocalVar
);
}
};
}
} *匿名類的使用 不取名字，直接用父類或介面的名字 類定義同時建立例項，既類的定義前有一個new new 類名或介面名(){...} 在構造物件時使用父類構造方法，如果new物件時，要帶引數 2.lambda表示式 *基本寫法 （引數） ->結果，如（string s）->s.length() class LambdaRunnable {
public static void main(String argv[]) {
Runnable doIt = new Runnable(){
public void run(){
System.out.println("aaa");
}
};
new Thread( doIt ).start(); Runnable doIt2 = ()->System.out.println("bbb");
new Thread( doIt2 ).start(); new Thread( ()->System.out.println("ccc") ).start();

}
}