初识JAVA中的代码块和内部类

在JAVA代码中，被“{  }”所括起来的代码被称为代码块

代码块可以分为四种：普通代码块、构造代码块（实例代码块）、静态代码块、同步代码块

普通代码块，一般指的时方法的方法体。

构造代码块，只在创建对象时才会执行，实例代码块会优先于构造方法执行，编译器会将实例代码块中的代码拷贝到每个构造方法第一条语句前

静态代码块，一般用于静态变量的初始化）

静态代码块，编译器在执行时只会执行一次，并且会在实例代码块之前使用

同步代码块，在对多线程的学习时再做讨论，可以参考学习Java编程中的4种代码块详解 - html中文网

内部类：

当一个事物中有一部分，需要相对完整的结构来表达，而这个部分只需对这个事物服务，那么使用内部类是一个非常好的选择。

在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

内部类和外部类共用一个java源文件，但是在经过编译后，内部类会形成单独的字节码文件

内部类大概分为：
成员内部类（static所修饰的成员内部类（静态内部类）和非static所修饰的成员内部类（普通内部类））

局部内部类、匿名内部类

普通内部类：
1. 外部类中的任何成员都可以在普通内部类方法中直接访问

2. 普通内部类所处的成员与外部类成员位置相同，也受public、private等访问限定符的约束

3. 在内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this. 同名成员 来访问

4. 普通内部类对象必须在先有外部类对象前提下才能创建

5. 普通内部类的非静态方法中包含了一个指向外部类对象的引用

6. 外部类中，不能直接访问内部类中的成员，如果要访问必须先要创建内部类的对象

class A{
    int sum=1;
    int num=1;
    InnerA innerA =new InnerA();
    class InnerA{
        int sum=0;
        int innernum=0;

        public void show(){
            System.out.println(sum);//0
            System.out.println(num);//1
            System.out.println(A.this.sum);//1
            System.out.println(innernum);//0
        }
    }
    public void display(){
        System.out.println(innerA.innernum);
    }
}


public class Demo2 {
    public static void main(String[] args) {

        A a =new A();
        A.InnerA innerA=new A().new InnerA();
        innerA.show();

        a.display();

    }
}

静态内部类：
1. 在静态内部类中只能访问外部类中的静态成员

2. 创建静态内部类对象时，不需要先创建外部类对象

class A{
    int sum=1;
    int num=1;
    static String string="A的静态成员变量";
    InnerA innerA =new InnerA();
    class InnerA{
        int sum=0;
        int innernum=0;

        public void show(){
            System.out.println(sum);//0
            System.out.println(num);//1
            System.out.println(A.this.sum);//1
            System.out.println(innernum);//0
        }
    }
    public void display(){
        System.out.println(innerA.innernum);
    }
    static class InnerA1{
        int sum=3;
        String string = "InnerA1的成员变量";
        public void show(){
            System.out.println(sum);
            System.out.println(string);
            System.out.println(A.string);
        }
    }
}


public class Demo2 {
    public static void main(String[] args) {

        A.InnerA1 innerA1 = new A.InnerA1();
        A a =new A();
        A.InnerA innerA=new A().new InnerA();
        innerA.show();

        a.display();
        innerA1.show();

    }
}

局部内部类：
定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用

1. 局部内部类只能在所定义的方法体内部使用

2. 不能被public、static等修饰符修饰

3. 编译器也有自己独立的字节码文件

4.局部内部类在外部没有创建其对象的语法

5.局部内部类访问外部类的局部变量（类的方法中的变量）：局部内部类中的变量一般用final来修饰，同时局部内部类，在调用外部类的局部变量时，局部变量一般要用final修饰。局部变量在方法被调用后会消失，但是局部对象并没有立马从堆上消失，还要使用那个变量，为了继续使用，将其使用final修饰，这样在堆上存储的是一个常量值。（JDK1.8后会自动添加）

补充final：

1.修饰变量与字段表示常量，不可修改

2.修饰类，表此类不可继承

3修饰方法，表该方法不可被重写

class B{
    int num = 0;
    final int sum = 1;
    public void createInnerB(int a){
        class InnerB{
            final int num = 4;
            public void InnerShow(){
                System.out.println(num);//4
                System.out.println(B.this.num);//0
                System.out.println(B.this.sum);//1
                System.out.println(a);//1
            }
        }
        InnerB innerB = new InnerB();
        innerB.InnerShow();
    }
}


  B b = new B();
        b.createInnerB(b.sum);

匿名内部类，在谈到抽象类和接口时我们继续讨论。