本文主要向大家介绍了JAVA语言面向对象基础之接口问题，通过具体的内容向大家展示，希望对大家学习JAVA语言有所帮助。

一、接口

(一) 接口的定义和使用

多个抽象类的抽象就是接口。

在Java中最小的程序单元就是类，接口其实是一个特殊的类。

Java中的接口表示规范，用于定义一组抽象方法，表示某一类事物必须具备的功能，要求实现类必须来实现接口并提供方法实现。

定义类的语法： [public] class 类名{}

定义接口语法： [public] interface 接口名{}，(在这里还没有考虑接口的父接口等)

接口起名问题： 表示具有某些能力的，习惯以able结尾。

成功编译之后和类一样，具有一份字节码。

接口存在的成员：

① 接口中没有构造器，所以接口不能创建对象(不能new)，接口中不能定义普通方法。

② 接口中定义的成员变量，实质上是全局静态常量。默认使用public static final来修饰。

③ 接口中定义的方法都是公共的抽象方法，默认使用abstract来修饰方法。一般在接口中定义方法不使用修饰符。

④ 接口中定义的内部类都是公共的静态内部类。默认使用public static 来修饰内部类。

标志接口：

接口中没有任何的成员，就仅仅是一个接口的定义，就是一个标志。其他的类实现该接口，就属于该家族。我们可以通过第三方代码赋予该接口实现类特殊功能（不推荐）。

常量接口：

使用接口来封装多个常量信息，称之为常量接口，其目的和常量类相同（不推荐）。

我们使用的接口，主要都包含了抽象方法。

接口的特点和接口的继承

接口的特点：

① 没有构造方法，也不能显示定义构造器，不能实例化。

② 接口只能继承接口，不能继承类，且接口可以多继承（类是单继承关系）。

③ 接口里的方法全是抽象的，默认修饰符是 public abstract。

④ 接口里的字段全是全局静态常量，默认修饰符是 public static final。

⑤ 接口里的内部类全是公共静态的，默认修饰符是 public static。

类和类之间存在是继承关系：使用extends来表示。

接口和接口之间只能是继承关系：使用extends来表示。

接口和实现类之间只能是实现关系（继承关系）：使用implements来表示。

接口的实现者：实现类

接口仅仅只是定义了某一类事物应该具有的某些功能，但是没有提供任何实现。

此时，我们得提供类再让该类去实现接口，并覆盖接口中的方法，从而实现类接口中定义的功能。

接口和实现类之间的关系，严格上称之为“实现关系”，使用implements来表示。

但是在开发，有时候为了方便也把这个实现关系称之为：特殊继承关系。

所以可以这样理解：接口是实现类的父类，实现类就是接口的子类。

面向接口编程：

接口 变量 = 创建实现类对象; // 体现类多态的思

接口和实现类的多态关系才是我们见的最多的。

类实现接口的语法：一个类可以实现多个接口，从而也弥补了类的单继承问题。

[修饰符] class 实现类名 extents 父类 implements 接口1,接口2{}

注意：

接口中定义的方法是公共的抽象的，所以实现类必须覆盖接口中的方法，并且方法必须使用public修饰。

(二) 接口和抽象类

接口和抽象类的区别：

相同点：

① 都位于继承的顶端，用于被其他实现或继承。

② 都不能实例化。

③ 都可以定义抽象方法，其子类都必须覆写这些抽象方法。

不同点：

① 接口没有构造方法，抽象类有构造方法。

② 抽象类可包含普通方法和抽象方法，接口只能包含抽象方法。

③ 一个类只能继承一个直接的父类（可能是抽象类），却可以实现多个接口（接口弥补了Java的单继承）。

④ 变量：接口里默认的是public static final，抽象类默认的是包访问权限。

⑤ 方法：接口里默认的是public abstract，抽象类默认的是包访问权限。

⑥ 内部类：接口里默认的是public static，抽象类默认的是包访问权限。

如果接口和实现类可以完成相同的功能，尽量使用接口，面向接口编程。

设计模式：接口和抽象类集合使用的（适配器模式）。

(三) 面向接口编程

多态的好处：把实现类对象赋给接口类型变量，屏蔽了实现类之间的实现差异，从而可以做到通用编程。

public class Main {

    public static void main(String[] args) {

        // 调用

        MotherBoard.pluginIn(new Mouse());

    }

}

// usb

interface IUSB {

    void swapData();

}

// 鼠标

class Mouse implements IUSB{

    @Override

    public void swapData() {

        System.out.println("鼠标");

    }

}

// 打印机

class Print implements IUSB{

    @Override

    public void swapData() {

        System.out.println("打印机");

    }

}

// 主板

class MotherBoard{

    public static void pluginIn(IUSB usb){

        usb.swapData();

    }

}

二、内部类

内部类：定义在类结构中的另一个类。

类中定义的成员：字段、方法、内部类。

为什么使用内部类：

① 增强封装，把内部类隐藏在外部类之内，不许其他的类访问该类。

② 内部类能提高代码的可读性和可维护性，把小型类嵌入到外部类结构上代码更靠近。

③ 内部类可以直接访问外部类的成员。

// 外部类/宿主类

public class Out(){

    // 内部类/嵌套类

    public class In(){}

}

内部类根据使用不同的修饰符或者定位的位置不同，分成四种内部类：

① 实例内部类： 内部类没有使用static修饰。

② 静态内部类： 内部类使用的static修饰。

③ 局部内部类： 在方法中定义的内部类。

④ 匿名内部类*： 适合仅使用一次的类，属于局部内部类的特殊情况。

实例内部类、静态内部类和局部内部类的区别：

外部类的访问修饰符：要么使用public，要么缺省。

内部类可以看做是外部类的一个成员，好比字段，那么内部类可以用时public/缺省/protected/private修饰还可以使用static修饰。

对于每个内部类来说： Java编译器会生成独立的.class文件。

成员内部类：外部类名内部类名称。局部内部类：外部类名数字内部类名称。

匿名内部类：外部类名$数字。

(一) 实例内部类

实例内部类： 没有使用static修饰内部类，说明内部类属于外部类的对象，不属于内部类本身。

特点：

① 创建实例内部类前，必须存在外部类对象，通过外部类对象创建内部类对象（当存在内部类对象时，一定存在外部类对象）。

② 实例内部类的实例自动持有外部类的实例的引用，内部类可以直接访问外部类的成员。

③ 外部类中不能直接访问内部类的成员，必须通过内部类的实例去访问。

④ 实例内部类中不能定义静态成员，只能定义实例成员。

⑤ 如果实例内部类和外部类存在同名的字段或方法，那么内部类中：this.xxx：表示访问内部类成员，外部类.this.xxx：表示访问外部类成员。

// 外部类

public class Outter{

    String name = "name";

    // 实例内部类

    public class Inner{

        public void test(){

            System.out.println(new Outter().name);

        }

    }

}

(二) 静态内部类

静态内部类： 使用static修饰的内部类。

特点：

① 静态内部类的实例不会自动持有外部类的特定实例的引用，在创建内部类的实例时，不必创建外部类的实例。

② 静态内部类可以直接访问外部类的静态成员，如果访问外部类的实例成员，必须通过外部的实例去访问。

③ 在静态内部类中可以定义静态成员和实例成员。

④ 测试类可以通过完整的类名直接访问静态内部类的静态成员。

(三) 局部内部类(不建议使用)

局部内部类： 在方法中定义的内部类，其可见范围是当前方法和局部变量是同一个级别。

① 不能使用public，private，protected，static修饰符。

② 局部内部类只能在当前方法中使用。

③ 局部内部类和实例内部类一样，不能包含静态成员。

④ 局部内部类和实例内部类一样，可以访问外部类的所有成员。

⑤ 局部内部类访问的局部变量必须使用final修饰（在Java8中是自动隐式加上final，但是依然是常量，不能改变值）。

原因： 如果当前方法不是mian方法，那么当前方法调用完毕之后，当前方法的栈帧即被销毁，方法内部的局部变量空间也会被销毁。然而局部内部类是定义在方法中的，而且方法中会创建局部内部类对象，而局部内部类会去访问局部变量，当当前方法被销毁的时候，对象还在堆内存，依然持有对局部变量的引用，但是方法被销毁的时候局部变量也被销毁了。

此时出现：在堆内存中，一个对象引用着一个不存在的数据，为了避免该问题，我们使用final修饰局部变量，从而变成常量，永驻内存空间，即使方法销毁之后，该局部变量也在内存中，对象可以继续持有。

class LocalInnerClassDemo{

    static String name = "x";

    public static void main(){

        System.out.println("Hello World");

        // 局部变量

        final int age = 23;

        // 局部内部类

        class Inner{

            String info = "INFO";

            public void test(){

                System.out.println(name);

                System.out.println(info);

                System.out.println(age);

            }

        }

    }

}

局部内部类只能访问final修饰的局部变量。

(四) 匿名内部类

匿名内部类（Anonymous）是一个没有名称的局部内部类，适合只使用一次的类。

在开发中经常有这样的类，只需要定义一次，使用一次就可以丢弃了，此时：不应该白白定义在一个文件中。

在Java/Android的事件处理中：不同的按钮点击之后，应该有不同的响应操作，首选使用匿名内部类。

特点：

① 匿名内部类本身没有构造器，但是会调用父类的构造器。

② 匿名内部类尽管没有构造器，但是可以在匿名内部类中提供一段实例初始化代码块，JVM在调用父类构造器后，会执行该段代码。

③ 内部类处理可以继承之外，还可以实现接口。

格式：

new 父类构造器([实参列表]) 或 接口(){

    // 匿名内部类的类体部分

}

注意： 匿名内部类必须继承一个父类或者实现一个接口，但最多只能继承一个父类或实现一个接口。

// 创建一个匿名内部类

MotherBoard.pluginIn(new IUSB(){

    // 匿名内部类体

    public void swapData(){

        System.out.println("键盘");

    }

})

三、枚举

枚举是从Java5开始提供的一种新的数据类型，是一个特殊的类，就是固定的多个常量对象的集合。

定义格式：

[修饰符] enum 枚举类名{

    常量A,常量B,常量C;

}

枚举的特点：

① 枚举的直接父类java.lang.Enum，但是不能显示继承Enum。

② 枚举就相当于一个类，可以定义构造方法，成员变量，普通方法和抽象方法。

③ 默认私有的构造方法，即使不写访问权限也是private（假构造器，底层没有无参数构造器）。

④ 每个实例分别用一个全局常量表示，枚举的对象是固定的，实例个数有限，不能使用new关键字。

⑤ 枚举实例必须位于枚举内中最开始的部分，枚举实例列表的后面要有分号与其他成员相分隔。

⑥ 枚举实例后有花括号时，该实例是枚举类的匿名内部类对象（查看编译后的class文件）。

枚举的使用：

① 枚举中都是全局公共的静态常量，可以直接使用枚举类名调用。

② 因为java.lang.Enum类是所有枚举类的父类，所以所有的枚举对象都可以调用Enum类中的方法。

③ 编译器生成的枚举类的静态方法。

④ 从Java5开始出现枚举，switch也支持操作枚举类型。

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注编程语言JAVA频道！