内部类

内部类的分类：成员内部类，静态内部类，局部内部类，匿名内部类

 

 

成员内部类:如同类的普通成员一样。  
1、成员类必须依赖外部类而存在（不可有静态成员或方法）
2、内部类可以访问外部类的任意变量或方法
3、先有外部类后有内部类，静态方法要先创建外部对象
 成员方法：this.new  静态方法（如同外部类外部）：先创建外部类对象在创建内部类

 

静态内部类:类静态成员
1、可以有静态、非静态成员
2、内部类只可以访问外部类的静态成员和方法
3、如同一个单独的类，在类外部是加入外部类前缀，在类内部可以不加前缀

局部内部类：成员方法的成员变量
1、不可static,静态成员或者静态方法。不可public 、private修饰
2、变量名称：先this,在局部final变量,最后成员变量（局部变量必须是final变量）
       成员变量：加入外部类.this.变量名
3、可以访问外部类的所有变量和方法
 成员方法：访问所有变量和方法
 静态方法：访问静态变量和方法
4、外部类只有在方法体内才能操作此类

匿名内部类：一种特殊的局部内部类，它是通过匿名类实现接口或继承类。 
1、唯一一种无构造方法类

评论

3 楼 bierbobo 2012-05-04  

package com.bierbobo.design.struct;

public class Outer2 {

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

private static Outer2 o=new Outer2();

public static Outer2 outer_f1() {
Outer2.Inner inner = new Outer2.Inner();
return o;
}

public void outer_f2() {
Outer2.Inner inner = new Outer2.Inner();
Inner inner1 = new Inner();
}

// 静态内部类可以用public,protected,private修饰
// 静态内部类中可以定义静态或者非静态的成员
static class Inner {
static int inner_i = 100;
int inner_j = 200;

static void inner_f1() {
System.out.println("Outer.i" + i);// 静态内部类只 能访问外部类的静态成员
outer_f1();// 包括静态变量和静态方法
}

void inner_f2() {
// System.out.println("Outer.i"+j);//静态内部类不能访问外部类的非静态成员
// outer_f2();//包括非静态变量和非静态方法
}

}

public void outer_f3() {
// 外部类访问内部类的静态成员：内部类.静态成员
System.out.println(Inner.inner_i);
Inner.inner_f1();
// 外部类访问内部类的非静态成员:实例化内部类即可
Inner inner = new Inner();
inner.inner_f2();

}

public static void main(String[] args) {
// new Outer().outer_f3();

Outer2 f1 = Outer2.outer_f1();
Outer2 f2 = Outer2.outer_f1();
System.out.println(f1);
System.out.println(f2);
}

}

abstract class People {
abstract void run();
}

interface Machine {
void run();
}

class Robot extends People{

@Override
void run() {

}

Machine fun(){
return new T();
}

private class T implements Machine{

@Override
public void run() {
// TODO Auto-generated method stub

}}
}

2 楼 bierbobo 2012-05-04  

package com.bierbobo.design.struct;

public class Outer1 {
private static int i = 1;
private int j = 10;
private int k = 20;

public static void outer_f1() {

}

public void outer_f2() {

}

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

void inner_f1() {
System.out.println(i);
System.out.println(j);
// 在内部类中访问内部类自己的变量直接用变量名
System.out.println(this.j);// 或者用this.变量名
System.out.println(Outer1.this.j);

// 在内部类中访问外部类中与内部类同名的实例变量用 外部类名.this.变量名
System.out.println(k);

// 如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量
outer_f1();
outer_f2();


}

void fun(){}
}

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

// 外部类的静态方法访问成员内部类，与在外部类外部访问成员内部类一 样

public static void outer_f4() {

// Inner inner = new Inner();
// inner.inner_f1();

// Outer out = new Outer();
// Inner inner = out.new Inner();
// inner.inner_f1();
}

public static void main(String[] args) {
outer_f4();
}

}


class A{}

1 楼 bierbobo 2012-05-04  

package com.bierbobo.design.struct;

public class Outer {
private int s = 100;
private int out_i = 1;
private static int s1 = 100;
{}
{}
static{}
static{}

public void f(final int k) {
// int s = 200;
int i = 1;
final int j = 10;

class Inner {// 定义在方法内部
// int s = 300;// 可以定义与外部类同名的变量

// static int m = 20;//不可以定义静态变量
Inner(int k) {
inner_f(k);
}


int inner_i = 100;

void inner_f(int k111) {
fun1();
fun2();
System.out.println(out_i);
System.out.println(s1);
// System.out.println(k);// 可以访问外部类 的局部变量(即方法内的变量)，但是变量必须是final的
// System.out.println(s);// 如果内部类中有 与外部类同名的变量，直接用变量名访问的是内部类的变量
// System.out.println(this.s);// 用this.变 量名 访问的也是内部类变量
// System.out.println(Outer.this.s);// 用 外部类名.this.内部类变量名 访问的是外部类变量
}
}

new Inner(k);
}

private void fun1(){}
private static void fun2(){}

public static void f1(final int k) {
final int s = 200;
int i = 1;
final int j = 10;

class Inner {// 定义在方法内部
int s = 300;// 可以定义与外部类同名的变量

// static int m = 20;//不可以定义静态变量
Inner(int k) {
inner_f(k);
}

int inner_i = 100;

void inner_f(int k) {

// fun1();
fun2();
// System.out.println(out_i);// 如果内部类中有 与外部类同名的变量，直接用变量名访问的是内部类的变量
System.out.println(s1);// 用 外部类名.this.内部类变量名 访问的是外部类变量
// System.out.println(k);// 可以访问外部类 的局部变量(即方法内的变量)，但是变量必须是final的
// System.out.println(this.s);// 用this.变 量名 访问的也是内部类变量
}
}

new Inner(k);
}

public static void main(String[] args) {
// 访问局部内部类必须先有外部类对象
Outer out = new Outer();
out.f(3);
Test t=new Test() {
// private static int a=3;
private  int a=3;
void fun(){
System.out.println(s1);

}
// static void fun1(){}
};

class aaa{}

}


public void main1(String[] args) {
Test t=new Test() {
private  int a=3;
void fun(){
System.out.println(s);

}
};


final int i=0;
AAA a=new AAA(){
void fun1(){
System.out.println(s1);
}
};

}

}

class AAA{}
class Test{}