一: 内部类
定义在类体部,方法体部,甚至比方法体更小的代码块内部的类(if 语句里面等)
1.声明在类体部，方法体外，并且使用static修饰的内部类
2.访问特点可以类比静态变量和静态方法
3.脱离外部类的实例独立创建
在外部类的外部构建内部类的实例
new Outer.Inner();
在外部类的内部构建内部类的实例
new Inner();
4.静态内部类体部可以直接访问外部类中所有的静态成员，包含私有
[java]
view plain
copy
1. /**
2. * @author gress
3. *静态内部类
4. */
5. public class StaticInnerTest {
6. public static void main(String[] args) {
7.
8. new StaticOuter.StaticInner();
9. si.test2();
10. //StaticOuter.StaticInner.test();
11. "si.b = "+si.b);
12. "si.a = "+si.a);
13. // System.out.println("StaticOuter.b = "+StaticOuter.b); 这里报错
14. }
15.
16. }
17.
18. class StaticOuter {
19. private int a = 100;
20. private static int b = 150;
21. public static void test(){
22. "Outer static test ...");
23. }
24. public void test2(){
25. "Outer instabce test ...");
26. }
27.
28. static class StaticInner {
29. public int a = 200;
30. static int b =300;
31. public static void test(){
32. "Inner static test ...");
33. }
34. public void test2(){
35. "Inner instance test ...");
36. StaticOuter.test();
37. new StaticOuter().test2();
38. "StaticOuter.b = "+StaticOuter.b);
39. }
40. }
41. }
1.没有使用static修饰的内部类。
2.在成员内部类中不允许出现静态变量和静态方法的声明。
static只能用在静态常量的声明上。
3.成员内部类中可以访问外部类中所有的成员(变量，方法)，包含私有成员，如果在内部类中定义有和外部类同名的实例变量，访问：
OuterClass.this.outerMember;
4.构建内部类的实例，要求必须外部类的实例先存在
外部类的外部/外部类的静态方法：new Outer().new Inner();
外部类的实例方法：
new Inner();
this.new Inner();
[java]
view plain
copy
1. **
2. @author gress
3. * 实例内部类
4. *
5. */
6. class MemberOuter{
7.
8. private String s1 = "Outer InstanceMar";
9. private String s2 = "OuterStatic s2";
10. public void setS1(String s1) {
11. this.s1 = s1;
12. new MemberOuter().new MemberInner();
13. this.new MemberInner(); //此时MemberOuter已经实例化完成,所以可以使用this
14. new MemberInner().test2();
15. }
16. public static void test2 (){
17. new MemberOuter().new MemberInner();
18. /*this.new MemberInner();
19. * 此时MemberOuter没有实例化完成,所以不可以使用this
20. * static 是在MemberOuter构造器前使用,所以此时this不能使用
21. *
22. */
23.
24. }
25.
26.
27. class MemberInner{
28. "Inner instanceMae ";
29. static final String s4 = "static final MemberInner";
30.
31. void test2(){
32. " s1 =" + s1);
33. " Outter MemberOuter.this.s1 =" + MemberOuter.this.s1);
34. "s2 = "+s2);
35. }
36. }
37.
38. }
39.
40. public class MemberInnerTest {
41.
42. public static void main (String args []){
43. /* MemberOuter.MemberInner mm = new MemberOuter().new MemberInner();
44. mm.test2();*/
45.
46. new MemberOuter();
47. "");
48.
49.
50. }
51. }
1.定义在方法体，甚至比方法体更小的代码块中
2.类比局部变量。
3.局部内部类是所有内部类中最少使用的一种形式。
4.局部内部类可以访问的外部类的成员根据所在方法体不同。
如果在静态方法中：
可以访问外部类中所有静态成员，包含私有
如果在实例方法中：
可以访问外部类中所有的成员，包含私有。
局部内部类可以访问所在方法中定义的局部变量，但是要求局部变量必须使用final修饰。
[java] view plain copy
1. **
2. @author gress 局部内部类
3. *
4. */
5. public class LocalInnerTest {
6.
7. private int a = 1;
8. private static int b = 2;
9.
10. public void test() {
11. final int c = 3;
12. class LocalInner {
13. public void add1() {
14. "a= " + a);
15. "b= " + b);
16. "c= " + c);
17. }
18. }
19. new LocalInner().add1();
20. }
21.
22. static public void test2() {
23. final int d = 5;
24. class LocalInner2 {
25. public void add1() {
26. // System.out.println("a= " + a);
27. "b= " + b);
28. "c= " + d);
29. }
30. }
31. new LocalInner2().add1();
32. }
33.
34. public static void main(String args[]) {
35.
36. // LocalInnerTest() lc = new LocalInnerTest();
37. new LocalInnerTest().test2();
38. new LocalInnerTest().test();
39. }
40. } 1.没有名字的局部内部类。
2.没有class,interface,implements,extends关键字
3.没有构造器。
4.一般隐式的继承某一个父类或者实现某一个接口
5.吃货老师讲的一个很生动的例子
/**
* @author gress 匿名内部类,我只会使用一次的类
* 假如我想吃一个泡面,但我不可能建一个厂,制造一个流水线,生产一包泡面之后就在也不去使用这个泡面厂了
* 所以这里引申出匿名内部类 ,而我们建立的泡面厂就像这里构建的一个类Pencil 铅笔类一样
*/
[java] view plain copy
1. **
2. @author gress 匿名内部类,我只会使用一次的类
3. *
4. * 就假如我想吃一个泡面,但我不可能建一个厂,制造一个流水线,生产一包泡面之后就在也不去使用这个泡面厂了
5. * 所以这里引申出匿名内部类 ,而我们建立的泡面厂就像这里构建的一个类Pencil 铅笔类一样
6. */
7. interface Pen {
8. public void write();
9. }
10.
11. class Pencil implements Pen {
12. @Override
13. public void write() {
14. //铅笔 的工厂
15. }
16. }
17.
18. class Person {
19. public void user(Pen pen) {
20. pen.write();
21. }
22. }
23.
24. public class AnyInnerTest {
25. public static void main(String args[]) {
26. new Person();
27.
28. new Pen() {
29. @Override
30. public void write() {
31. "写子");
32. }
33. });
34. }
35.
36. }
