2023年5月22日，内部类，类加载机制
标签： 2023年5月22日，内部类，类加载机制 博客 51CTO博客
2023-05-24 18:24:13 196浏览
2023年5月22日，内部类，类加载机制，内部类1.成员内部类packageoutter_inner_01;importoutter_inner_01.Outter.Inner;publicclasstest01{/***知识点：成员内部类**需求：创建成员内部类的对象，并调用其方法**小结：*1.外部类和内部类不属于继承关系
内部类
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. 静态内部类
- 静态内部类只能调用外部类的静态属性
- 创建静态内部类的对象时，不需要创建外部类对象
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负责对类进行初始化
类的完整生命周期 ：加载、连接（验证、准备、解析）、初始化、使用、卸载
好博客就要一起分享哦！分享海报
此处可发布评论
评论（0）展开评论
暂无评论，快来写一下吧
展开评论
