成员内部类实现如下：
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文件，在打包上线的时候尤其要注意不要漏掉内部类的清单，一般以$分开的
最大的作用：封装！