public void study（）{

　　　　　　System.out.println("......");

　　　　}

public static void study(){

　　System.out.println(".......");

}

　public class PersonBean {

	//实例初始化块

	//该代码块在new对象的构造的时候会被自动执行，new一次就执行一次

	//new对象构造方法要执行4步，该代码块在第3步之前执行，即在对属性进行初始化之前

	//因此先在初始化块中对属性进行赋值，会被第3步的赋值覆盖

	{

		System.out.println("Person的实例初始化块");

	}

	//静态初始化块

	//该代码块是在加载PersonBean的class的时候就被自动执行了

	//一个类只加载一次，所以静态初始化块也只执行一次

	//所以很多打开资源、开启链接的预加载动作可以写到静态初始化块中

	static{

		System.out.println("Person的静态初始化块");

	}

	//属性

	private String name;

	private int age = 20;

	private static int a;

	//构造

	public PersonBean(){

		System.out.println("PersonBean的构造");

	}

	public PersonBean(String name, int age){

		this.name = name;

		this.age = age;

	}

	//方法

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	public int getAge() {

		return age;

	}

	public void setAge(int age) {

		this.age = age;

	}

}

package com.lovo.innerclass;

//OutClass被称之为外部类

//所有的内部类都是一个独立的类，都拥有各自的属性、行为、构造等等

//每个内部类都会被编译成一篇独立的Class文件，文件名都带外部类类名$

public class OutClass {

	private int a;

	private static int b;

	//成员内部类

	//位置：直接写在外部类当中，位置和属性、构造、方法平行。

	//Class文件的名字：”外部类类名" + $ + "内部类类名”

	//可以有访问修饰符，代表是否可以在外部的类使用

	//不管带什么访问修饰符，本类（外部类）的所有方法都可以使用

	public class InnerClass1{

		public void innerMethod(){

			//内部类如果要调用外部类的属性，请书写下面格式：

			OutClass.this.a = 100;

		}

	}

	//静态内部类--成员内部类的特例

	//位置：直接写在外部类当中，位置和属性、构造、方法平行。

	//Class文件的名字：”外部类类名" + $ + "内部类类名”

	//可以有访问修饰符，代表是否可以在外部的类使用

	//不管带什么访问修饰符，本类（外部类）的所有方法都可以使用

	public static class InnerClass2{

		public void innerMethod(){

			//静态内部类只能使用外部类的静态属性或静态方法，请书写下面格式：

			OutClass.b = 100;

		}

	}

	public void test1(final int e){

		this.a = e;

		final int A = 1200;

		//局部内部类

		//位置：直接写在外部类的方法当中，其位置和局部变量平行。

		//Class文件的名字：”外部类类名" + $ + "序号" + "内部类类名”

		//没有访问修饰符，只能在所定义的外部类方法中使用

		class InnerClass3{

			public void innerMethod(){

				//局部内部类不能操作它所在方法的局部变量（非常特殊）

				System.out.println(OutClass.this.a);

				System.out.println(e);

			}

		}

		//直接产生内部类对象

		InnerClass3 in = new InnerClass3();

		in.innerMethod();

	}

	public void test2(){

		//匿名内部类--是局部内部类的特例

		//位置：直接写在外部类的方法当中，其位置和局部变量平行。

		//Class文件的名字：”外部类类名" + $ + "序号"

		//在产生对象的同时去定义这个类，只能用这一次

		new Object(){

			public void introduce(){

				//匿名内部类不能操作它所在方法的局部变量（非常特殊）

				System.out.println("我可不是Object哦~~~");

			}

		}.introduce();

	}

}

public class TestInnerClass {

	public static void main(String[] args) {

		// TODO Auto-generated method stub

		//在外部使用成员内部类--首先产生外部类对象、然后使用特殊语法外部类对象.new

		//产生内部类对象，然后再调用内部类对象的属性或方法（受访问修饰符限制）

		OutClass out = new OutClass();

		OutClass.InnerClass1 oi = out.new InnerClass1();

		oi.innerMethod();

		//在外部类使用静态内部类---可以用外部类类名直接访问操作，无需产生外部类对象

		OutClass.InnerClass2 oi2 = new OutClass.InnerClass2();

	}

}