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

本章概述：
一、为什么使用接口

1、Door.java

2、DoorBell.java

二、接口的基本使用

1、Lock.java

2、LockDoor.java 

3、TestLockDoor.java

三、内部类

1、Outerclass.java

2、TestOuterclass.java 

一、为什么使用接口
1、Door.java
package day01.class2.interfacedemo;
 

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
package day01.class2.interfacedemo;
 

public interface DoorBell {
 
    //拍照存储
    public abstract void photo();
}
二、接口的基本使用
1、Lock.java
package day01.class2.interfacedemo;
 

public interface Lock {
 
    public static final int num = 100;
 
//    public Lock(){
//
//    }
 
    //开锁
    public abstract void openLock();
 
    //上锁
    public abstract void closeLock();
 
}
2、LockDoor.java 
package day01.class2.interfacedemo;
 

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
package day01.class2.interfacedemo;
 

 
/*
        在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、复习-->预习-->同步找一套视频-->上课的时候可以带问题来听课
            3、课堂笔记，预习笔记
 */
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
package day01.class2.interfacedemo;
 

public interface DoorBell {
 
    //拍照存储
    public abstract void photo();
}
三、内部类
1、Outerclass.java
package day03.class4.innerdemo1;
 

 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();
//    }
 
}
 
//class HelloWorld{
//
//}
2、TestOuterclass.java 
package day03.class4.innerdemo1;
 

 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();
//    }
 
}
 
//class HelloWorld{
//