一、代码块

4.1普通代码块

public static void main(String[] args) {
        {
            System.out.println("haha");
        }
    }

直接定义在方法中的代码块，即为普通代码块

4.2静态代码块

用于static修饰的代码块即为静态代码块，可初始化静态成员变量。

class Student {
    public static String classHome;
    static {
        classHome = "001";
    }
}
public static void main(String[] args) {
        System.out.println(Student.classHome);
    }

我们可以发现我们为new对象，直接打印static成员变量时，static成员变量已经经过static代码块赋值.

==1.静态代码块在程序中只会执行一次(用于静态变量初始化)==
==2.静态成员变量时类的属性，JVM在加载类时开辟空间并初始化==
==3.一个类如果有多个静态代码块，编译时，按照顺序执行==

4.3实例代码块

实例代码块又称构造代码块，顾名思义是用来初始化普通成员变量的

class Student {
    public String name;
    public int age;
    {
        name = "张三";
        age = 18;
    }
}
 public static void main(String[] args) {
        Student student = new Student();
        System.out.println("name: "+student.name+" age: "+student.age);
  }

我们可以发现我们在创建对象时实例代码块执行对对象进行赋值，因为它是依赖每一个对象的，因此会多次执行。

二、内部类

5.1什么是内部类

简单地说就是:定义在一个类内部的类

class OutClass{//外部类
   class InnerClass{//内部类
   }
}

注意: 虽然内部类外部类在一个java文件，但编译后会形成两个不同的字节码文件.

5.2静态内部类

class OutClass {
    public int size;
    static int age;
    public void funcSize() {
        System.out.println(size);
    }
    public static void funcAge() {
        System.out.println(age);
    }
    static class InnerClass {
    //静态内部类只能访问外部的静态成员和方法.
        public void funInner() {
            age = 18;
            funcAge();
        }
    }

    public static void main(String[] args) {
        OutClass.InnerClass innerClass = new OutClass.InnerClass();
        innerClass.funInner();
    }
}

==1.在静态内部类只能访问外部类中的静态成员和方法==
==2.创建内部类对象时，不需要先创建外部类对象==

在内部类如何访问外部类的成员和方法？

 static class InnerClass {
        public void funInner() {
            OutClass outClass = new OutClass();
            outClass.size = 20;
            outClass.funcSize();
            age = 18;
            funcAge();
        }
    }

我们可以通过外部类对象在内部类访问外部类成员变量和方法.

5.3实例内部类

class OutClass {
    public int size;
    static int age;
    public  void funcSize() {
        System.out.println("size: "+size);
    }
    public static void funcAge() {
        System.out.println("age: "+age);
    }
    class InnerClass {
        String name;
        public void funcInnerClass() {
            size = 20;
            age = 18;
            name = "张三";
            funcSize();
            funcSize();
            System.out.println("name: "+name);
        }
    }

当内部类中的成员变量和外部类重名了，怎么访问？

class InnerClass {
        int size;
        public void funcInnerClass() {
            OutClass.this.size = 20;
            age = 18;
            funcSize();
            funcAge();
        }
    }

可以通过外部类名.this.成员变量名访问.

1. 外部类中的任何成员都可以在实例内部类方法中直接访问
2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名

称.this.同名成员 来访问

1. 实例内部类对象必须在先有外部类对象前提下才能创建
2. 实例内部类的非静态方法中包含了一个指向外部类对象的引用
3. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

5.4局部内部类

class OutClass {
    int size = 20;
    public void funcSize() {
        int age = 18;
        class InnerClass{
            public void funcInnerClass() {
                System.out.println(size);
                System.out.println(age);
            }
        }
        InnerClass innerClass = new InnerClass();
        innerClass.funcInnerClass();
    }
  }

局部内部类是定义在外部类方法体或者普通代码块中的内部类.

==1.局部内部类只能使用在所定义的方法体内部==
==2.不能被public,static修饰==
==3.编译器有自己的字节码文件，命名为：外部类＄内部类.class==