内部类(成员内部类、局部内部类(包括匿名内部类))

内部类(成员内部类、局部内部类(包括匿名内部类))这是我参与8月更文挑战的第8天,活动详情查看:8月更文挑战 一个事物的内部包含另一个事物。一个类里面包含另一个类,这个类叫内部类,包含它的叫它外部类。 例如:身体和心脏的关系;汽车和引擎的关系。 心脏

这是我参与8月更文挑战的第8天,活动详情查看:8月更文挑战

一个事物的内部包含另一个事物。一个类里面包含另一个类,这个类叫内部类,包含它的叫它外部类。

例如:身体和心脏的关系;汽车和引擎的关系。

心脏、引擎只有在身体和汽车中才有用。内部类也一样。

分类:

  1.成员内部类;

  2.局部内部类(包括匿名内部类);

1.成员内部类

/* 修饰符 class 外部类名称{ 修饰符 class 内部类名称{ ...... } ...... } */
public class Outer {
    private String name;

    public class Inter{
        public void InterMethod(){
            System.out.println("内部方法");
            System.out.println("姓名:" + name);   // 成员内部类可以访问外部类属性
        }
    }
    public void fun1(){
        Inter in = new Inter();
        in.InterMethod();
    }
}

编译后,这个类的class文件保存在磁盘里

内部类(成员内部类、局部内部类(包括匿名内部类))

内部类的使用方式

  在外部类中可以直接通过 new 对象的方式使用。

  在其他类中访问:

    1.间接方式:在外部类的方法中使用内部类,而在其他类中使用就 new 外部类调用这个方法;

/** * 其他类使用内部类 */
public class OuterDemo1 {
    public static void main(String[] args) {
        Outer out = new Outer();
        out.fun1();
    }
}

    2.直接方式,直接创建出内部类

    公式: 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();

public class OuterDemo2 {
    public static void main(String[] args) {
        Outer.Inter in = new Outer().new Inter();

        in.InterMethod();
    }
}

问题:在外部类、内部类、内部类方法体出现相同名称属性,如何输出相应的值呢?

解决:

public class OuterDemo3 {

    private String name ="外";

    class Inter{
        private String name = "内";
        public void interMethod(){
            String name = "方法";
            System.out.println(name);   // 输出: 方法,就近原则
            System.out.println(this.name);   // 输出: 内
            System.out.println(OuterDemo3.this.name);    // 输出: 外
        }
    }
}

2.局部内部类

  在方法体内定义一个类,出了这个方法,就无法使用这个类(所以其他类无法使用【局部内部类】)

  普及:

  权限修饰符的使用规则:

  public > protected > (default) > private

  1.外部类:能使用 public / (defautl) 修饰

  2.成员内部类: public / protected / (default) / private

  3.局部内部类:什么都不写

public class Test {

    public void fun(){
        final int num = 100;
        class Fun{
            private void fun2(){
                System.out.println(num);
            }
        }
        Fun fun = new Fun();
        fun.fun2();
    }
}

问题:为什么访问所在方法的局部变量,必须要有final修饰?

原因(本质是生命周期问题)

  1.内部类 new 出来的对象在堆内存中;

  2.局部变量跟着方法,在栈内存中;

  3.方法运行完,立刻出栈,局部变量跟着消失;

  4.但 new 出来的对象,会在堆内存持续存在,直到垃圾回收;

  5.所以,要将该内存复制到常量池才能保存继续使用。

3.匿名内部类(重要)

  往常,我们要使用接口方法,得先定义该接口的实现类 -> 重写该接口的所有抽象方法 -> new 实现类使用。

  而如果接口的实现类只是用唯一的一次,那么这种情况就可以省略该实现类的定义,而改为使用 【匿名内部类】

接口

public interface MyInteface {
    void method();
}

使用【匿名内部类】

/** * 格式: * 接口名称 对象名 = new 接口名称(){ * // 覆盖重写所有抽象方法 * }; */
public class AnonymityTest2 {
    public static void main(String[] args) {
        MyInteface my = new MyInteface(){
            @Override
            public void method() {
                System.out.println("匿名内部类方法");
            }
        };
        my.method();
    }
}

  很多人一开始可能会有误解:不是【匿名内部类】吗? MyInteface my = new MyInteface(){…} 这不是有名字么?

  先看,对于”new MyInteface(){…};” 的解析:

    1). new 代表对象创建的动作;

    2). 接口名称 【匿名内部类】要实现的接口;

    3). {…} 这才是【匿名内部类】的内容,里面重写着接口的所有抽象方法

  它光秃秃的,的确没名没姓的。

  而 MyInteface my = new MyInteface(){…} 中的 my 是对象名,它是供你调用匿名类方法的对象。

ps:匿名内部类、匿名对象

1、【匿名内部类】表示,在创建对象是,只能使用唯一一次,一般用于书写接口的实现类。

    如果希望多次创建对象,而且类的内容一样的话,那还是单独定义实现类更方便。

public class AnonymityTest2 {
    public static void main(String[] args) {
        MyInteface my1 = new MyInteface(){
            @Override
            public void method() {
                System.out.println("匿名内部类方法");
            }
        };
        my1.method();
        MyInteface my2 = new MyInteface(){
            @Override
            public void method() {
                System.out.println("匿名内部类方法");
            }
        };
        my2.method();
    }
}

2.【匿名对象】表示,在调用方法时,只能调用唯一一次。

    如果希望同一对象,调用多次方法,那么还是给对象起个名把。

new MyInteface(){
            @Override
            public void method1() {
                System.out.println("匿名内部类方法1");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类方法2");
            }
        }.method1();
        
        new MyInteface(){
            @Override
            public void method1() {
                System.out.println("匿名内部类方法1");
            }
            @Override
            public void method2() {
                System.out.println("匿名内部类方法2");
            }
        }.method2();

3.两者不是一回事

【匿名内部类】是省略了 <实现类 / 子类>

【匿名对象】是省略了 <对象名称>

两者不是一回事。

public class AnonymityTest {
    public static void main(String[] args) {
        fun1();
    }

    private static void fun1() {
        // 对于 Thread 来说,这就是【匿名对象】
        // 对于 Runnable 来说,这就是【匿名内部类】
        new Thread( new Runnable(){
            @Override
            public void run() {

            }
        }).start();
    }
}

今天的文章内部类(成员内部类、局部内部类(包括匿名内部类))分享到此就结束了,感谢您的阅读。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:https://bianchenghao.cn/13650.html

(0)
编程小号编程小号

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注