在本次博客之后，进行的就是面向对象的高级操作。何为高级呢？只是在基础之上的扩充，所以要把基础知识掌握牢固才有可能进一步提高。为了完成质疑任务，本周剩下的时间全部用来复习，温故而知新。
在开始主题内部类之前，先简单介绍一下代码块的基本概念。
//代码块的测试
public class Test
{
public static void main(String[] args)
{
{
int x = 10;<span style="white-space:pre"> </span>
System.out.println("x = " + x);
}
int x = 100;
System.out.println("x = " + x);
}
} 解释：上述代码int实例化，首先对x赋予局部变量，在基本代码块之后，进入全局变量。
2.构造块：在类中定义的代码块。构造块优先于构造方法执行，每个对象实例化之后，都会重复执行构造块和构造方法。
//代码块的测试
class A
{
{
System.out.println("这是构造块");
}
public A()
{
System.out.println("hello world");
}
}
public class Test
{
public static void main(String[] args)
{
new A();
new A();
new A();
}
} 
3.静态代码块。使用static定义的块，他优先于构造块执行，而且不管多少个实例化对象，他只执行一次。
//代码块的测试
class A
{
static
{
System.out.println("这是静态块");
}
{
System.out.println("这是构造块");
}
public A()
{
System.out.println("hello world");
}
}
public class Test
{
public static void main(String[] args)
{
new A();
new A();
new A();
}
} 
在主类之中定义的静态块优先于主方法执行。\
//代码块的测试
class A
{
static
{
System.out.println("这是静态块");
}
{
System.out.println("这是构造块");
}
public A()
{
System.out.println("hello world");
}
}
public class Test
{
static
{
System.out.println("@@@@@@@@@@@");
}
public static void main(String[] args)
{
new A();
new A();
new A();
}
} 
上面的这一程序提供了一个信息，可以不使用main()方法就能输出信息，通过代码块来实现。
使用情况：
1.最早使用在图形界面
2.开源框架
概念：在一个类的内部定义其他操作类
格式：
Class 外部类
{
属性方法
Class 内部类
｛
属性方法
｝
}
//内部类的测试
class Outer
{
private String name1 = "hello";
class Inner
{
private String name2 = "world";
public void print()
{
System.out.println(name1);<span style="white-space:pre"> </span>//调用外部类属性<span style="white-space:pre"> </span>
<span style="background-color: rgb(255, 255, 51);">//System.out.println(Outer.this.name1);</span>
}
}
public void f()<span style="white-space:pre"> </span><span style="font-family: 宋体;"> </span><span style="font-family: 宋体;">//</span><span style="font-family: 宋体;">外部类的方法，进行实例内部类并调用内部类的方法</span><span style="white-space:pre">
</span> {
Inner in = new Inner();
in.print();
System.out.println(in.name2);<span style="white-space:pre"> </span>//外部类方法调用内部类
}
}
public class Test
{
public static void main(String[] args)
{
new Outer().f();
}
} 
优点：内外部类的私有操作可以互相访问
缺点：破坏了类的结构
之前内部类的操作都是产生了外部类之后通过外部类提供的方法提供实例化内部类，才能进行内部类的方法的调用，能否在外部产生内部类的实例？
编译程序之后出现了 Outer$Inner.class
$在程序之中可以理解为”.”，即内部类的名称为： “外部类.内部类”。
由于内部类的访问需要操作外部类的资源和属性，所以要想在外部实例化内部类的对象，格式：
外部类.内部类 内部类对象名= new 外部类().new内部类()
//内部类的测试
class Outer
{
private String name1 = "hello";
class Inner
{
//内部类的方法
public void print()
{
System.out.println(Outer.this.name1);
}
}
}
public class Test
{
public static void main(String[] args)
{
//外部类.内部类 内部类对象名= new 外部类().new内部类()
Outer.Inner in = new Outer().new Inner();
in.print();
}
}
可以使用static声明内部类，但是不能声明外部类
例如 static A{ } 错误的提示： 错误: 此处不允许使用修饰符static
如果一个内部类用static声明 则成为了外部类
声明格式：
外部类.内部类 内部类对象名= new 外部类.内部类()
//内部类的测试
class Outer
{
private static String name1 = "hello"; //内部类变成static 只能访问static资源
static class Inner
{
//内部类的方法
public void print()
{
System.out.println(name1);
}
}
}
public class Test
{
public static void main(String[] args)
{
//static内部类则他又变成了外部类
Outer.Inner in = new Outer.Inner();
in.print();
}
}
理论上内部类可以在任何地方定义，大多数在方法之中。在方法中定义内部类，可以直接访问外部类的属性
//内部类的测试
class Outer
{
private static String name1 = "hello"; //内部类变成static 只能访问static资源
//外部类的方法
public void fun()
{
//在方法中定义内部类
class Inner
{
//内部类的方法
public void print()
{
System.out.println(Outer.this.name1);
}
}
Inner in = new Inner();
in.print();
}
}
public class Test
{
public static void main(String[] args)
{
new Outer().fun();
}
} 
//内部类的测试
class Outer
{
private static String name1 = "hello"; //内部类变成static 只能访问static资源
//外部类的方法
public void fun(final int x)
{
final String name2 = "world";
//在方法中定义内部类
class Inner
{
//内部类的方法
public void print()
{
System.out.println(Outer.this.name1);
System.out.println(x);
System.out.println(name2);
}
}
Inner in = new Inner();
in.print();
}
}
public class Test
{
public static void main(String[] args)
{
new Outer().fun(1);
}
} 
今天到此结束，祝大家健健康康，快快乐乐。
原文地址：http://blog.csdn.net/baobeizhanshen/article/details/41874811
