匿名对象

顾名思义就是没有名字的对象，这种对象创建直接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();   }}