顾名思义就是没有名字的对象，这种对象创建直接new 就可以了，具体的实例如下：
l Person类
package cn.itcast.AnonymousObject;
public class Person {
//定义一个方法，用于对象的调用
public static void eat(){
System.out.println("人会吃饭");
}
}l 测试类
package cn.itcast.AnonymousObject;
public class Test {
public static void main(String[] args) {
//创建有名对象
Person p = new Person();
p.eat();
//创建匿名对象
new Person().eat();
//调用方法,作为参数进行传递
method(new Person());
//调用method空参方法，用Person类型的参数进行接收
Person p1 = method();
p1.eat();
}
//对象创建写进方法中，进行调用
public static Person method(){
// Person p = new Person();
// return p;
return new Person();
}
//匿名对象可以作为参数进行传递
public static void method(Person p){
p.eat();
}
}匿名对象的特点：
1． 有名对象可以用引用变量随时进行调用，而匿名对象只能调用一次，还想调用，继续创建匿名对象进行调用，这样做浪费资源，不建议多次调用时使用。
2． 匿名对象可以当做参数进行传递调用。
顾名思义就是类内部包含的类，就是内部类。一个事物内部还包含更深层次的事物，这个事物就是内部类，比如描述汽车类，它的内部还有发动机类，发动机类就是内部类。
内部类的定义格式：
外部类.内部类 变量名 = new 外部类().new 内部类();
变量名.方法名();
外部类内部类成员调用规则：内部类调用外部类中的成员直接调用即可，外部类调用内部类中的成员需要创建外部类内部类的对象（如上内部类的创建格式）。
内部类的定义如下代码演示：
package cn.itcast.NestedClass内部类;
//外部类
public class Outer {
//定义一个成员变量
private int a = 1;
//内部类,定义在外部类的成员位置，可以加pubic private static
class Inner{
//定义一个方法
public void show(){
//内部类可以使用外部类中的成员
System.out.println("内部类方法"+a);
}
}
}l 测试类
package cn.itcast.NestedClass内部类;
public class Test {
public static void main(String[] args) {
//创建对象，调用内部类方法
Outer.Inner n = new Outer().new Inner();
n.show();
}
}运行结果：
内部类中同名成员变量的调用具体演示如下：
package cn.itcast.NestedClass内部类成员变量;
/*
* 外部类、内部类成员变量的调用
*/
public class Outer {
//外部类成员变量
int i = 1;
//内部类
class Inner{
//内部类成员变量
int i = 2;
public void show(){
//局部变量
int i = 3;
//调用方法内局部变量
System.out.println("方法内局部变量i的值："+i);
//调用内部类i的值
System.out.println("内部类中i的值："+this.i);
//调用外部类中i的值
System.out.println("外部类中i的值："+Outer.this.i);
}
}
}l 测试类
package cn.itcast.NestedClass内部类成员变量;
/*
* 测试类
*/
public class Test {
public static void main(String[] args) {
//创建内部类的对象
Outer.Inner in = new Outer().new Inner();
in.show();
}
}运行结果：
局部内部类：定义在外部类方法中的内部类，具体代码演示如下：
package cn.itcast.NestedClass局部内部类;
public class Outer {
//外部类的方法
public void out(){
//局部内部类，定义在外部类方法中成员位置的内部类
class Inner{
//内部类中的方法
public void inner(){
System.out.println("内部类中的方法");
}
}
//创建内部类的对象
Inner in = new Inner();
in.inner();
}
}l 测试类
package cn.itcast.NestedClass局部内部类;
public class Test {
public static void main(String[] args) {
//创建外部类对象。调用内部类方法
Outer o = new Outer();
o.out();
}
}运行结果：
注意：局部内部类中的方法调用需要在外部类的方法中创建内部类的对象，然后再在主方法中创建外部类的对象才能调用局部内部类中的方法。
匿名内部类：就是将实现接口的实现类，重写接口方法，创建实现类的对象，调用实现类的方法这些步骤简化。
定义匿名内部类的格式：
new 接口类的类名(){
重写后的方法
}.方法名();
具体的代码演示如下：
package cn.itcast.NestedClass匿名内部类;
//接口类
public interface Inner {
public abstract void smoking();
}
/*
实现接口的实现类
public class Inter implements Inner{
//重写抽象方法
public void smoking(){
}
}
//创建实现类的对象
Inner x = new Inner();
x.smoking();
Inner i = new Inter();
i.smoking();
*/l 测试类
package cn.itcast.NestedClass匿名内部类;
public class Test {
public static void main(String[] args) {
//匿名内部类：将定义实现类，重写抽象方法，创建实现类的对象进行简化
new Inner(){
public void smoking(){
System.out.println("人在抽烟");
}
}.smoking();
}
}代码演示二：
package cn.itcast.NestedClass匿名内部类;
//抽象类
public abstract class Animal {
public abstract void show();
public abstract void sleep();
}l 测试类
package cn.itcast.NestedClass匿名内部类;
public class Test2 {
public static void main(String[] args) {
//创建匿名内部类,这种方法只能调用一次方法，不能同时调用两次方法
/*new Animal(){
//重写抽象方法
public void show(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
}.show();*/
Animal a = new Animal(){
//重写抽象方法
public void show(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
};
a.show();
a.sleep();
}
}
原文：http://blog.51cto.com/13502869/2063014