static、代码块、静态导入包，abstract(抽象类)，interface(接口)、implements(接口实现方式)

static详解

//static
package oop;

public class F1 {
    private static int age;//静态的变量
    private double score;//非静态的变量

    public void run(){
        go();//当前类里非静态的也可以直接访问静态的
    }
    public static void go(){

    }

    public static void main(String[] args) {
/*        F1 f1 = new F1();
        System.out.println(F1.age);
    //    System.out.println(F1.score); //非静态会报错
        System.out.println(f1.age);
        System.out.println(f1.score);

 */
        go();//当前类里静态方法可以直接调用静态方法,不能直接调用非静态方法
        new F1().run();//非静态方法
        F1.go();//非同类里的静态调用方法
    }
}

代码块

//代码块
package oop;

public class F2 {
 /*   {
        //代码块（匿名代码块）
        //
    }
    static {
        //静态代码块（匿名代码块）
    }
 */
    //赋初始值
  {
      System.out.println("匿名代码块");//第二输出
  }
  //只执行一次
  static{
      System.out.println("静态代码块");//最先输出
  }

    public F2() {
        System.out.println("构造方法");//最后输出
    }

    public static void main(String[] args) {
        F2 f21 = new F2();
        System.out.println("==============");
        F2 f22 = new F2();
    }
}

静态导入包

//静态导入包
package oop;
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class F3 {
    public static void main(String[] args) {
        System.out.println(Math.random());
        //静态导入后可以直接
        System.out.println(random());
        System.out.println(PI);
    }
}

abstract(抽象类)

/* 抽象类-abstract修饰符-提高开发效率
本质是（类）-需要去继承-局限性（单继承）
特点
 1、不能去new,只能靠子类去实现它：约束
 2、抽象类可以写抽象方法且抽象方法必须在抽象类中
 3、抽象的抽象：约束
*/
package oop;
// 在类前加入abstract关键字就变成了 抽象类
public abstract class G1 {
    //约束 有人能帮忙实现
    //在方法前加入abstract关键字就变成了 抽象方法-只有方法的名字，没有方法的实现
    public abstract void doSomething();
}


/*
package oop;

//抽象类的所有方法，继承了它的子类都必须要实现它的方法，除非
public class G2 extends G1{
//    new G1();//会报错
    @Override
    public void doSomething(){

    }
}
*/

interface

定义

/* 接口interface-只有规范、契约（制定了就要遵守）-约束和实现分离
作用
1、约束
2、定义一些方法，让不同人实现
3、方法都是 public abstract 常量都是public static final
4、接口不能被实列化，接口中没有构造方法
5、通过implements关键字可以实现多个接口
7、必须要重写Overried接口中的方法
 */
package oop;

public interface H1 {
    //接口中的所有定义其实都是抽象的 public abstract默认的可以不写
    void add(String name);//前面的绿标，点一下就跳到对应的方法
    void delete(String name);
    void update(String name);
    void guery(String name);
    //属性定义的都默认为常量   public static final可以不写
 // public static final int Age=99;
    int age=99;
}

implements(接口实现方式)

//类实现接口方式implements
package oop;
//抽象类：extends-单继承
//类 通过implements关键字重写方法啊 接口-多继承
public class H2 implements H1,H3{
    //alt+enter快捷键
    //实现接口的类，就需要重写接口中的方法
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void guery(String name) {

    }

    @Override
    public void timer() {

    }
}


/*
package oop;

public interface H3 {
    void timer();
}
*/