Java内部类基础知识点 内部类基本操作 匿名内部类使用

导航

内部类的概念
内部类的分类
内部类的定义格式
成员内部类的访问
内部类的同名变量访问方法
局部内部类定义
局部内部类final问题
匿名内部类
匿名内部类的注意事项
类的权限修饰符总结

内部类的概念

​ 如果一个事物的内部仍包含另一个事物，内部事物还在访问外部事物的内容时，这个类内部就可以包含另一个类

• 身体和心脏的关系
• 汽车和发动机的关系

内部类的分类

• 成员内部类 : 属于外部类的成员
• 局部内部类(包含匿名内部类 )：类定义在方法内部，只有当前所属的方法才能使用它

内部类的定义格式

//外部类
public class Body{
    
    
    //外部类成员变量
    private String name="name";
    
    //成员内部类
    public class Heart{
    
    
        public void beat(){
    
    
            System.out.println("心脏跳动" + name);
        }
    }
    
    public void bodyMethod(){
    
    
        System.out.println("外部类方法");
    }
}

内部类可以随意访问任意外部类成员，外部类访问内部类需要创建内部类对象

成员内部类的访问

• 间接访问：通过外部类方法，方法中使用内部类
• 直接访问：外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();

public class Body {
    
    
    //外部类成员变量
    private String name;
    //外部类构造器
    public Body(String name ){
    
    
        this.name = name;
    }
    //成员内部类
    public class Heart{
    
    
        //内部类成员方法
        public void innerMethod(){
    
    
            System.out.println(name + "心脏跳动");
        }
    }
    //外部类成员方法
    public void outMethod(){
    
    
        System.out.println(name +"身体");
    }
    //通过外部类方法访问内部类
    public void visitInner(){
    
    
        new Heart().innerMethod();
    }
}
class Test{
    
    
    public static void main(String[] args) {
    
    
        //1-通过外部类方法访问内部类，方法中调用内部类
        new Body("zxw").visitInner();
        //2-通过正常方式访问内部类
        Body.Heart heart = new Body("zxw").new Heart();
        heart.innerMethod();
    }
}	

内部类的同名变量访问方法

public class Outer {
    
    
    private int num = 10;

    public class Inner{
    
    
        private int num = 20;

        public void methodInner(){
    
    
            int num = 30;
            System.out.println(num);//此方法中的num
            System.out.println(this.num);//内部类中的成员变量num
            System.out.println(Outer.this.num);//外部类中的成员变量num
        }
    }

    public static void main(String[] args) {
    
    
        new Outer().new Inner().methodInner();
    }
}

30

20

10

局部内部类定义

​ 局部内部类是定义在外部类的成员方法中，只有在当前成员方法中可以调用

public class Outer{
    
    
    public methodOuter(){
    
    
        //局部内部类
        class Inner{
    
    
            int num = 20;
            public void print(){
    
    
                System.out.println(this.num);
            }     
        }
        
        //局部内部类的使用
        new Inner().print();
    }
     public static void main(String[] args) {
    
    
        new Outer().methodOuter();
    }
}

10

局部内部类final问题

​ 局部内部类中,如果想要访问所在方法的局部变量，那么这个局部变量必须是有效的final,从jdk 8+开始，只要局部变量不变，就可以省略final关键字

public class Outer{
    
    
    public void methodOuter(){
    
    
        int num = 10;
        //num = 1; 程序会出错
        class Inner(){
    
    
            public void methodInner(){
    
    
                System.out.println(num);
        }
    }
}

原因

1. 内存中对象存储在堆内存中，局部变量跟着方法存储在占内存中
2. 方法一旦运行结束后，会立刻出栈，局部变量会立刻消失
3. 但是对象却已在在碓内存中持续存在，直到垃圾回收。

匿名内部类

匿名内部类使用场景

​ 如果接口的实现类(或者是父类的子类)只需要使用一次，那么这种情况下可以省略掉该类的定义，使用匿名内部类

匿名内部类的定义格式

interface MyInter{
    
    
    void method();
}
public class Test{
    
    
    public static void main(String[] args){
    
    
        MyInter inter = new MyInter{
    
    
            @Override
            public void method(){
    
    
                System.out.println("匿名内部类的使用");
            }
        }
        
        inter.method();
    }

匿名内部类的使用

扫描二维码关注公众号，回复： 13146529 查看本文章

匿名内部类的注意事项

1. 匿名内部类，在创建对象时只能使用唯一一次
2. 匿名对象，在调用方法时只能调用唯一一次
3. 匿名内部类是省略了实现类/子类名称；匿名对象是胜率的对象名称

类的权限修饰符总结

​ public > protected > (default) > private

定义类时，权限修饰符的规则

• 外部类：public / (default)
• 成员内部类 : public / protected / (default) / private
• 局部内部类：什么都不能写