关于如何正确地定义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);
    }
}