java高薪之路__001_类

Java中内部类分四种：成员内部类、局部内部类、静态内部类和匿名内部类。
要注意静态内部类的调用方式与其他不同，采用的是类似调用类中的静态属性、静态方法的方式

Multi Level

调用不同类中的相同的名字的属性

 /**
  * the output is:
  * x = 23
  * this.x = 1
  * ShadowTest.this.x = 0
  */
 public class ShadowTest {
     public int x = 0;

     class FirstLevel {
         public int x = 1;

         void methodInFirstLevel(int x) {
             System.out.println("x = " + x);
             System.out.println("this.x = " + this.x);
             System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
         }
     }

     public static void main(String... args) {
         ShadowTest st = new ShadowTest();
         ShadowTest.FirstLevel fl = st.new FirstLevel();
         fl.methodInFirstLevel(23);
     }
 }

Inner Class

成员内部类： 即作为外部类的一个成员存在，与外部类的属性、方法并列。上述的Multi Level也是成员内部类

内部类作为外部类的成员，可以访问外部类的私有成员或属性

用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限

注意：成员内部类中不能定义静态变量,但可以访问外部类的所有成员,内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类

 /**
 *The output is: 0 2 4 6 8 10 12 14
 */
 public class DataStructure {

     // Create an array
     private final static int SIZE = 15;
     private int[] arrayOfInts = new int[SIZE];

     public DataStructure() {
         // fill the array with ascending integer values
         for (int i = 0; i < SIZE; i++) {
             arrayOfInts[i] = i;
         }
     }

     public void printEven() {

         // Print out values of even indices of the array
         DataStructureIterator iterator = this.new EvenIterator();
         while (iterator.hasNext()) {
             System.out.print(iterator.next() + " ");
         }
         System.out.println();
     }

     interface DataStructureIterator extends java.util.Iterator<Integer> { } 

     // Inner class implements the DataStructureIterator interface,
     // which extends the Iterator<Integer> interface

     private class EvenIterator implements DataStructureIterator {

         // Start stepping through the array from the beginning
         private int nextIndex = 0;

         public boolean hasNext() {

             // Check if the current element is the last in the array
             return (nextIndex <= SIZE - 1);
         }        

         public Integer next() {

             // Record a value of an even index of the array
             Integer retValue = Integer.valueOf(arrayOfInts[nextIndex]);

             // Get the next even element
             nextIndex += 2;
             return retValue;
         }
     }

     public static void main(String s[]) {

         // Fill the array with integer values and print out only
         // values of even indices
         DataStructure ds = new DataStructure();
         ds.printEven();
     }
 }

Local Class

局部内部类： 即在方法中定义的内部类，与局部变量类似，在局部内部类前不加修饰符public或private，其范围为定义它的代码块。
注意：局部内部类中不可定义静态变量，可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的

在类外不可直接生成局部内部类（保证局部内部类对外是不可见的）。要想使用局部内部类时需要生成对象，对象调用方法，在方法中才能调用其局部内部类。通过内部类和接口达到一个强制的弱耦合，用局部内部类来实现接口，并在方法中返回接口类型，使局部内部类不可见，屏蔽实现类的可见性

 /**
 *output: First number is 1234567890
 * Second number is invalid
 */
 public class LocalClassExample {

     static String regularExpression = "[^0-9]";

     public static void validatePhoneNumber(
         String phoneNumber1, String phoneNumber2) {

         final int numberLength = 10;

         // Valid in JDK 8 and later:

         // int numberLength = 10;

         class PhoneNumber {

             String formattedPhoneNumber = null;

             PhoneNumber(String phoneNumber){
                 // numberLength = 7;
                 String currentNumber = phoneNumber.replaceAll(
                   regularExpression, "");
                 if (currentNumber.length() == numberLength)
                     formattedPhoneNumber = currentNumber;
                 else
                     formattedPhoneNumber = null;
             }

             public String getNumber() {
                 return formattedPhoneNumber;
             }

             // Valid in JDK 8 and later:

 //            public void printOriginalNumbers() {
 //                System.out.println("Original numbers are " + phoneNumber1 +
 //                    " and " + phoneNumber2);
 //            }
         }

         PhoneNumber myNumber1 = new PhoneNumber(phoneNumber1);
         PhoneNumber myNumber2 = new PhoneNumber(phoneNumber2);

         // Valid in JDK 8 and later:

 //        myNumber1.printOriginalNumbers();

         if (myNumber1.getNumber() == null)
             System.out.println("First number is invalid");
         else
             System.out.println("First number is " + myNumber1.getNumber());
         if (myNumber2.getNumber() == null)
             System.out.println("Second number is invalid");
         else
             System.out.println("Second number is " + myNumber2.getNumber());

     }

     public static void main(String... args) {
         validatePhoneNumber("123-456-7890", "456-7890");
     }
 }

 Static Class

 package learn.JavaBasics.Class;

 public class Outer {
     private static int i=1;
     private int j=10;

     public static void outer_f1(){
         System.out.println("This is outer class");
     }

     public void outer_f2() {
         System.out.println("This is outer class");
     }

     static class Inner {
         static int inner_i=100;
         int inner_j = 200;

         static void inner_f1() {
             System.out.println("Outer.i:"+i);//静态内部类只能访问外部类的静态成员
             outer_f1();//包括静态变量和静态方法
         }

         void inner_f2() {

         }
     }

     public void outer_f3(){
         System.out.println(Inner.inner_i);//外部类访问内部类的静态成员：内部类.静态成员
         Inner inner = new Inner();
         inner.inner_f2();
     }

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         new Outer().outer_f3();

         new Outer.Inner().inner_f2();//匿名调用内部的静态类
     }

 }

静态内部类： 静态内部类定义在类中，任何方法外，用static定义。
注意：静态内部类中可以定义静态或者非静态的成员,静态内部类可以用public,protected,private修饰

Anonymous Class

A a = new A(), a就是类名，如果不需要类名a就可以调用类A中的方法，则是匿名类， 如：new A().toString();
还有接口

 public class HelloWorldAnonymousClasses {

     interface HelloWorld {
         public void greet();
         public void greetSomeone(String someone);
     }

     public void sayHello() {

         class EnglishGreeting implements HelloWorld {
             String name = "world";
             public void greet() {
                 greetSomeone("world");
             }
             public void greetSomeone(String someone) {
                 name = someone;
                 System.out.println("Hello " + name);
             }
         }

         HelloWorld englishGreeting = new EnglishGreeting();

         HelloWorld frenchGreeting = new HelloWorld() {
             String name = "tout le monde";
             public void greet() {
                 greetSomeone("tout le monde");
             }
             public void greetSomeone(String someone) {
                 name = someone;
                 System.out.println("Salut " + name);
             }
         };

         HelloWorld spanishGreeting = new HelloWorld() {
             String name = "mundo";
             public void greet() {
                 greetSomeone("mundo");
             }
             public void greetSomeone(String someone) {
                 name = someone;
                 System.out.println("Hola, " + name);
             }
         };
         englishGreeting.greet();
         frenchGreeting.greetSomeone("Fred");
         spanishGreeting.greet();
     }

     public static void main(String... args) {
         HelloWorldAnonymousClasses myApp =
             new HelloWorldAnonymousClasses();
         myApp.sayHello();
     }
 }

类中的对象的初始化顺序

 public class InitializeDemo {
     private static int k = 1;
     private static InitializeDemo t1 = new InitializeDemo("t1");
     private static InitializeDemo t2 = new InitializeDemo("t2");
     private static int i = print("i");
     private static int n = 99;
     static {
         print("静态块");
     }
     private int j = print("j");
     {
         print("构造块");
     }
     public InitializeDemo(String str) {
         System.out.println((k++) + ":" + str + "   i=" + i + "    n=" + n);
         ++i;
         ++n;
     }
     public static int print(String str) {
         System.out.println((k++) + ":" + str + "   i=" + i + "    n=" + n);
         ++n;
         return ++i;
     }
     public static void main(String args[]) {
         new InitializeDemo("init");
     }
 }

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.最后执行构造方法。

上面的总结有点绕对吧，问题进一步简化的话，就更好理解了：

读者将静态代码块视为一个静态属性，将构造块视为一个非静态属性，那么问题简化到了这种路线“静态属性-->非静态属性-->构造方法“