Java SE 内部类

• 内部类
• object类
• Object类常用方法
• 包装类
• String类
• BigDecimal类

内部类：

• 概念：在一个类的内部再定义一个完整的类
• 特点：
  • 编译之后可生成独立的字节码文件
  • 内部类可直接访问外部类的私有成员，而不破坏封装
  • 可为外部类提供必要的内部功能组件

package Neibulei;

public class Body {

    private String name;

    class Header{

        public void run(){
            System.out.println(name);
        }

    }
}

成员内部类：

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

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

  • Outer outer = new Outer();

  • Inner inner = outer.new Inner();

  • //Outer outer = new Outer();
    //Outer.Inner inner = outer.new Inner();
    Outer.Inner inner = new Outer().new Inner();
    

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

  Outer.this.name;

  Outer.this.age;

• 成员内部类不能定义静态成员 可以定义静态常量

package Neibulei;

public class Outer {

    private String name="zxzx";
    private int age=24;
    //private /protected/public class Inner(){}
    class Inner{
        private String address="njust";
        private String drom="509";
        private String name = "xzxz";
        //不能使用static
        //private static String Country;
        private static final String Country1="China";
        //可以用static定义常量


        public void show(){
            System.out.println(name);
            //内部类属性和外部类相同，Outer.this.name
            System.out.println(Outer.this.name);
            System.out.println(Outer.this.age);

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

    }


}

package Neibulei;

public class TestOuter {
    public static void main(String[] args) {

        //Outer outer = new Outer();
        //Outer.Inner inner = outer.new Inner();
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }
}

静态内部类

package Neibulei;

//外部类
public class Outer01 {

    private String name = "zx";
    private int age = 19;

    //静态内部类：和外部类相同
    static class Inner{

        private String address = "xian";
        private int phone = 110;
        //静态内部类里面可以有静态成员
        private static int count  = 100;

        public void showMaker(){
            //调用外部类的属性：
            //1创建外部类的对象
            //2调用外部类对象的属性
            Outer01 outer01 = new Outer01();
            System.out.println(outer01.name);
            System.out.println(outer01.age);
            //调用静态内部类的属性和方法
            System.out.println(address);
            System.out.println(phone);


            //调用静态内部类的静态属性
            System.out.println(count);
            System.out.println(Inner.count);
        }
    }
}

package Neibulei;

public class TestOuter01 {
    public static void main(String[] args) {
        Outer01.Inner inner = new Outer01.Inner();
        inner.showMaker();
    }
}

输出：

zx
19
xian
110
100
100

Process finished with exit code 0

局部内部类

方法里面的内部类

package JubuNeibulei;

public class Outer {
    private String name = "zx";
    private int age = 20;

    public void show(){

        //局部变量
        String address = "xian";

        //局部内部类不能加任何的修饰符
        class Inner{
            private int phone = 520520520;
            private int email = 521521521;

            public void show2(){
                //访问外部类的属性
                System.out.println(Outer.this.name);
                System.out.println(Outer.this.age);
                //访问内部类的属性
                System.out.println(this.phone);
                System.out.println(this.email);
                //访问局部变量
                System.out.println(address);
            }

        }
        //创建局部内部类对象
        Inner inner = new Inner();
        inner.show2();

    }
}

package JubuNeibulei;

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

匿名内部类

• 没有类名的局部内部类（一切特性都与布局内部类相同）
• 必须继承一个父类或者实现一个接口
• 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
• 优点：减少代码量
• 缺点：可读性较差

接口回顾

package NimingNeibulei;

public interface Usb {
    void faker();
}

重写

package NimingNeibulei;

public class Mouse implements Usb{
    @Override
    public void faker() {
        System.out.println("我鼠标动了我不玩了");
    }
}

package NimingNeibulei;

public class TestUsb {
    public static void main(String[] args) {
        Usb usb = new Mouse();
        usb.faker();
    }
}

使用成员内部类

package NimingNeibulei;

public class TestUsb {
    public static void main(String[] args) {
        //Usb usb = new Mouse();
        //usb.faker();

        class guiZi implements Usb{
            @Override
            public void faker() {
                System.out.println("我柜子动了我不玩了");
            }
        }
        //使用内部类创建对象
        Usb usb = new guiZi();
        usb.faker();

    }
}

package NimingNeibulei;

public class TestUsb {
    public static void main(String[] args) {
        //Usb usb = new Mouse();
        //usb.faker();

//        class guiZi implements Usb{
//            @Override
//            public void faker() {
//                System.out.println("我柜子动了我不玩了");
//            }
//        }
//        //使用内部类创建对象
//        Usb usb = new guiZi();
//        usb.faker();

        
        //使用匿名内部类优化(相当于创建了个局部内部类)
        Usb usb = new Usb(){
            @Override
            public void faker() {
            System.out.println("我柜子动了我不玩了");
            }

        };
        usb.faker();

    }
}