关于如何正确地定义Java内部类方法详解

class Outer { //外部类

     class Inner { //内部类

         //方法和属性

     }

}

/**

  * @author 一一哥Sun

  * 千锋教育

  * 成员内部类

  */

public class OuterClass {

     // 外部类的非静态成员

     String name = "一一哥" ;

     private String hobby = "撸码" ;

     static int age = 30 ;

     // 非静态方法

     public void show() {

         //这里的this是指OuterClass对象

     System.out.println( "show方法...name=" + this .name);

         //如果是在外部类里面创建内部类的对象，就不需要创建外部类实例，可以直接new 内部类()

     //InnerClass inner = new InnerClass();

     }

     // 定义一个成员内部类

     public class InnerClass {

     // 也可以定义私有属性

     private int a = 10 ;

     //在早期的JDK中，成员内部类中不能定义静态变量；但在新版JDK中，成员内部类中可以定义静态变量

     static int b = 20 ;

     // 非静态方法

     public void m1() {

             // 这里的this对象是InnerClass内部类对象

             System.out.println( "成员内部类的成员变量:" + this .a);

             //外部类.this.属性或方法，这个this是外部类对象

             System.out.println( "外部类的成员变量:" + OuterClass. this .name);

             //内部类中可以访问外部类的私有成员和静态成员

             System.out.println( "外部类的私有成员变量:" + hobby);

             System.out.println( "外部类的静态变量:" + age);

     }

     //在早期的JDK中，成员内部类中不能定义静态方法；但在新版JDK中，成员内部类中可以定义静态方法

     public static void m2() {

             System.out.println( "调用成员内部类的静态变量:" + b);

             System.out.println( "调用外部类的静态变量:" + age);

             //在静态方法中创建内部类对象，也要通过内部类 对象名 = new 外部类().new 内部类();的格式

             //InnerClass innerClass = new OuterClass().new InnerClass();

     }

     }

}

/**

  * @author 一一哥Sun

  * 千锋教育

  */

public class InnerClassTest {

     public static void main(String[] args) {

     //在外部的其他类中，不能直接创建内部类对象，否则：

     //No enclosing instance of type OuterClass is accessible.

     //Must qualify the allocation with an enclosing instance of type OuterClass

     //(e.g. x.new A() where x is an instance of OuterClass).

     //InnerClass inner=new InnerClass();

         //在外部的其他类中创建内部类对象，需要通过如下格式：

     //内部类 对象名 = new 外部类().new 内部类();

     //InnerClass inner=new OuterClass().new InnerClass();

     //也可以拆分成如下格式：

     OuterClass outer= new OuterClass();

     InnerClass inner=outer. new InnerClass();

     inner.m1();

     InnerClass.m2();   

     }

}

public class PartClass {

     public void method() {

         //在方法中定义的内部类，就是局部内部类

         class Inner {

             //属性

             //方法

         }

     }

}

/**

  * @author 一一哥Sun

  * 千锋教育

  *

  * 局部内部类---定义在方法中的内部类

  */

public class PartOuterClass {

     //类的成员变量

     String name= "一一哥" ;

     private int age= 30 ;

     static String hobby= "java" ;

     public void show() {

         //局部变量

         //JDK 7之前，匿名内部类和局部内部类中访问外部的局部变量时，该变量需要明确地带有final修饰符

         //final int num = 10;

         //Effectively final特性

         int num = 10 ;

         //局部内部类，类似于是方法中的局部对象

         class PartInnerClass{

             //内部可以正常定义方法

             public void m1() {

                 //访问外部类的非静态成员，可以使用OuterClass.this.成员的格式，也可以直接访问

                 //System.out.println("外部类的成员变量"+name);

                 System.out.println( "外部类的成员变量" +PartOuterClass. this .name);

                 System.out.println( "外部类私有的成员变量" +age);

                 System.out.println( "外部类的静态变量" +hobby);

                 //局部内部类，可以直接访问方法中的局部变量

                 System.out.println( "访问局部变量" +num);

             }

             //在新版的jdk中，也可以定义静态的属性和方法，老版的jdk则不行

             static int b= 10 ;

             public static void m2() {

                 System.out.println( "外部类的静态变量，hobby=" +hobby+ "，b=" +b);

             }

         }

         //创建局部内部类对象

         PartInnerClass inner = new PartInnerClass();

         inner.m1();

         //在当前类中，局部内部类可以直接访问静态成员

         PartInnerClass.m2();

     }   

}

/**

  * @author 一一哥Sun

  * 千锋教育

  */

public class PartInnerClassTest {

     public static void main(String[] args) {

     //创建外部类对象，调用方法，执行局部内部类

     PartOuterClass outer= new PartOuterClass();

     outer.show();

     }

}

new <类或接口> (){

     重写类或接口的方法

}

/**

  * @author 一一哥Sun

  * 千锋教育

  *

  * 点击监听事件

  */

public interface OnClickListener {

     //点击事件

     void onClick();

}

/**

  * @author 一一哥Sun

  * 千锋教育

  *

  * 局部内部类---定义在方法中的内部类

  */

public class Button {

     //处理案例点击的监听事件

     public void setOnClickListener(OnClickListener listener) {

         listener.onClick();

     }

}

/**

  * @author 一一哥Sun

  * 千锋教育

  *

  * 匿名内部类测试

  */

public class AnonyInnerClassTest {

     public static void main(String[] args) {

     //外部变量

     int num= 20 ;

     //测试匿名内部类

     Button btn= new Button();

     //模拟处理按钮的点击事件

     btn.setOnClickListener( new OnClickListener() { //这里就是一个匿名内部类

             //在匿名内部类中，可以允许使用非静态代码块进行成员初始化操作。

             int i;

             {   // 非静态代码块，在构造方法之后执行

         i = 100 ;    //成员初始化

             }

             @Override

             public void onClick() {

         System.out.println( "按钮被点击啦...i=" +i+ ",num=" +num);

             }

     });

     }

}

/**

  * @author 一一哥Sun

  * 千锋教育

  *

  * 外部类和内部类

  */

public class OuterClass {

     //普通属性，属于外部类

     static int outerNum= 10 ;

     //定义一个静态的内部类，如果不带static，就是一个普通的内部类。

     //内部类的使用，和普通类一样，里面可以正常定义属性、方法、构造方法等。

     //static前面可以带public等任意访问修饰符，也可以不带！

     static class InnerClass{

     //私有属性无法在类的外部直接访问

     //private int innerNum=20;

     int innerNum= 20 ;

     public void printNum() {

             //定义外部类对象

             OuterClass outer= new OuterClass();

             //这里的this是指InnerClass内部类对象！ System.out.println("innerNum="+this.innerNum+",outerAge="+outer.outerAge+",outerNum="+OuterClass.outerNum);

     }

     }

}

/**

  * @author 一一哥Sun

  * 千锋教育

  *

  * 测试访问内部类

  */

public class InnerClassTest {

     public static void main(String[] args) {

     //创建内部类对象，格式为[外部类.内部类 对象名 = new 外部类.内部类的构造方法]

     OuterClass.InnerClass inner = new OuterClass.InnerClass();

     //调用内部类的方法

     inner.printNum();

     //访问外部类属性

     System.out.println( "outerNum=" +OuterClass.outerNum);   

     //访问内部类属性

     System.out.println( "innerNum=" +inner.innerNum);

     }

}