Java面向对象学习（四）static关键字与抽象类

1.static：静态的

2.static用法

1）static修饰属性

static可以修饰变量，被static修饰的变量都是存放在堆中的静态方法区，与类一起加载。

所以调用static修饰的变量可以使用  类名.变量名的方式调用，且一般都是使用这种方式

public class Student {
    private static String name;     //静态的变量，一般用于多线程中
    private int age;    //非静态的变量

    public static void main(String[] args) {
        //要使用这个类，先要初始化这个类
        Student student = new Student();

        //static修饰的对象我们一般都直接用类.变量的方式调用，而非静态变量不可以
        System.out.println(name);   //在当前类可以直接调用name，但不能直接调用age
        System.out.println(Student.name);   //在其他类中可以直接调用类名.name
        //System.out.println(Student.age); //这句话报错Non-static field 'age' cannot be referenced from a static context
        //也可以通过对象调用
        System.out.println(student.name);
        System.out.println(student.age);
    }
}

 

2）static修饰方法

调用方法与属性同理

public class Student {
    //static修饰方法
    //静态方法
    public static void run1(){

    }
    //非静态方法，在非静态方法中可以直接调用静态方法，因为静态方法是和类一起加载的
    public void run2(){
        run1();
    }

    public static void main(String[] args) {
        //可以直接调动静态方法run1
        run1(); //当前类中调用的写法
        Student.run1(); //其它类中调用的写法
        //run2();在调用时必须先初始化这个类,否则不能调用
        new Student().run2();
    }
}

3）static修饰代码块

static修饰代码块，与类一起加载，只会加载一次。加载顺序为：静态代码块>匿名代码块>构造方法

//static修饰代码块
public class Person {
    //匿名代码块：没有名字定义的代码块，用于赋初始值，和类一起加载
    {
        System.out.println("匿名代码块");
    }

    //静态代码块，和类一起加载，且只会加载一次
    static {
        System.out.println("静态代码块");
    }

    //构造方法
    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        /*第一次初始化这个类的时候，执行顺序为
        静态代码块
        匿名代码块
        构造方法
         */
        System.out.println("==============");
        Person person2 = new Person();
        /*第二次初始化这个类的时候，静态代码块不会再执行。执行顺序为
        匿名代码块
        构造方法
         */
    }
}

4）static静态导入包

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
    public static void main(String[] args) {
        //要想调用random()方法，需要调用Math.random()
        System.out.println(Math.random());
        /*但是可以通过静态导入Math.random这个包，实现只写random()来调用
          先Ctrl点开Math，查看它属于哪个包。查到是java.lang
          于是可以导入import java.lang.Math.random;，但是此时会报错，还需要加上static才行。
         */
        System.out.println(random());
        System.out.println(PI);
    }
}

 

 

2.抽象类

在普通的方法中加上abstract关键字，就成了抽象类

抽象类中可以写抽象方法和非抽象方法，抽象方法必须写在抽象类中。这些方法只是一个约束（只有方法名，没有具体的实现），具体功能由抽象类下面的非抽象子类完成（如果抽象类的子类还是抽象类，则有子子类，即一直往下，知道不是抽象类的子类来完成）

抽象类不能new，只能靠子类实现它的方法，new它非抽象类的子类

抽象类存在的意义：抽象出共同的方法。

//普通类加上abstract关键字就是抽象类
public abstract class Father {
    //抽象类中的方法只是一个约束，方法具体的功能要由子类实现
    public abstract void add();
    public void delete(){
        
    }
}

抽象类中可以写抽象方法和非抽象方法，抽象方法只是一个约束，没有实现。非抽象方法可以写实现。

public class Son extends Father{
    //必须有下面重写的方法，否则子类会报错
    @Override
    public void add() {
    }
}

在非抽象的子类中必须重写抽象方法，否则会报错。快捷键：Ctrl+o、Alt+insert----Override Methods