2023年5月22日，内部类，类加载机制

内部类

1. 成员内部类

package outter_inner_01;
import outter_inner_01.Outter.Inner;
public class test01 {
    /**
     * 知识点：成员内部类
     *
     * 需求：创建成员内部类的对象，并调用其方法
     *
     * 小结：
     * 		1.外部类和内部类不属于继承关系
     * 		2.创建成员内部类对象，必须先创建外部类对象
     * 		3.在成员内部类中可以调用外部类所有的属性
     */
    public static void main(String[] args) {
        Inner inner = new Outter().new Inner();
        inner.method();
    }
}

package outter_inner_01;

//外部类
public class Outter {

    private 	String str1 = "属性1";
    String str2 = "属性2";
    protected 	String str3 = "属性3";
    public 		String str4 = "属性4";
    final 		String str5 = "属性5";
    static 		String str6 = "属性6";
    static final String str7 = "属性7";

    //成员内部类
    class Inner{

        String str1 = "内部类属性";

        public void method(){
            System.out.println("成员内部类");
            System.out.println(str1);

            //Outter.this 表示外部类对象
            System.out.println(Outter.this.str1);
            System.out.println(str2);//Outter.this.str2
            System.out.println(str3);//Outter.this.str3
            System.out.println(str4);//Outter.this.str4
            System.out.println(str5);//Outter.this.str5
            System.out.println(str6);//Outter.str6
            System.out.println(str7);//Outter.str7
        }
    }

}

2. 静态内部类

1. 静态内部类只能调用外部类的静态属性
2. 创建静态内部类的对象时，不需要创建外部类对象

package outter_inner_02;
import outter_inner_02.Outter.Inner;

public class test01 {
    /**
     * 知识点：静态内部类
     *
     * 需求：创建静态内部类的对象，并调用其方法
     *
     * 小结：
     * 		1.静态内部类只能调用外部类的静态属性
     * 		2.创建静态内部类对象时，不需要创建外部类对象
     */
    public static void main(String[] args) {

        Inner inner = new Outter.Inner();
        inner.method();

    }
}

package outter_inner_02;

//外部类
public class Outter {

    static 		String str1 = "属性6";
    static final String str2 = "属性7";

    //静态内部类
    static class Inner{

        public void method(){
            System.out.println("静态内部类");
            System.out.println(str1);//Outter.str1
            System.out.println(str2);//Outter.str2
        }
    }

}

3. 接口内部类

接口内部类的使用创建方式和静态内部类的一至（public、static）

package outter_inner_03;
import outter_inner_03.Outter.Inner;
public class test01 {
    /**
     * 知识点：接口内部类
     *
     * 需求：创建接口内部类的对象，并调用其方法
     *
     * 小结：
     * 		接口内部类的创建方式和静态内部类的方式一致
     */
    public static void main(String[] args) {

        Inner inner = new Outter.Inner();
        inner.method();

    }
}

package outter_inner_03;

public interface Outter {
    class Inner{
        public void method(){
            System.out.println("接口内部类");
        }
    }
}

4. 局部内部类

package outter_inner_04;

public class test01 {
    /**
     * 知识点：局部内部类
     *
     * 需求：调用局部内部类中的方法
     *
     * 小结：
     * 		局部内部类的作用范围在该方法中
     */
    public static void main(String[] args) {

        Outter outter = new Outter();
        outter.outMethod();
    }
}

package outter_inner_04;

public class Outter {
    public void outMethod(){

        //局部内部类
        class Inner{
            public void method(){
                System.out.println("局部内部类");
            }
        }

        //创建局部内部类的对象
        Inner inner = new Inner();
        //调用方法
        inner.method();
    }
}

5. 匿名内部类

1. new A() //抽象类

package outter_inner_05;

public class test01 {
    /**
     * 知识点：匿名内部类
     * 应用场景：A类（抽象类）的子类只创建一次时，就没必要创建子类，直接使用new A()即可。
     * @param args
     */
    public static void main(String[] args) {
        //创建的是匿名内部类的对象
        A a = new A(){

            @Override
            public void method() {

            }
        };
    }
}

package outter_inner_05;

public abstract class A {
    public abstract void method();
}

2. new I1() //接口

package outter_inner_06;

public class test01 {
    /**
     * 知识点：匿名内部类
     *应用场景：I1接口的实现类对象只创建一次，就没有必要直接创建实现类，直接使用匿名内部类
     * @param args
     */
    public static void main(String[] args) {
        I1 i1 = new I1() {
            @Override
            public void method() {

            }
        };
    }
}

package outter_inner_06;

public interface I1 {
    public void method();
}

总结

分类：

成员内部类 Outter$Inner.class

静态内部类 Outter$Inner.class

接口内部类 Outter$Inner.class

局部内部类 Outter$1Inner.class

匿名内部类 Test01$1.class

应用场景：

• B类的对象只在A类中使用，并且B类使用到A类所有的属性，就可以将B类设置为A类的成员内部类
• B类的对象只在A类中使用，并且B类使用到A类的静态属性，就可以将B类设置为A类的静态内部类
• B类对象只在I1接口中使用，就可以将B类设置为I1接口的接口内部类
• B类对象只在A类的method方法中使用，就可以将B类设置为A类method方法中的局部变量
• 抽象类的子类或者接口的实现类只new了一次对象，就直接使用匿名内部类

类加载机制

初识类加载过程

使用某个类时，如果该类的class文件没有加载到内存时，则系统会通过以下三个步骤来对该类进行初始化

1.类的加载（Load） → 2.类的连接（Link） → 3.类的初始化（Initialize）

• 类的加载（Load）：将类的class文件读入内存，并为之创建一个java.lang.Class的对象，此过程由类加载器（ClassLoader ）完成
• 类的连接（Link）：将类中的数据加载到各个内存区域中
• 类的初始化（Initialize）：JVM负责对类进行初始化

类的完整生命周期 ：加载、连接（验证、准备、解析）、初始化、使用、卸载