【Java】接口、内部类、包装类、装箱拆箱详解！

接口

接口是一组常量和抽象方法、默认方法、静态方法的集合。实现接口的类必须覆盖接口中的所有抽象方法。

声明接口：

[访问修饰符]  interface 接口名   [extends  父接口1，父接口2…]  {
常量定义；  
方法定义；
}

接口中的常量默认被public static final 修饰； 接口中的方法默认被public abstract 修饰；

接口的使用：

public class Main {
    public static void main(String[] args) {
        A a = new C();
        A.b();
        System.out.println(A.a);
    }
}
interface A {   //声明接口
    int a = 100; 
    void b(); 
}
class C implements A{  //实现接口
    public void b() {
        System.out.println("bbb");
    }
}

结果：

bbb
100

注意： 1.接口不能创建实例，但是可用于声明引用变量类型；

2.一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的；

3.接口可以多继承；

内部类

我们把一个类放在另一个类的内部定义，成为内部类；

内部类的作用

内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直接访问；

内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。 但外部类不能访问内部类的内部属性；

内部类体现了多重继承； 定义内部类：

/**外部类Outer*/
class Outer {
    private int age = 10;
    public void show(){
        System.out.println(age);//10
    }
    /**内部类Inner*/
    public class Inner {
        //内部类中可以声明与外部类同名的属性与方法
        private int age = 20;
        public void show(){
            System.out.println(age);//20
        }
    }
}

匿名内部类

适合那种只需要使用一次的类

this.addWindowListener(new WindowAdapter(){
        @Override
        public void windowClosing(WindowEvent e) {
            System.exit(0);
        }
    }
);
this.addKeyListener(new KeyAdapter(){
        @Override
        public void keyPressed(KeyEvent e) {
            myTank.keyPressed(e);
        }      
        @Override
        public void keyReleased(KeyEvent e) {
            myTank.keyReleased(e);
        }
    }
);

注意

匿名内部类没有访问修饰符；

匿名内部类没有构造方法；

局部内部类

局部内部类是定义在方法中的只作用域局限于该方法

public class Test2 {
    public void show() {
        //作用域仅限于该方法
        class Inner {
            public void fun() {
                System.out.println("helloworld");
            }
        }
        new Inner().fun();
    }
    public static void main(String[] args) {
        new Test2().show();
    }
}

包装类

们在实际应用中经常需要将基本数据转化成对象，以便于操作。比如：将基本数据类型存储到Object[]数组或集合中的操作等等；

Java在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)均位于java.lang包；

其中byte、short、integer、long、float、double是“数字型”，“数字型”都是java.lang.Number的子类。Number类是抽象类，因此它的抽象方法，所有子类都需要提供实现。Number类提供了抽象方法：intValue()、longValue()、floatValue()、doubleValue()；意味着所有的“数字型”包装类都可以互相转型 包装类使得基本数据类型、包装类对象、字符串之间能够相互转化；

包装类的使用

public class Test {
    void testInteger() {
        // 基本类型转化成Integer对象
        Integer int1 = new Integer(10);
        Integer int2 = Integer.valueOf(20);
        // Integer对象转化成int
        int a = int1.intValue();
        // 字符串转化成Integer对象
        Integer int3 = Integer.parseInt("334");
        Integer int4 = new Integer("999");
        // Integer对象转化成字符串
        String str1 = int3.toString();
        // 一些常见int类型相关的常量
        System.out.println(Integer.MAX_VALUE); 
    }
    public static void main(String[] args) {
        Test test  = new Test();
        test.testInteger();
    }
}

输出：

2147483647

自动装箱和拆箱

自动装箱和拆箱就是将基本数据类型和包装类之间进行自动的互相转换

自动装箱

当我们输入Integer i = 5这样的语句时JVM会为我们自动执行Integer i = Integer.valueOf(5)这样的操作（JDK1.5之后才有此功能），这就是自动装箱；

自动拆箱

每当需要一个值时，对象会自动转成基本数据类型，没必要再去显式调用intValue()、doubleValue()等转型方法。 如 Integer i = 5;int j = i; 这样的过程就是自动拆箱； 注意：

public class Main {
    public static void main(String[] args) {
        Integer i = null;
        int j = i;
    }
}

以上代码编译能够通过，但是会报以下错误：

此错误为空指针异常； 因为 null表示i没有指向任何对象的实体，但作为对象名称是合法的，由于实际上i并没有指向任何对象的实体，所以也就不可能操作intValue()方法，这样上面的写法在运行时就会出现NullPointerException错误；