面向对象--接口，面向接口编程，内部类-CFANZ编程社区

一、为什么要使用接口？

1.Door.java

public abstract class Door {
 
//    public Door(){
//
//    }
 
    //开门
    public abstract void openDoor();
 
    //关门
    public abstract void closeDoor();
 
//    public static void main(String[] args) {
//        Door door = new Door();
//    }

}

2.DoorBell.java

public interface DoorBell {
 
    //拍照存储
    public abstract void photo();
}

为什么需要接口?接口和抽象类的区别?
– 接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类迚行约束。
全面地专业地实现了：规范和具体实现的分离。
– 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须
能…”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏
人；如果你是坏人，则必须欺负好人。
– 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
– 项目的具体需求是多变的，我们必须以不变应万变才能从容开发，此处的
“不变”就是“规范”。因此，我们开发项目往往都是面向接口编程！

接口的特性：
– 接口不可以被实例化
– 实现类必须实现接口的所有方法
– 实现类可以实现多个接口
– 接口中的变量都是静态常量

接口相关规则
– 接口中所有方法都是抽象的。
– 即使没有显式的将接口中的成员用public标示，也是public访问类型的
– 接口中变量默认用 public static final标示，所以接口中定义的变量就是全
局静态常量。
– 可以定义一个新接口，用extends去继承一个已有的接口
– 可以定义一个类，用implements去实现一个接口中所有方法。
– 可以定义一个抽象类，用implements去实现一个接口中部分方法。

二、面向接口编程例子：

1.Lock.java

public interface Lock {
 
    public static final int num = 100;
 
//    public Lock(){
//
//    }
 
    //开锁
    public abstract void openLock();
 
    //上锁
    public abstract void closeLock();
 
}

2.LockDoor.java

public /*abstract*/ class LockDoor extends Door implements Lock,DoorBell/*,Runnable,Serializable*/ {
 
    @Override
    public void openDoor() {
        System.out.println("开门");
    }
 
    @Override
    public void closeDoor() {
        System.out.println("关门");
    }
 
    @Override
    public void openLock() {
        System.out.println("开锁");
    }
 
    @Override
    public void closeLock() {
        System.out.println("上锁");
    }
 
    @Override
    public void photo() {
        System.out.println("咔嚓咔嚓... ...图片被存储了");
    }
 
//    @Override
//    public void run() {
//
//    }
}

3.TestLockDoor.java

public class TestLockDoor {
 
    public static void main(String[] args) {
        LockDoor lockDoor = new LockDoor();
        lockDoor.openLock();
        lockDoor.openDoor();
        lockDoor.closeDoor();
        lockDoor.closeLock();
        lockDoor.photo();
 
//        Lock lock = new LockDoor();
//        System.out.println(lock.num);
 
//        Lock lock = new Lock();
//        Lock.num = 200;
//        System.out.println(Lock.num);
    }
}

4.DoorBell.java

public interface DoorBell {
 
    //拍照存储
    public abstract void photo();
}

在java中，一个子类只能有一个父类，是单继承的，如果我们遇到一个类需要继承多个类的时候，就需要考虑使用接口实现。
在实际项目开发过程中，接口的应用非常的广泛。
用法：
1、接口需要用interface定义
2、如果一个类实现了一个接口，那么就必须要把接口中所有的抽象方法都实现了
3、使用implements实现接口
特征：
1、接口中所有的方法都是public abstract修饰的，也就是默认修饰符，不管写与不写，都是public abstract,
当把修饰符 public省略的时候，不能理解为使用的default修饰符，仍然是public，而且只能是public
2、接口是一种特殊的抽象类，接口不可以被实例化，这个特点和抽象类是一样的,但是并不意味着不能有构造器，
抽象类中可以有构造器，接口中不能有，之前我们讲过只要可以通过new关键字创建一个对象，就一定会找到
一个对应的构造器被执行，但是这句话反过来就不一定了，什么意思，也就是说，有构造器不一定可以创建对象，
但是如果new一个对象就一定存在一个对应的构造器
3、实现类必须实现接口中的所有方法，但是如果你就想实现接口中的一部分方法，有一些未实现，那么需要把这个实现类
定义为抽象类即可
4、实现类可以实现多个接口
5、接口中的变量都是静态变量,默认修饰符是 public static final,修饰符 public写与不写都是public，
而且只能是 public
6、一个接口可以继承多个接口
注意：
1、接口表示一种能力，体现在接口的方法上
2、关心实现类有何能力，而不关心实现细节，面向接口的约定而不考虑接口的具体实现
3、接口是一种约定
java基础阶段高频面试题：
接口和抽象类有什么区别？
1、接口是一种特殊的抽象类；
2、一个类继承抽象类使用extends，实现接口使用implements，并且extends要在implements之前；
3、一个类只能继承一个抽象类，但是可以实现多个接口；
4、抽象类和接口都不能被实例化，但是抽象类中可以有构造器，而接口中不能有；
5、抽象类中可以有变量也可以有常量，可以有方法的实现，也可以有方法的定义，而接口中只能有全局静态常量，
默认的修饰符是public static final,不能有变量，同时只能有方法的定义，默认修饰符是public abstract,
不能有方法的实现；
6、类与类之间的继承是单继承，而接口之间的继承是多继承.

三、内部类

把一个类定义在另一个类的内部称为内部类

成员内部类：

注意事项：
▪ （1）外部类不能直接使用内部类的成员和方法
▪ （2）如果外部类和内部类具有相同的成员变量戒方法，内部类默认访问自己的成员的变量方法，如果要访问外部类的成员变量，需使用this关键字

在外部访问内部类：

语法
▪ 外部类外部类对象=new 外部类();
▪ 外部类.内部类内部类对象=外部类对象.new 内部类 ()；

如果主方法在外部类内部，则可以省略Outer

静态内部类

语法
▪ new 外部类类名.内部类().方法名
▪ 外部类类名.内部类内部类对象名=new 外部类类名.内部类类名();

使用static声明的内部类不能访问非static的外部属性

匿名内部类

适合只需要使用一次的类，安卓中使用的比较多

匿名内部类Anonymous
– 可以实现一个接口，戒者继承一个父类
– 只能实现一个接口
– 适合创建那种只需要一次使用的类，不能重复使用。比较常见的是在图形界面编程GUI里用得到。
– 匿名内部类要使用外部类的局部变量，必须使用final修饰该局部变量

方法内部类

方法内部类是指：将内部类定义在外部类的方法中。
▪ 注意事项：
▪ 方法内部类不能在外部类的方法以外的地方使用，所以方法内部类不能使用访问控制符和static修饰符

内部类总结：

将一个类定义置入另一个类定义中就叫作“内部类”
▪ 类中定义的内部类特点
 内部类作为外部类的成员，可以直接访问外部类的成员（包括private成员），反之则不行。
 内部类做为外部类成员，可声明为private、默认、protected戒public。
 内部类成员只有在内部类的范围之内是有效的。
 用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小
的访问权限。
– 编译后生成两个类： OuterClass.class 和OuterClass$InnerClass.class
▪ 内部类分类
– 成员内部类静态内部类方法内部类匿名内部类

OuterClass.java

public class OuterClass{
 
     private String name = "张飞";
     private int id;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getId() {
        return id;
    }
 
    public void setId(int id) {
        this.id = id;
    }
 
    public void show(){
        System.out.println("这是外部类的show方法");
//        System.out.println(gender);
//        test();
        //创建类对象
//        InnerClass innerClass = new InnerClass();
//        System.out.println(innerClass.gender);
//        innerClass.test();
 
    }
 
    //成员内部类
    class InnerClass{
        private String gender;
        private String name = "赵云";
 
//        private static String no;
 
        public void test(){
            System.out.println("这是内部类的test方法");
//            System.out.println(gender);
//            System.out.println(name);
//            System.out.println(id);
//            show();
            System.out.println(name);
            System.out.println(this.name);
            System.out.println(OuterClass.this.name);
 
//            OuterClass outerClass = new OuterClass();
//            outerClass.show();
 
        }
 
 
        class InnerInnerClass{
            public void test1(){
                System.out.println("这是内部类中的内部类");
            }
        }
    }
 
    //主方法/入口方法
//    public static void main(String[] args) {
//        InnerClass innerClass = new OuterClass().new InnerClass();
//    }
 
}

TestOuterClass.java

public class OuterClass{
 
     private String name = "张飞";
     private int id;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getId() {
        return id;
    }
 
    public void setId(int id) {
        this.id = id;
    }
 
    public void show(){
        System.out.println("这是外部类的show方法");
//        System.out.println(gender);
//        test();
        //创建类对象
//        InnerClass innerClass = new InnerClass();
//        System.out.println(innerClass.gender);
//        innerClass.test();
 
    }
 
    //成员内部类
    class InnerClass{
        private String gender;
        private String name = "赵云";
 
//        private static String no;
 
        public void test(){
            System.out.println("这是内部类的test方法");
//            System.out.println(gender);
//            System.out.println(name);
//            System.out.println(id);
//            show();
            System.out.println(name);
            System.out.println(this.name);
            System.out.println(OuterClass.this.name);
 
//            OuterClass outerClass = new OuterClass();
//            outerClass.show();
 
        }
 
 
        class InnerInnerClass{
            public void test1(){
                System.out.println("这是内部类中的内部类");
            }
        }
    }
 
    //主方法/入口方法
//    public static void main(String[] args) {
//        InnerClass innerClass = new OuterClass().new InnerClass();
//    }
 
}