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

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();//非静态方法需要new
        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;

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

    }
}
*/

interface（声明接口关键字不是class）

定义

普通类—只有具体实现

抽象类—具体实现和规范都有

接口—只有规范！自己无法写方法，约束和实现分离

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

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();
}
*/

内部类

1、通过外部类来实列化内部类使用

2、直接获得外部类的私有属性

重写的条件，多态的用法，内部类