java常用类笔记 内部类

目录

什么是内部类？

 特点

成员内部类

 静态内部类

局部内部类

 匿名内部类

---

内部类分类

 成员内部类：把一个类定义在另外一个类中，作为一个成员而存在。

静态内部类：static关键字定义的类。

局部内部类：把一个类定义在方法内部。

匿名内部类：没有名字的内部类，在使用接口或者抽象的时候用的较多。

什么是内部类？

如上图，Outer类是外部类，Inner类就为内部类，它在被包裹在Outer类中。

 特点

1.编译后可以生成独立的字节码文件。

2.内部类可直接访问外部类的私有成员，而不破坏封装。

3,可以为外部类提供必要的功能组件。

成员内部类

定义：在类的内部定义，与实例变量、实例方法同级别的类。

外部类的一个实例部分，创建内部类对象时，必须依赖外部来对象。

 //  Outer outer = new Outer();
        //  Inner inner = outer.new Inner();
        
        //一步到位创建法
        Inner inner = new Outer().new Inner();

举例

package com.zhang.error;
//外部类
public class Outer {
    //实例变量
    private String name="张三";
    private int age = 20;
    //内部类
    public class Inner{
        private String address="北京";
        private String phone ="123456789";

        //方法
        public void show(){
            //输出外部类属性
            System.out.println(name);
            System.out.println(age);
            //输出内部类属性
            System.out.println(address);
            System.out.println(phone);
        }
    }

    public static void main(String[] args) {
        //  Outer outer = new Outer();
        //  Inner inner = outer.new Inner();
        
        //一步到位创建法
        Inner inner = new Outer().new Inner();
        inner.show();
    }
}

 当外部类、内部类属性重名时，会优先访问内部类属性。

内部类也添加一个name属性。

输出

 如果想要访问外部类的name那么在属性前加上 “类名.this.”

在输出时可以像下图这样加上前缀来明确调用的属性。

成员内部类不能定义静态成员。但是可以包括静态常量。

成员内部类总结

 静态内部类

不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。

package com.zhang.inner;
//静态内部类
public class Sta {
    private String name = "张三";
    private int age = 18;
    //静态内部类 Inner
    static class Inner{
        private String address = "北京";
        private String phone = "12345567";
        //静态成员
        private static int count = 1000;
        //方法
        public void show(){
            //调用外部类属性 1.创建对象
            Sta sta = new Sta();
            //2.调用外部类对象的属性
            System.out.println(sta.name);
            System.out.println(sta.age);
            //调用静态内部类属性
            System.out.println(this.address);
            System.out.println(this.phone);
            //调用静态内部类的静态属性
            System.out.println(Inner.count);
        }
    }

    public static void main(String[] args) {
        Inner inner = new Inner();
        inner.show();
    }
}

只有内部类才能是静态的，普通类不行。

总结

局部内部类

定义在外部类方法中，作用范围和创建对象仅能在当前方法使用

package com.zhang.inner.Demo03;
//局部内部类
public class Outer {
    private String name ="李华";
    private int age = 18;
    //创建show方法
    public void show(){
        //定义局部变量
        String sex = "男";
        //局部内部类 Inner
        class Inner{
            private String phone = "12321341412";
            //方法
            public void show2(){
                //访问外部类属性
                System.out.println(name);
                System.out.println(age);
                //访问内部类属性
                System.out.println(phone);
            }
        }

    }
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }

}

 如上代码，创建外部对象，调用show（）方法。

没有任何输出结果，这是因为在执行show（）方法时并没有用到局部内部类Inner。

 要想输出结果，要创建局部内部类对象调用show2（）方法。

访问局部变量

 加上final后sex相当于一个常量，在运行时

System.out.println(sex);==System.out.println("男");

 代码

package com.zhang.inner.Demo03;
//局部内部类
public class Outer {
    private String name ="李华";
    private int age = 18;
    //创建show方法
    public void show(){
        //定义局部变量
        String sex = "男";
        //局部内部类 Inner
        class Inner{
            private String phone = "12321341412";
            //方法
            public void show2(){
                //访问外部类属性
                System.out.println(name);
                System.out.println(age);
                //访问内部类属性
                System.out.println(phone);
                //访问局部变量
                System.out.println(sex);
            }
        }
        Inner inner = new Inner();
        inner.show2();


    }
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }

}

总结

 匿名内部类

没有类别的局部内部类（一切特征与局部内部类相同）

必须继承一个父类或实现一个接口。

测试类TestUsb

package com.zhang.inner.Demo04;

public class TestUsb {
    public static void main(String[] args) {
        //使用Mouse类
        /*USB usb = new Mouse();
        usb.service();*/
        //局部内部类
       /* class KeyBoard implements USB{

            @Override
            public void service() {
                System.out.println("键盘连接成功");
            }
        }*/
        //使用局部内部类创建对象
        /*USB usb = new KeyBoard();
        usb.service();*/
        //匿名内部类使用方法
        USB usb = new USB() {
            @Override
            public void service() {
                System.out.println("xxxx连接成功，开始工作");
            }
        };
        usb.service();
    }

}

USB接口

package com.zhang.inner.Demo04;

public interface USB {
    void service();
}

Mouse

package com.zhang.inner.Demo04;

public interface USB {
    void service();
}

如上代码所示，局部内部类只使用一次，这样写就太麻烦，于是使用匿名内部类对它进行优化。

匿名内部类相当于创建了一个局部内部类，只是没有名字。

总结