Java知识梳理---内部类（扩展）

Java知识梳理： java知识梳理

内部类可分为成员内部类，静态内部类，局部内部类，匿名内部类。
特点：

• 内部类可以直接访问外部类的私有成员，而不破坏封装
• 为外部类提供必要的内部功能组件
• 编译后会生成独立的字节码文件
  

成员内部类

成员内部类： 定义在其他类中的类作为成员存在

• 当外部类和内部类有重名的属性时会有限访问内部类属性
• 不能定义静态成员，但是可以定义静态常量

案例：

public class Outer_class {
    private String name="lala";

    class Inner_class{
        private String name="hha";
        private String phone="1223546";
        //不可以定义静态变量，但是可以定义静态常量
        private static final String country="中国";
        //内部类可以直接访问外部类的私有成员
        public void show(){
            //重名属性访问外部类属性
            System.out.println(Outer_class.this.name);

            System.out.println(name);
            System.out.println(phone);
        }
    }
}

public class test_inner {
    public static void main(String[] args) {
        //创建外部类对象
        Outer_class outer_class=new Outer_class();
        //创建内部类对象
        //需要将外部类的名称加在内部类的前面
        //使用外部类对象.new来创建内部类对象
        Outer_class.Inner_class inner_class=outer_class.new Inner_class();
//        Outer_class.Inner_class inner_class1=new Outer_class().new Inner_class();

        inner_class.show();
    }
}

静态内部类

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

• 只有内部类才能写成静态的
• 不依赖外部类对象
• 可以直接创建或通过类名访问
• 可声明静态成员
• 相当于外部类

案例：

public class staticInnerClass {
    private String name="yang";
    //静态内部类，级别和外部类相同
    static class inner_class{
        private String address="河南";
        private static int num=100;

        public void show(){
            //调用外部类属性
            //需要先创建外部类对象，然后使用对象调用属性
            staticInnerClass staticInnerCategory=new staticInnerClass();
            System.out.println(staticInnerCategory.name);

            System.out.println(address);
            System.out.println(num);
        }
    }
}

public class testStatic {
    public static void main(String[] args) {
        staticInnerClass.inner_class inner=new staticInnerClass.inner_class();
        inner.show();
    }
}

局部内部类

局部内部类： 定义在外部类方法中的类，作用范围和创建对象范围仅限于当前方法

• 局部内部类访问外部类方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final

案例：

public class OuterClass {
    private String name="木头人";

    public void show(){
        String phone="15462364";

        //局部内部类class前面不能加任何访问修饰符，例如private
        class InnerClass{
            private String address="地球";

            public void show1(){
                //可以直接访问外部类的属性
                System.out.println(name);

                //访问方法的局部变量
                //jdk1.8以后默认在局部变量前加上final
                //局部内部类访问外部类方法中的局部变量时，
                //因无法保障变量的生命周期与自身相同，变量必须修饰为final
                //相当于 System.out.println("15462364");
                System.out.println(phone);

                System.out.println(address);
            }
        }

        InnerClass innerClass=new InnerClass();
        innerClass.show1();
    }
}

public class testPart {
    public static void main(String[] args) {
        OuterClass outer_class=new OuterClass();
        outer_class.show();

    }
}

匿名内部类

• 没有名字的内部类，等价于没有名字的局部内部类
• 必须继承一个父类或者实现一个接口
• 定义类，实现类，创建对象的语法合并，只能创建一个该类的对象
• 优点：减少代码量
• 缺点：可读性差

案例：

public interface Usb {
    void Service();
}

public class Mouse implements Usb {
    @Override
    public void Service() {
        System.out.println("鼠标USB连接成功！");
    }
}

public class testUsb {
    public static void main(String[] args) {
        //1.创建接口类型变量====多态
        //接口对象引用一个具体的实现类
        /*USB usb=new Mouse();
        usb.Service();*/

        //2.局部内部类
        /*class Key implements USB{

            @Override
            public void Service() {
                System.out.println("键盘USB连接成功!");
            }
        }
        USB usb=new Key();
        usb.Service();*/

        //使用匿名内部类===相当于创建了一个局部内部类
        Usb usb=new Usb() {
            @Override
            public void Service() {
                System.out.println("显示器连接成功！");
            }
        };
        usb.Service();
    }

}

其他相关文章：

• Java知识梳理：Java知识梳理