java12 - static关键字+抽象类+接口+内部类

static关键字

Student student = new Student();
System.out.println(Student.age);//静态变量 可以通过方法名 来调用
//Student.score  报错 非静态变量 不可以通过方法名 来调用
System.out.println(student.score);
System.out.println(student.age);

• 静态变量对于类 ，所有对象（实例）所共享。
• 静态方法也可以直接在其他方法中调用。

package com.oop.dome07;

public class Person {
    {
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }
    static {
        //静态 代码块
        //类加载的时候永久执行一次.   只执行一次！！！！！！
        System.out.println("静态代码块");
    }

    public Person() {
        System.out.println("构造器");
    }

    public static void main(String[] args) {
        Person person = new Person();

        System.out.println("===============");
        Person person1 = new Person();
        

    }
}
结果
静态代码块
匿名代码块
构造器
===============
匿名代码块
构造器

• 静态 代码块 类加载的时候永久执行一次. 只执行一次！！！！！！最先执行 ，在一个类中
• 先走匿名代码块 再走静态代码块 最后走构造器。

抽象类

• abstract，抽象方法，只有方法名字，没有方法的实现！
• 抽象类的所有方法，继承了他的子类，都必须要实现它的方法。除非子类也是abstract
• 一旦是抽象方法，你这个类必须是抽象类。
• 不能new这个抽象类，只能靠子类去实现他：约束！
• 抽象类中可以写普通的方法。
• 抽象方法必须在抽象类中

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

}

接口

• 普通类：只有具体实现
• 抽象类：具体实现和规范（抽象方法）都有。只能单继承
• 接口：只有规范！自己无法写方法，专业的约束！约束和实现分离：面向接口编程。。
• 接口就是规范，定义的是一组规则，体验了现实世界中“如果你是。。。则必须能。。。”的思想。例如：如果你是天使，则必须能飞；如果你是汽车，则必须能跑 ；如果你是好人 ，则必须干掉坏人；如果你是坏人 ，则必须欺负好人；
• 接口 的本质是契约。就像法律，制定了就必须遵守。
• OO的精髓，是对对象的抽象，最能体现这一点的就是接口。

声明的关键字的是class，声明接口的关键字是interface

接口的定义与实现（关键字interface）

• 可以多继承

• 类可以实现接口 Implements 接

• 实现了接口的类 ， 就需要重写接口的方法

• 多继承，利用接口来实现多继承implements UserService,TimeService

• package com.oop.dome09;
  //Impl就是实现的方法
  //类可以实现接口 Implements 接口
  //实现了接口的类 ， 就需要重写接口的方法
  
  //多继承，利用接口来实现多继承
  public class UserServiceImpl implements UserService,TimeService{
      @Override
      public void run() {
  
      }
  
      @Override
      public void add(String name) {
  
      }
  
      @Override
      public void delete(String name) {
  
      }
  
      @Override
      public void updata(String name) {
  
      }
  
      @Override
      public void query(String name) {
  
      }
  
      @Override
      public void termer() {
  
      }
  }
  

• //insterface 定义的关键字, 接口都应该有实现类
  public interface  UserService {
    
    //接口中定义的都是常量（一般没人这么做 public static final int age = 10;）
      //接口中的多有定义其实都是抽象的 public abstract
      public abstract void run();//不用定义 定义了也变成灰色
      void add(String name);//正常方法
      void delete(String name);//正常方法
      void updata(String name);//正常方法
      void query(String name);//正常方法
  
  }
  

接口的作用

1. 约束
2. 定义一些方法，让不同的人实现～。
3. 方法都是 public abstract。
4. 常量都是 public static final。
5. 接口不能被实例化（new），接口中没有构造方法。
6. 可以实现多个 ，通过imlements可以是实现多个接口。
7. 实现了接口的类，就必须要重写接口中的方法。

内部类

• 内部类就是在一个类的内部在定义一个类，比如，A类中定义了一个B类，那么B类相对于A类来说就可以称为内部类，而A类相对于B类来说就是外部类。

• 1. 成员内部类

  2. 静态内部类

  3. 局部内部类

     public void method(){
         class Inner{
           
         }
     }
     //方法中的类
     

  4. 匿名内部类

     public class test {
         public static void main(String[] args) {
             new Apple().eat();
           //new Apple（）不知道名字是什么 所以这种叫匿名内部类
           //名字没有初始化类，不用将实例保存到变量中
         }
     }
     class Apple{
         public void eat(){
             System.out.println("eat");
         }
     }