day19 - static关键字，抽象类，接口

static关键字

类中直接一个代码块匿名代码块用于初始赋值
static修饰的代码块静态代码块只执行一次
构造函数

在声明类的对象时先调用静态代码块之后是匿名代码块最后时构造函数方法，且静态代码快只调用一次就失效，之后不再调用

 1  //2
 2  {
 3      //匿名代码块(赋初始值)
 4      System.out.println("匿名");
 5  }
 6  //1
 7  static {
 8      //静态代码块（只执行一次）
 9      System.out.println("静态");
10  
11  }
12  
13  //3
14  public Person() {
15      System.out.println("构造");
16  
17  }
18  
19  public static void main(String[] args) {
20      Person person = new Person();
21      //静态 > 匿名 > 构造函数
22      Person person1 = new Person();
23  
24  
25  }

static修饰的是静态变量，不使用static的是非静态变量

同时static可以修饰方法

无法通过类调用非静态变量

 1  public class Student {
 2      private static int age;//静态变量
 3      private double score;//非静态变量
 4  
 5      public void run(){
 6  
 7      }
 8  
 9      public static void go(){
10  
11      }
12  
13      public static void main(String[] args) {
14          Student student = new Student();
15          System.out.println(student.score);
16          System.out.println(student.age);
17          System.out.println(Student.age);
18          //System.out.println(Student.score);
19  
20      }
21  
22  }

抽象类

使用abstract修饰类，就变成了抽象类

抽象类中可以写抽象方法也可以写普通方法，但抽象方法必须写在抽象类中。public abstract void xxx（）定义抽象方法

抽象类可以由其他类继承，抽象类中所有的方法必须由子类实现，除非子类也是抽象类

 1 //使用abstract修饰类 就变成了抽象类
 2  public abstract class Action {
 3      //约束，有人实现
 4      public abstract void dosomething();
 5  
 6      public Action() {
 7  
 8      }
 9  }
10  抽象类///////////
11  ////////////继承子类
12  public class A extends Action{
13      @Override
14      public void dosomething() {
15  
16      }
17  }

总结：

1  /*
2  抽象类：
3  1. 不能new这个抽象类，只能靠子类去实现它，是一个约束
4  2. 抽象类里面可以写普通方法，抽象方法必须写在抽象类里卖弄
5  抽象类存在构造器嘛？存在
6  抽象类的意义是什么？ 将方法抽象出来，让子类实现。提高开发效率
7  
8   */

接口

接口是一种规范，定义的必须由后面的对象遵守

interface定义接口的关键字

public interface xxxxx{} 定义接口

接口中所有的定义都是抽象的

默认是 public abstract类型的（不用再重复写）

接口中定义的属性是静态常量，默认是public static final

 1 //interface 定义接口的关键字  接口的定义都需要实现类
 2  public interface UserSerbice {
 3      //接口中的所有定义都是抽象的
 4      //默认都是public abstract
 5      int age =99;
 6      //接口中定义的属性是一个静态的常量 省略了public static final
 7      void add(String name);
 8      void del(String name);
 9      void update(String name);
10      void find(String name);
11  }
12  
13  接口定义

定义接口需要一个实现类

实现类需要重写接口的方法，经常以接口名+Impl命名

public class xxxImpl implements 接口名{}（定义）

实现类可以同时实现多个接口，即多继承接口

实现类必须重写接口中的方法

 1 //实现类需要重写接口中的方法 经常以接口名+impl结尾
 2  //多继承，一个类可以继承多个接口
 3  
 4  public class UserSerbiceImpl implements UserSerbice,TimeService {
 5  //实现了接口的类，就必须重写接口中的方法
 6  
 7      @Override
 8      public void add(String name) {
 9  
10      }
11  
12      @Override
13      public void del(String name) {
14  
15      }
16  
17      @Override
18      public void update(String name) {
19  
20      }
21  
22      @Override
23      public void find(String name) {
24  
25      }
26  
27      @Override
28      public void timer() {
29  
30      }
31  }

总节：

1  接口的作用：
2      1. 是一个约束
3      2. 定义一些方法，让不同的人实现
4      3. 接口中默认的方法都默认是public abstract
5      4. 接口中的常量都默认是 public static final
6      5. 接口不能被实例化，没有构造方法
7      6. 实现接口的类可以伪继承多个接口 使用implement
8      7. 实现接口的类必须重写接口中的