Java中内部类分四种:成员内部类、局部内部类、静态内部类和匿名内部类。
要注意静态内部类的调用方式与其他不同,采用的是类似调用类中的静态属性、静态方法的方式
Multi Level
调用不同类中的相同的名字的属性
1 /**
2 * the output is:3 * x = 234 * this.x = 15 * ShadowTest.this.x = 06 */
7 public classShadowTest {8 public int x = 0;9
10 classFirstLevel {11 public int x = 1;12
13 void methodInFirstLevel(intx) {14 System.out.println("x = " +x);15 System.out.println("this.x = " + this.x);16 System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);17 }18 }19
20 public static voidmain(String... args) {21 ShadowTest st = newShadowTest();22 ShadowTest.FirstLevel fl = st.newFirstLevel();23 fl.methodInFirstLevel(23);24 }25 }
View Code
Inner Class
成员内部类: 即作为外部类的一个成员存在,与外部类的属性、方法并列。上述的Multi Level也是成员内部类
内部类作为外部类的成员,可以访问外部类的私有成员或属性
用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限
注意:成员内部类中不能定义静态变量,但可以访问外部类的所有成员,内部类是一个编译时的概念,一旦编译成功,就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类
1 /**
2 *The output is: 0 2 4 6 8 10 12 143 */
4 public classDataStructure {5
6 //Create an array
7 private final static int SIZE = 15;8 private int[] arrayOfInts = new int[SIZE];9
10 publicDataStructure() {11 //fill the array with ascending integer values
12 for (int i = 0; i < SIZE; i++) {13 arrayOfInts[i] =i;14 }15 }16
17 public voidprintEven() {18
19 //Print out values of even indices of the array
20 DataStructureIterator iterator = this.newEvenIterator();21 while(iterator.hasNext()) {22 System.out.print(iterator.next() + " ");23 }24 System.out.println();25 }26
27 interface DataStructureIterator extends java.util.Iterator{ }28
29 //Inner class implements the DataStructureIterator interface,30 //which extends the Iterator interface
31
32 private class EvenIterator implementsDataStructureIterator {33
34 //Start stepping through the array from the beginning
35 private int nextIndex = 0;36
37 public booleanhasNext() {38
39 //Check if the current element is the last in the array
40 return (nextIndex <= SIZE - 1);41 }42
43 publicInteger next() {44
45 //Record a value of an even index of the array
46 Integer retValue =Integer.valueOf(arrayOfInts[nextIndex]);47
48 //Get the next even element
49 nextIndex += 2;50 returnretValue;51 }52 }53
54 public static voidmain(String s[]) {55
56 //Fill the array with integer values and print out only57 //values of even indices
58 DataStructure ds = newDataStructure();59 ds.printEven();60 }61 }
View Code
Local Class
局部内部类: 即在方法中定义的内部类,与局部变量类似,在局部内部类前不加修饰符public或private,其范围为定义它的代码块。
注意:局部内部类中不可定义静态变量,可以访问外部类的局部变量(即方法内的变量),但是变量必须是final的
在类外不可直接生成局部内部类(保证局部内部类对外是不可见的)。要想使用局部内部类时需要生成对象,对象调用方法,在方法中才能调用其局部内部类。通过内部类和接口达到一个强制的弱耦合,用局部内部类来实现接口,并在方法中返回接口类型,使局部内部类不可见,屏蔽实现类的可见性
1 /**
2 *output: First number is 12345678903 * Second number is invalid4 */
5 public classLocalClassExample {6
7 static String regularExpression = "[^0-9]";8
9 public static voidvalidatePhoneNumber(10 String phoneNumber1, String phoneNumber2) {11
12 final int numberLength = 10;13
14 //Valid in JDK 8 and later:15
16 //int numberLength = 10;
17
18 classPhoneNumber {19
20 String formattedPhoneNumber = null;21
22 PhoneNumber(String phoneNumber){23 //numberLength = 7;
24 String currentNumber =phoneNumber.replaceAll(25 regularExpression, "");26 if (currentNumber.length() ==numberLength)27 formattedPhoneNumber =currentNumber;28 else
29 formattedPhoneNumber = null;30 }31
32 publicString getNumber() {33 returnformattedPhoneNumber;34 }35
36 //Valid in JDK 8 and later:37
38 //public void printOriginalNumbers() {39 //System.out.println("Original numbers are " + phoneNumber1 +40 //" and " + phoneNumber2);41 //}
42 }43
44 PhoneNumber myNumber1 = newPhoneNumber(phoneNumber1);45 PhoneNumber myNumber2 = newPhoneNumber(phoneNumber2);46
47 //Valid in JDK 8 and later:48
49 //myNumber1.printOriginalNumbers();
50
51 if (myNumber1.getNumber() == null)52 System.out.println("First number is invalid");53 else
54 System.out.println("First number is " +myNumber1.getNumber());55 if (myNumber2.getNumber() == null)56 System.out.println("Second number is invalid");57 else
58 System.out.println("Second number is " +myNumber2.getNumber());59
60 }61
62 public static voidmain(String... args) {63 validatePhoneNumber("123-456-7890", "456-7890");64 }65 }
View Code
Static Class
1 packagelearn.JavaBasics.Class;2
3 public classOuter {4 private static int i=1;5 private int j=10;6
7 public static voidouter_f1(){8 System.out.println("This is outer class");9 }10
11 public voidouter_f2() {12 System.out.println("This is outer class");13 }14
15 static classInner {16 static int inner_i=100;17 int inner_j = 200;18
19 static voidinner_f1() {20 System.out.println("Outer.i:"+i);//静态内部类只能访问外部类的静态成员
21 outer_f1();//包括静态变量和静态方法
22 }23
24 voidinner_f2() {25
26 }27 }28
29 public voidouter_f3(){30 System.out.println(Inner.inner_i);//外部类访问内部类的静态成员:内部类.静态成员
31 Inner inner = newInner();32 inner.inner_f2();33 }34
35 public static voidmain(String[] args) {36 //TODO Auto-generated method stub
37 newOuter().outer_f3();38
39 new Outer.Inner().inner_f2();//匿名调用内部的静态类
40 }41
42 }
View Code
静态内部类: 静态内部类定义在类中,任何方法外,用static定义。
注意:静态内部类中可以定义静态或者非静态的成员,静态内部类可以用public,protected,private修饰
Anonymous Class
A a = new A(),a就是类名,如果不需要类名a就可以调用类A中的方法,则是匿名类, 如:new A().toString();
还有接口
1 public classHelloWorldAnonymousClasses {2
3 interfaceHelloWorld {4 public voidgreet();5 public voidgreetSomeone(String someone);6 }7
8 public voidsayHello() {9
10 class EnglishGreeting implementsHelloWorld {11 String name = "world";12 public voidgreet() {13 greetSomeone("world");14 }15 public voidgreetSomeone(String someone) {16 name =someone;17 System.out.println("Hello " +name);18 }19 }20
21 HelloWorld englishGreeting = newEnglishGreeting();22
23 HelloWorld frenchGreeting = newHelloWorld() {24 String name = "tout le monde";25 public voidgreet() {26 greetSomeone("tout le monde");27 }28 public voidgreetSomeone(String someone) {29 name =someone;30 System.out.println("Salut " +name);31 }32 };33
34 HelloWorld spanishGreeting = newHelloWorld() {35 String name = "mundo";36 public voidgreet() {37 greetSomeone("mundo");38 }39 public voidgreetSomeone(String someone) {40 name =someone;41 System.out.println("Hola, " +name);42 }43 };44 englishGreeting.greet();45 frenchGreeting.greetSomeone("Fred");46 spanishGreeting.greet();47 }48
49 public static voidmain(String... args) {50 HelloWorldAnonymousClasses myApp =
51 newHelloWorldAnonymousClasses();52 myApp.sayHello();53 }54 }
View Code
类中的对象的初始化顺序
1 public classInitializeDemo {2 private static int k = 1;3 private static InitializeDemo t1 = new InitializeDemo("t1");4 private static InitializeDemo t2 = new InitializeDemo("t2");5 private static int i = print("i");6 private static int n = 99;7 static{8 print("静态块");9 }10 private int j = print("j");11 {12 print("构造块");13 }14 publicInitializeDemo(String str) {15 System.out.println((k++) + ":" + str + " i=" + i + " n=" +n);16 ++i;17 ++n;18 }19 public static intprint(String str) {20 System.out.println((k++) + ":" + str + " i=" + i + " n=" +n);21 ++n;22 return ++i;23 }24 public static voidmain(String args[]) {25 new InitializeDemo("init");26 }27 }
View Code
1.静态属性和静态代码块都是在类加载的时候初始化和执行,两者的优先级别是一致的,
且高于非静态成员,执行按照编码顺序。
2.非静态属性和匿名构造器在所有的构造方法之前执行,两者的优先级别一致,执行按照编码顺序。
3.以上执行完毕后执行构造方法中的代码。
读者仔细揣摩上面三条句子,也就是Java对象初始化的顺序,也就明白以上程序的输出结果为什么如下:
1:j i=0 n=0
2:构造块 i=1 n=1
3:t1 i=2 n=2
4:j i=3 n=3
5:构造块 i=4 n=4
6:t2 i=5 n=5
7:i i=6 n=6
8:静态块 i=7 n=99
9:j i=8 n=100
10:构造块 i=9 n=101
11:init i=10 n=102
如果还是没有明白,就看下面详解,一下详解的顺序就是按照上文的核心理念的顺序来执行的(建议读者把自己带入JVN的世界里,跟着JVM一步一步往下面走):
1.运行main方法的时候,JVM会调用ClassLoader来加载InitializeDemo类,那么一起源于这次加载。
2.上面有四个静态属性,所以会按顺序逐一初始化这四个静态属性。
3.private static int k = 1; 此时将k初始化为1。
4.private static InitializeDemo t1 = new InitializeDemo("t1");创建InitializeDemo对象,
那么按照核心理念中的顺序,先执行private int j = print("j");,打印出j,然后执行构造
块,最后执行构造方法。
5.private static InitializeDemo t2 = new InitializeDemo("t2");同步骤4。
6.private static int i = print("i");打印i。
7.private static int n = 99;直到这一步,n才被赋值为99,之前是从默认的0开始++的。
8.静态属性初始化完毕,代码走到静态块,打印出静态块,此时n=99。
9.静态属性和静态块执行完毕,然后执行main方法中的代码new InitializeDemo("init");
10.main方法中创建对象,先初始化非静态属性,private int j = print("j");打印j,
然后执行构造块,最后执行构造方法。
不知道我解说清楚了没有,只要把握住核心理念,碰到在复杂的问题也都不会怕了。
用一个公式概括一下Java对象初始化执行优先级别:
(静态属性=静态代码块)> (非静态属性 = 构造块)> 构造方法
总结一下核心理念:
1.静态只在类加载的时候执行,且执行一次。
2.非静态只在实例化的时候执行,且每次实例化都执行。
3.静态在非静态之前执行。
4.静态属性和静态块的执行顺序取决于编码顺序,对它们一视同仁。
5.非静态属性和构造块的执行顺取决于编码顺序,对它们也一视同仁。
6.最后执行构造方法。
上面的总结有点绕对吧,问题进一步简化的话,就更好理解了:
读者将静态代码块视为一个静态属性,将构造块视为一个非静态属性,那么问题简化到了这种路线“静态属性-->非静态属性-->构造方法“