JAVA 面向对象08-static、abstract

static静态

（1）当一个类被final修饰，该类就“断子绝孙”，不可以在被继承；
（2）匿名代码块：用来赋初始值，运行顺序在构造器之前。

{
	//匿名代码块
}

静态代码块： 永久只执行一次，和类加载时一起执行。

static{
		//静态代码块
}

（3）静态变量可以用对象/类名调用；非静态变量只能用对象调用。

（4）静态方法可以调用静态方法；
静态方法不可以调用非静态方法；
非静态方法可以调用静态方法。

（5）静态导入包：import static 类名；

Person类：final，匿名代码块，静态代码块

//当一个类被final定义，就不能被继承
public final class Person {

    //2.赋初始值
    {
        //代码块（匿名代码块），创建对象的时候自动会创建，并且在构造器之前
        System.out.println("匿名代码块");
    }
    
    //1.永久只执行一次
    static {
        //静态代码块，用来初始化一些变量
        //和类加载的时候一起执行，永久只执行一次
        System.out.println("静态代码块");
    }
    
    //3.
    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("=================");
        Person person2 = new Person();
    }
}

运行结果：

静态代码块
匿名代码块
构造方法
=================
匿名代码块
构造方法

Student类：变量的调用、方法的调用，静态与非静态方法的调用

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

    public static void main(String[] args) {
        Student s1 = new Student();
        //用对象调用变量
        System.out.println(s1.age);
        System.out.println(s1.score);
        //用类名调用变量，只能调用静态变量
        System.out.println(Student.age);
        //System.out.println(Student.score);//报错score为非静态变量
        //调用方法
        //静态方法
        go();
        Student.go();
        s1.go();
        //非静态方法
        //run();//报错
        //Student.run();//报错 无法从静态方法中引用非静态
        s1.run();
    }
    //非静态方法可以调用静态方法
    //静态方法可以调用静态方法
    //静态方法不可以调用非静态方法
    //非静态方法
    public void run(){
        System.out.println("run");
        go();
    }
    //静态方法
    public static void go(){
        System.out.println("go");
		//run();//报错
    }

Test类：导入静态包
静态导入包，调用里面的静态方法，可以直接调用方法名，例如：random()，不用再类名调用方法名Math.random()。

//不想写Math，直接调用Math里面的方法，可以导入Math包
import java.lang.Math;
//导入random方法，加static
//静态导入包
import static java.lang.Math.random;
public class Test {

    public static void main(String[] args) {
    
        System.out.println(Math.random());//产生一个随机数
        
        System.out.println(random());

    }
}

abstract 抽象

类+abstract=抽象类；
方法+abstract=抽象方法；

注意点：
抽象类中可以没有抽象方法，即抽象类中可以写抽象方法和普通方法，但抽象方法必须在抽象类中。
(1) 抽象类不能使用new实例化，创建对象；

(2) 抽象类中的方法只有方法声明，没有方法的实现，它的实现由子类做；

(3) 子类继承抽象类，要实现父类的抽象方法，否则除非子类也为抽象类。

Action类：为父类，也为抽象类

//使用abstract进行修饰-->抽象类
public abstract class Action {
    //一个约束方法：需要别人帮助实现
    //使用abstract进行修饰-->抽象方法：只有方法的名字，没有方法的实现
    //doSomething()的声明
    public abstract void doSomething();

    public static void suggectA(){
        System.out.println("Suggect A");
    }
    
    //抽象类的无参构造器
    public Action() {
        System.out.println("抽象类的构造器");
    }
}

A类：为子类，也为非抽象类

//继承抽象类的子类，必须要重写父类的抽象方法，除非该类也为抽象类
public class A extends Action{
    @Override//重写父类的抽象方法
    public void doSomething() {

    }

    public A() {
        super();
    }

    public static void main(String[] args) {
        
        A a = new A();//打印输出：抽象类的构造器

    }
}

思考：

抽象类不能new，它存在构造器吗？ 存在

抽象类存在的意义：提高开发效率