成员内部类实现如下：
package innerClassDemo;
import innerClassDemo.Foo.Goo;
/** 成员内部类:
声明在类体中，不使用static，具有类的成员特征
也就是，必须有类的实例才能创建内部类实例。内部类实例
可以访问共享外部类的成员变量。很常用。
如：链表的节点就可以定义为内部类 */
public class InnerClassDemo {
public static void
main(String[] args) {
Foo f1 = new Foo();
Goo
g1=f1.new Goo();
Goo g2=f1.new
Goo();
System.out.println(g1.add() +
","+g2.add());
Foo f2 = new Foo();
Goo g3=f2.new
Goo();
Goo g4=f2.new Goo();
f2.a =
2;
System.out.println(g3.add() +
","+g4.add());
}
}
class Foo{
int a =
1;
/** 成员内部类 */
class
Goo{
public int
add(){
//corejava.day07.inn.Foo.this.a;
return
a+1;
}
}
}
局部内部类实现如下：
package innerClassDemo;
/**局部内部类：把类声明在方法中，就是局部内部类，作用域
类似局部变量。很少见。**/
public class LocalDemo {
public static void
main(String[] args) {
/** 局部内部类, 在方法中声明,
作用域仅限方法中有效
* 局部内部类可以访问 final 的局部变量
**/
final int
a=7;
class Foo{
public int
add(){
return
a+1;
}
}
System.out.println(a);
Foo
foo=new Foo();
System.out.println(foo.add());
}
}
静态内部类实现如下：
package innerClassDemo;
import innerClassDemo.Koo.Foo;
/**
**
静态内部类：使用static修饰，声明在类体中.
静态内部类中可以访问外部类的静态成员。**/
public class
StaticInnerClassDemo {
public static void main(String[] args)
{
Foo foo=new
Foo();
System.out.println(foo.add());
}
}
/**
静态内部类
* 静态内部类可以共享外部类的静态资源(属性/方法)
**/
class
Koo{
static int a=1;
int b=2;
static class
Foo{
int b=8;
public int
add(){
return
innerClassDemo.Koo.a+innerClassDemo.Koo.Foo.this.b;
}
}
}
匿名内部类实现如下：
package innerClassDemo;
import java.util.Arrays;
import java.util.Comparator;
/**
* 匿名内部类，匿名类：非常常见，可以写在任何地方,就像一般的语句。
语法更象是创建对象：
Date d = new Date(){};
匿名类是对原类的一个继承，同时创建了实例，{} 就是继承
以后的类体。类体中可使用所有类的语法。
匿名类不能写构造器。
匿名类可以从抽象类或者接口继承，必须提供抽象方法的实现。**/
public class
AnnDemo {
public static void main(String[] args) {
Goo
goo=new Goo(){
public String
toString(){
return
"重写toString实现";
}
};
System.out.println(goo.toString());
System.out.println(goo.say());
Goo
goo2=new
Goo();
System.out.println(goo2.toString());
System.out.println(goo2.say());
Xoo
xoo=new Xoo(){
public int add()
{
// TODO Auto-generated method
stub
return
1+1;
}
};
System.out.println(xoo.add());
//匿名类实际应用案例:
自定义排序
String[] ary =
{"Andy","Tom","Jerry","Bob"};
final int dir = -1;
//排序方向
Arrays.sort(ary, new
Comparator<String>(){
public int
compare(String o1, String o2)
{
//new
StringBuilder(o1).reverse().toString().compareTo()
return dir * (o1.charAt(o1.length()-1)-
o2.charAt(o2.length()-1));
}
});
System.out.println(Arrays.toString(ary));
}
}
interface
Xoo{
int add();
}
class Goo{
public String
toString(){
return "toString实现";
}
public
String say(){
return "hello!";
}
}
注意：任何内部类都编译成独立的class文件，在打包上线的时候尤其要注意不要漏掉内部类的清单，一般以$分开的
最大的作用：封装！