一、类中的成分 – 代码块

基本介绍

• 代码块是类的 5 大成分之一（成员变量、构造器、方法、代码块、内部类）。

代码块分为两种：

• 静态代码块：

格式：static {} 
特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次。
作用：完成类的初始化，例如，对静态变量的初始化赋值。

//示例
public class CodeBlock {
  //静态资源
  public static String name;
  public static String[] pokeCards = new String[54];

  //静态代码块
  //基本作用：可以完成对类的静态资源的初始化
  static {
    System.out.println("===静态代码块执行了===");
    name = "可乐";
    pokeCards[0] = "A";
    pokeCards[0] = "2";
    .....
  }

  public static void main(String[] args){
    //目标：认识代码块，理解代码块的执行顺序、基本作用
    System.out.println("===main方法执行了===");
  }
}

执行结果：

===静态代码块执行了===
===main方法执行了===

• 实例代码块：

格式：{} 
特点：每次创建对象时，执行实例代码块，并在构造器前执行。
作用：和构造器一样，都是用于完成对象的初始化，例如，对实例对象进行初始化。

public class CodeBlock {
  //实例变量
  private String name;
  private String[] direction = new String[4];

  //实例代码块，无static修饰，属于对象
  //基本作用：初始化对象的实例资源
  {
    System.out.println("===实例代码块执行了===");
    name = "可乐"
    deirection[0] = "东"; 
    deirection[1] = "南"; 
    deirection[2] = "西"; 
    deirection[3] = "北"; 
  }

  public static void main(String[] args){
    //目标：认识代码块，理解代码块的执行顺序、基本作用
    System.out.println("===main方法执行了===");
    new CodeBlock();
  }
}

执行结果：

===main方法执行了===
===实例代码块执行了===

二、内部类

基本介绍

• 如果一个类定义在另一个类的内部，这个类就称为内部类。
• 使用场景：当一个类的内部，包含了一个完整的事物，且这个事物没有必要单独设计时，就可以把这个事物设计成内部类。

public class Car {
  //内部类
  public class Engine {
  }
}

1. 成员内部类

• 类中的一个普通成员，类似普通成员变量、成员方法。

//外部类
public class OuterClass {
  //外部类静态变量
  public static String name = "可乐";

  //外部类实例变量
  private int age;
  
  //外部类静态方法
  public static void test() {
  }

  //成员内部类，无static修饰，属于外部类对象持有的。
  public class InnerClass {
    public void show() {
      System.out.println("成员内部类的show方法");
      //成员内部类可以直接访问外部类的静态变量
      System.out.println(name);
      
      //成员内部类可以直接访问外部类的静态方法
      test();
      
      //成员内部类可以直接访问外部类的实例成员
      System.out.println(age);
    }
  }
}

public class InnerClassDemo {
  public static void main(String[] args){
    //目标：理解成员内部类的语法
    //成员内部类创建对象的格式
    //外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
    OuterClass.InnerClass oi = new OuterClass().new InnerClass();
    oi.show();
    //成员内部类中访问外部类成员的特点：
    //1、成员内部类可以直接访问外部类的静态成员，也可以直接访问外部类的实例成员
  }
}

1. 静态内部类

• 有 static 修饰的内部类，属于外部类自己持有。

//外部类
public class OuterClass {
  //静态内部类
  public static class InnerClass{
  }
}

// 语法
// 外部类名.内部类名 对象名 = new 外部类.内部类();
OuterClass.InnerClass oi = new OuterClass.InnerClass();

//外部类
public class OuterClass {
  //外部类静态变量
  public static String name = "可乐";

  //外部类实例变量
  private int age;
  
  //外部类静态方法
  public static void test() {
  }

  //静态内部类，有static修饰，属于外部类持有的。
  public static class InnerClass {
    public void show() {
      System.out.println("静态内部类的show方法");
      //静态内部类可以直接访问外部类的静态变量
      System.out.println(name);
      
      //静态内部类可以直接访问外部类的静态方法
      test();
      
      //静态内部类 不可以 直接访问外部类的实例成员
      System.out.println(age); 报错
    }
  }
}

public class InnerClassDemo {
  public static void main(String[] args){
    //目标：理解静态内部类的语法
    //静态内部类创建对象的格式
    //外部类名称.内部类名称 对象名 = new 外部类名称.内部类名称();
    OuterClass.InnerClass oi = new OuterClass.InnerClass();
    oi.show();
    //静态内部类中访问外部类成员的特点：
    //1、静态内部类可以直接访问外部类的静态成员，不可以直接访问外部类的实例成员
  }
}

1. 局部内部类 （了解）

• 局部内部类是定义在方法、代码块、构造器等执行体中的内部类。

public class OuterClass {
  pulic static void main(String[] args) {
  
  }
  
  public static void go() {
    //局部内部类
    class A{
    
    }

    abstract class B{
    
    }

    interface C{
    
    }
  }
}

1. 匿名内部类（重点）

• 一种特殊的局部内部类
• 所谓匿名：指的是程序员不需要为这个类声明名字，默认有个隐藏的名字。

// 语法
new 类 或 接口(参数值) {
  类体(一般是方法重写);
};

// 示例
new Animal() {
  @override
  public void eat() {
  }
};

• 特点：匿名内部类本质是一个子类，并会立即创建出一个子类对象。
• 作用：用于更方便的创建一个子类对象。

// 父类
public abstract class Animal {
  public abstract void cry();
}



// main
public class TestDemo{
  pulic static void main(String[] args) {
    // 匿名内部类 创建子类对象
    // 匿名内部类实际有名字，外部类名$编号.class（TestDemo$1.class）
    Animal a = new Animal(){
      @override
      public void cry(){
          System.out.println("cat~");
      }
    }
    
    a.cry();
  }
}

• 匿名内部类在开发中的常见形式
  通常作为一个对象参数传输给方法。
示例：学生、老师参加游泳比赛。

// main
public class TestDemo{
  pulic static void main(String[] args) {
    // 目标：理解匿名内部类在开发中的用途，通常作为一个对象参数传输给方法
  }
}

来源链接：https://www.cnblogs.com/SpockC/p/18984398