Java 内部类

一 . 非静态成员内部类



public class MemberOuter {

/**
* @param args
*/
// 成员变量 i 未赋值，默认值为0
private static int i;// 定义一个静态私有的成员变量 i
private int j = 10;
private int k = 10;

/**
* 定义一个外部的静态方法
*/
public static void outer_f1() {
System.out.println("this is outer_f1");
}

public void outer_f2() {
System.out.println("this is outer_f2");
}

/**
* 成员内部类中，不能定义静态成员 成员内部类中，可以访问外部类的所有成员
*
* @param args
*/
class Inner {
/**
* static int inner_i = 100; 内部类中不允许定义静态变量
*/
/**
* 内部类和外部类的实例变量可以共存
*/
int j = 100;
int inner_i = 1;

void inner_f1() {
/**
* 如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量
*/
System.out.println(i);
/**
* 在内部类中访问内部类自己的变量直接用变量名
*/
System.out.println(j);
/**
* 在内部类中访问内部类自己的变量也可以用this.变量名
*/
System.out.println(this.j);
/**
* 在内部类访问外部类中与内部类同名的实例变量用外部类名.this.变量名
*/
System.out.println(MemberOuter.this.j);
System.out.println(k);
outer_f1();
outer_f2();
}
}

/**
* 外部类的非静态方法访问成员内部类
*
* @param args
*/
public void outer_f3() {
Inner inner = new Inner();
inner.inner_f1();
}

/**
* 外部类的静态方法访问成员内部类，与在外部类外部访问成员内部类一样
*
* @param args
*/
public static void outer_f4() {
/**
* step1 建立外部类对象
*/
MemberOuter out = new MemberOuter();
/**
* step2 根据外部类对象建立内部类对象
*/
Inner inner = out.new Inner();
/**
* step3 访问内部类的方法
*/
inner.inner_f1();
}

public static void main(String[] args) {
// TODO Auto-generated method stub
/**
* outer_f4(); //该语句的输出结果和下面三条语句的输出结果一样
* 如果要直接创建内部类的对象，不能想当然地认为只需要加上外部类Outer的名字就可以按照通常的样***子生成
* 内部类的对象，而是必须使用此外部类的一个对象来创建其内部类的一个对象 Outer.Inner outin = out.new
* Inner(); 因此，除非你已经有了一个外部类的对象，否则不可能生成内部类的对象。因为此内部类的对象会悄悄**地
* 连接到创建它的外部类的对象。如果你用的是静态内部类那就不需要对其外部类对象的引用
*/
MemberOuter out = new MemberOuter();
MemberOuter.Inner outin = out.new Inner();
outin.inner_f1();

}
}


二. 局部内部类


/**
* 局部内部类也叫方法内部类，即在方法内部定义的内部类。
*/
public class LocalOuter {

/**
* @param args
*/
private int s = 100;
private int out_i = 1;

/**
* 局部内部类中，如果要访问外部类的局部变量，则此变量必须是final修饰， 因为方法的生命周期只是在调用时存在，方法调用完就结束而内部类实例化后并
* 不随外部类成员方法的消失而消失，所有为了提高局部变量的生命周期必须用final修饰
*/
public void method(final int k) {
final int s = 200;
int i = 1;
final int j = 10;
class Inner {
int s = 300;
/**
* 由于内部类的对象中保存有外部类对象的引用，因而在内部类中不能定义静态的属性
*/
// static int m = 20;
int inner_i = 100;

Inner(int k) {
inner_method(k);
}

void inner_method(int k) {
/**
* 如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量
*/
System.out.println(out_i);
/**
* 可以访问外部类的局部变量（即方法内的变量），该变量必须经过final修饰
*/
System.out.println(j);
// System.out.println(i); //不能通过编译
/**
* 如果内部类中有与外部类同名的变量，直接用变量名访问的是内部类的变量。 同样也可以用this.变量名访问内部变量。
*/
System.out.println(s);
System.out.println(this.s);
/**
* 用外部类名.this.变量名放问的是外部变量。
*/
System.out.println(LocalOuter.this.s);
}
}
/**
* 访问局部内部类必须先有外部类对象
*/
new Inner(k);
}

public static void main(String[] args) {
// 访问局部内部类必须先有外部类对象
LocalOuter out = new LocalOuter();
out.method(3);
}

}


三 . 静态内部类


/**
* 用static修饰的内部类叫静态内部类，这个内部类相当于一个外部定义的类
* 静态内部类中可以声明static成员或非静态成员，并可以通过public，protected，private修饰。
*/
public class StaticOuter {

private static int i = 1;
private int j = 10;

public static void outer_method1() {
System.out.println("this is first outer_method");
}

public static void outer_method2() {
System.out.println("this is second outer_method");
}

static class Inner {
static int inner_i = 100;
int inner_j = 200;

static void inner_method1() {
/**
* 静态内部类只能访问外部类的静态成员（包括静态方法和静态变量）
*/
System.out.println(i);
outer_method1();
}

void inner_method2() {
/**
* 静态内部类只能访问外部类的静态成员（包括静态方法和静态变量）
*/
// System.out.println(j);
// outer_method2();
}
}

public void outer_method3() {
/**
* 外部类访问内部类的静态成员：内部类.静态成员
*/
System.out.println(Inner.inner_i);
Inner.inner_method1();
/**
* 外部类访问内部类的静态成员时实例化内部类即可
*/
Inner inner = new Inner();
inner.inner_method2();
}

public static void main(String[] args) {
// TODO Auto-generated method stub
new StaticOuter().outer_method3();
}

}


四 . 匿名内部类


//接口
public interface A {
abstract public void method();
}

/**
* 匿名内部类就是没有名字的内部类。所有匿名内部类是没有构造器的。如果内部类继承了一个带有参数构造器的父类，则在创建
* 它的时候必须要带上参数，并且在实现的过程中使用super关键字调用相应的内容
*/
public class AnonymosOuter {

/**
* @param args
*/
public void callInner(A a) {
a.method();
}

public void second_method() {
// 不能改变值
final int x = 10;
/**
* 匿名内部类为局部内部类，所有局部内部类的限制都对其生效 局部变量x并不是真正的匿名在内部类中使用，x会被匿名内部类复制作为数据成员来使用。
*/
Object obj = new Object() {
public String toString() {
return String.valueOf(x);
}
};
System.out.println(obj);
}

public static void main(String[] args) {
// TODO Auto-generated method stub
/**
* 接口不能用new操作符，但此处比较特殊的是子类对象实现接口，只不过没有为对象命名
*/
new AnonymosOuter().callInner(new A() {
public void method() {
System.out.println("implement for method");
}
});
new AnonymosOuter().second_method();
}

}