Day09-面向对象（三）

static关键字

• public class Person{
      {
          //代码块（匿名代码块）
      }
      static{
          //静态代码块
      }
  }

• 静态代码块（只执行一次）>匿名代码块（一般用来赋初始值）>构造方法

抽象类

• 抽象类的所有方法都需要子类实现

• 特点：

  1. 不能new这个类，只能靠子类去实现它；约束！

  2. 抽象类可以写普通方法

  3. 抽象方法必须在抽象类中

  4. 抽象的抽象：约束！

• public abstract class Action {
      //约束~有人帮我们实现
      //abstract 抽象方法，只有方法名字，没有方法的实现
      public abstract void doSomething();
      public abstract void doAnything();
  }

接口

• 接口：只有规范！自己无法写方法

• 接口就是规范，定义的是一组规则

• 接口的本质是契约

• 接口中所有定义其实都是抽象的，默认public abstract

• 接口的作用小结

  1. 约束

  2. 定义一些方法，让不同人实现

  3. public abstract

  4. public static final

  5. 接口不能实例化，接口中没有构造方法

  6. implements可以实现多个接口

  7. 必须重写接口中的方法

     public interface UserService {
     ​
         //抽象的思维~java 架构师 
     ​
         //常量public static final
         int AGE = 18;
         void add(String name);
     ​
         void delete(String name);
     ​
         void update(String name);
     ​
         void query(String name);
     }
     ​
     ​
     ​
     public class UserServiceImpl implements UserService,TimeService{
     //抽象类：extends~
         //类 可以实现接口 implements 接口
         //实现接口的类，就需要重写接口中的方法
         @Override
         public void add(String name) {
     ​
         }
     ​
         @Override
         public void delete(String name) {
     ​
         }
     ​
         @Override
         public void update(String name) {
     ​
         }
     ​
         @Override
         public void query(String name) {
     ​
         }
     ​

内部类

• 内部类就是在一个类的内部再定义一个类，比如A中定义一个B类，B相对A来说就是内部类

• 种类

  1. 成员内部类

  2. 静态内部类

  3. 局部内部类

     public class Outer {
         public void method(){
             class Inner{
                 
             }
         }
     }

  4. 匿名内部类

• public class Outer {
  ​
      private int id = 10;
      public void out(){
          System.out.println("外部类方法");
      }
      public class Inner{
          public void in(){
              System.out.println("内部类方法");
          }
  ​
  ​
          public void getID(){
              System.out.println(id);
          }
      }
  }
  ​
  ​
  public class Application {
      public  static void main(String[] args){
          Outer outer = new Outer();
          //通过外部类来实例化内部类
          Outer.Inner inner = outer.new Inner();
          inner.getID();
      }
  ​

• 一个文件中只能有一个public class，可以有多个class

• public class Test {
      public static void main(String[] args) {
          //没有名字初始化乐力，不用将实例保存到变量中
          new Apple().eat();
      }
  }
  class Apple{
      public void eat(){
          System.out.println("1");
      }