【0基础学java】教学日志：javaSE-面向对象6-接口、面向接口编程、内部类

本章概述：本章属于面向对象第六章接口，主要讲解了为什么使用接口，接口是什么，接口是如何在实际开发过程中使用的。
一、为什么使用接口？
1、Door.java
package day01.class2.interfacedemo;

/**

• @Auther: Yu Panpan
• @Date: 2022/2/24 - 02 - 24 - 8:13
• @Description: day01_2_1.interfacedemo
• @version: 1.0
  */
  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;

/**

• @Auther: Yu Panpan

• @Date: 2022/2/24 - 02 - 24 - 9:32

• @Description: day01_2_1.interfacedemo

• @version: 1.0
  */
  public interface DoorBell {

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

/**

• @Auther: Yu Panpan

• @Date: 2022/2/24 - 02 - 24 - 8:14

• @Description: day01_2_1.interfacedemo

• @version: 1.0
  */
  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;

/**

• @Auther: Yu Panpan

• @Date: 2022/2/24 - 02 - 24 - 8:15

• @Description: day01_2_1.interfacedemo

• @version: 1.0
  /
  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;

/**

• @Auther: Yu Panpan
• @Date: 2022/2/24 - 02 - 24 - 8:18
• @Description: day01_2_1.interfacedemo
• @version: 1.0
  */

/*
在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;

/**

• @Auther: Yu Panpan

• @Date: 2022/2/24 - 02 - 24 - 9:32

• @Description: day01_2_1.interfacedemo

• @version: 1.0
  */
  public interface DoorBell {

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

/**

• @Auther: Yu Panpan

• @Date: 2022/2/27 - 02 - 27 - 10:07

• @Description: day03.class4.innerdemo1

• @version: 1.0
  */
  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;

/**

• @Auther: Yu Panpan

• @Date: 2022/2/27 - 02 - 27 - 10:07

• @Description: day03.class4.innerdemo1

• @version: 1.0
  */
  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{
//
//}