接口与内部类

一、接口的概述

1、接口的定义格式：
interface 接口名{
属性
抽象方法
}

interface Inter
{
    int num = 6;  可以定义属性与方法。
    void show();
}

注意：可以通过javap命令查看.
(1)、接口中的所有属性 默认的修饰符是 public static final。
(2)、接口中的所有方法 默认的修饰符是 public abstract。

二、接口的特点

1. 类实现接口可以通过implements实现，实现接口的时候必须把接口中的所有方法实现,一个类可以实现多个接口。
2. 接口中定义的所有的属性默认是public static final的，即静态常量既然是常量，那么定义的时候必须赋值。
3. 接口中定义的方法不能有方法体。接口中定义的方法默认添加public abstract
4. 有抽象函数的不一定是抽象类，也可以是接口类。
5. 由于接口中的方法默认都是抽象的，所以不能被实例化。
6. 对于接口而言，可以使用子类来实现接口中未被实现的功能函数。
7. 如果实现类中要访问接口中的成员，不能使用super关键字。因为两者之间没有显示的继承关系，况且接口中的成员成员属性是静态的。可以使用接口名直接访问。
8. 接口没有构造方法。

三、接口与类、接口之间的关系

1. 大家之前都知道类与类之间的关系继承，那么接口与类之间又是怎样子的关系呢？接口与类之间是实现关系。非抽象类实现接口时，必须把接口里面的所有方法实现。类实现接口用关键字implements，类与接口之间是可以多实现的(即一个类可以实现多个接口)。

interface Eraser {
    public static final String color = "白色";
    public abstract void clean();
}
class Pencil implements Eraser {
    String name;
    Pencil() {
    }
    Pencil(String name) {
        this.name = name;
    }
    void write() {
        System.out.println("写字");
    }
    @Override
    public void clean() {
        System.out.println("涂改...");
    }
}

2. 接口与接口之间的关系式继承。

interface A{
    public void show();
}
interface B{
    public void print();
}
interface C extends A,B{    
}

四、内部类

1、内部类的概述：将类定义在另一个类的内部则成为内部类。其实就是类定义的位置发生了变化。

public class outer {
    int num = 10;
    class Inner{
        int age = 24;

        public void print(){
            System.out.println("内部类。。。");
        }
    }
    System.out.prinln("外部类。。。");
}

2、成员内部类的访问方式

①、内部类可以直接访问外部类的成员属性。
②、外部类需要访问内部类的成员属性时需要创建内部类的对象。
（1）、在外部类的成员函数中创建内部类的对象，通过内部类对象对象直接访问内部类的成员。
（2）、在其他类中直接创建内部类的对象。
Outer.Inner inner = new Outer().new Inner();

public class No2 {
        int num = 10;
        class Inner{
                int age = 24;

                public void print(){
                        System.out.println("内部类。。。");
                }
        }
        public void show(){
                System.out.prinln("访问内部类的属性：" + new Inner().print);
        }

        public static void main(String[] agrs){
                new No2().show();
        }
}

疑问： 什么时候使用内部类呢？

当我们分析事物时，发现事物的内部还有具体的事物，这时则应该定义内部类了。
比如人体是一个类，人体有心脏，心脏的功能在直接访问人体的其他内容。这时就将心脏定义在人体类中，作为内部类存在。

内部类的优势：成员内部类作为外部类的成员，那么可以访问外部类的任意成员。

3、局部内部类

局部内部类概述：包含在外部类的函数中的内部类称之为局部内部类。
访问：可以在包含局部内部类的方法中直接创建局部内部类的对象调用局部内部类的成员。
注意：局部内部类只能访问所在函数的fanal属性。

4、匿名内部类

匿名内部类：就是没有类名字的内部类。
匿名内部类作用：简化内部类书写。
匿名内部类的前提:必须继承一个父类或者是实现一个接口。
匿名内部类的格式：
new 父类或者接口(){ 执行代码….};
内部类的写法：

abstract class Inner{
        abstract void show();
}
public class No2 {
        int num = 10;
        /*class Inner{
                int age = 24;

                public void print(){
                        System.out.println("内部类。。。");
                }
        }*/
        public void print(){
                new Inner() {
                        public void show() {
                                System.out.prinln("内部类的show方法");
                        }
                }.show();
        }
}

注意细节：

使用匿名内部类时，如果需要调用匿名内部类的两个方法或者两个方法以上。可以使用变量指向该对象。