抽象类、接口

抽象类

1. abstract修饰符

2. 代码一：

   package oop.demo01.demo09;
   ​
   //abstract  抽象类：本质上还是个类，需要继承extends:只能单继承（一个儿子只能有一个爸爸）    不能进行多继承:接口可以进行多继承。
   //接口：比如一个插座可以插很多东西，只约束了需要什么样的插头，但并没有约束什么电器才能插上去。
   public abstract class Action {
   ​
       //假设方法是一个约束，对方法种类进行约束，有人帮我们实现，写框架。我们在抽象类中写需要的方法（只要名字即可，不需要方法体），在继承它的子类中实现这些方法。
       //abstract ，方法的抽象，只有方法的名字，没有方法的实现。
       //抽象类是一种约束，由于是单继承，用的不是很多。
       public abstract void doSomething();
   ​
       //1.不能new这个抽象类，只能靠子类去实现它：约束    new Action();会提示Action is abstract,cannot be instantiated。Action类是抽象的，不能被实例化。
       //2.抽象类中可以写普通的方法。
       //3.抽象方法必须在抽象类中。（给方法一个范围）
       //抽象的抽象：约束。
       //抽象类既然不能new对象，那抽象类里存在构造器吗？抽象类存在的意义：节省代码的开发，提升开发效率。比如：创建游戏角色，抽象出共有的属性方法，在各个子类中重写。
   }
   ​
   ​

   代码二：

   package oop.demo01.demo09;
   ​
   //抽象类的所有方法，继承了它（这个抽象类）的那些子类，都必须实现它的方法.除非它的子类也是抽象的，那就需要它的子子类来实现。
   public class A extends Action{   //提示A类必须重写抽象方法，否则报错
       @Override       //方法的重写    alt+insert-->Implement method-->select method to implement
       public void doSomething() {
   ​
       }
   ​
   }
   ​

   接口

   1. 普通类：只有具体实现。（有方法体）

   2. 抽象类：具体实现和规范（抽象方法）都有。

   3. 接口：只有规范。自己无法写方法。专业的抽象，约束。约束和实现分离：面向接口编程，架构师把接口定义好了，你们就去实现那个接口，写里面的方法就好了。

   4. 接口就是规范，定义的是一组规则，体现了现实生活中“如果你是...则必须能...”的思想。

   5. 接口的本质是契约，就像人间的法律一样，制定好后大家都遵守。

   6. 接口是面向对象的精髓，是对对象的抽象，最能体现这一点的就是接口。

   7. 声明类的关键字是class,声明接口的关键字是interface。

   8. java的接口：就是一种约束。可以定义一些方法，让不同的人实现。（多种不同的实现方式）所有默认方法都是public abstract，所有常量修饰符都是public static final。接口不能被实例化，因为接口中没有构造方法（不是类，所以没有构造方法，抽象类也不能被实例化）。implements可以实现多个接口（必须要重写接口中的方法）。

   9. 代码如下：接口

      package oop.demo01.demo10;
      //抽象的思维~架构师
      //interface 定义的关键字，接口都需要有实现类(接口也相当于是个约束)
      public interface UserService {
      ​
          //接口里面定义的属性默认都是常量
          public static final int age = 99;  //一定义就是静态的常量，可以简写成int age = 99;前面的修饰符都是默认的。一般都只会定义方法。
      ​
          //接口中的所有定义的方法其实都是抽象的，public abstract默认的修饰符
          //public void run(){
              //会报错，接口的抽象方法不能有方法体。
          //}
          public abstract void tun();  //public abstract可以省略
          void sun(String name);   //可以简写成这样，只能写最简单的方法。返回值类型  方法名（形参）;
          void add(String name);
          void delete(String name);
          void update(String name);
          void query(String name);
      }
      ​

      代码二：用类实现多个接口

      package oop.demo01.demo10;
      ​
      //抽象类 extends，只能单继承
      //类 可以实现接口，public class 类 implement 接口{}
      //实现了接口的类，必须要重写接口中的所有方法。
      //implement后面可以实现多个接口，只要把两个接口中的方法都重写@override即可。如下所示：就是利用接口实现多继承（伪多继承）
      //区别：类里面有方法的实现，接口里面只有方法的定义。通过interface来定义。
      public class UserServiceImpl implements UserService,TimeService{  //implements关键词就是实现的意思，一个类要去实现接口，要重写接口里面的全部方法，你要遵守这个法律，就要完成里面的所有规范。
      ​
          @Override      //alt + insert  -->implement methods-->select methods to implement-->ok 重写方法
          public void tun() {  //类只要实现了接口里面的六个方法，接口就不报错了，如果要实现接口里面的所有定义，必须要重写接口里面的所有方法。
      ​
          }
      ​
          @Override
          public void sun(String name) {
      ​
          }
      ​
          @Override
          public void add(String name) {
      ​
          }
      ​
          @Override
          public void delete(String name) {
      ​
          }
      ​
          @Override
          public void update(String name) {
      ​
          }
      ​
          @Override
          public void query(String name) {
      ​
          }
      ​
          @Override
          public void timer() {
      ​
          }
      }
      ​

      代码三：接口2

      package oop.demo01.demo10;
      ​
      public interface TimeService {
          void timer();
      }
      ​