代码块，final关键字和抽象类

代码块

1. 代码块的作用:用来初始化类、对象
2. 代码块如果有修饰的话，只能使用static

分类:静态代码块，非静态代码块

静态代码块
内部可以有输出语句
随着类的加载而执行，而且只执行一次
作用：初始化类的信息
如果一个类定义了多个静态代码块，安声明先后顺序执行

非静态代码块
内部可以有输出语句
随着对象的创建而执行
每创建一个对象， 就执行一次非静态代码块

public class test {
    public static void main(String[] args){
        Person.show();
        System.out.println("--------------------");
        Person p = new Person();
    }
}

class Person{
    public Person(){
        System.out.println("Person无参构造器");
    }
    static {
        System.out.println("静态代码块");
    }
    {
        System.out.println("非静态代码块");
    }
    public static void show(){
        System.out.println("静态方法");
    }
}
/*输出结果为：
静态代码块
静态方法
--------------------
非静态代码块
Person无参构造器
*/

从以上代码可以看出，类加载时，先执行静态代码块，然后执行静态方法，创建对象后，先执行非静态代码块，然后执行构造器。

开发中代码块的使用举例

当我们需要一些创建对象时只能执行一次的操作都可以使用静态代码块，例如数据库连接池的开发

final

final :最终的

1. final可以用来修饰的结构: 类、方法、变量
2. final 用来修饰一个类:此类不能被其他类所继承。比如: String类、 System类、StringBuffer类
3. final用来修饰方法:表明此方法不可以被重写。比如Object的getClass
4. final修饰变量：此时的“变量”就称为常量

抽象类

abstract关键字的使用

1. abstract :抽象的
2. abstract可以用来修饰的结构:类、方法
3. abstract修饰类:抽象类，此类不能实例化，且抽象类中一定有构造器，便于子类实例化时调用(涉及:子类对象实例化的全过程)，开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
4. abstract修饰方法: 抽象方法
   抽象方法只有方法的声明，没有方法体
   包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
   若子类重写了父类中的所有的抽象方法后，此子类方可实例化
   若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类， 需要使用abstract修饰

应用场景：父类不需要直接调用，子类会对其进行重写

代码：

public class test {
    public static void main(String[] args){
        Student s = new Student("小明",22,11111);
        s.work();
        s.eat();
    }
}

abstract class Biology{
    int age;
    abstract public void work();
    abstract public void eat();
}

abstract class Person extends Biology{
    String name;
    public void eat(){
        System.out.println("人类吃东西");
    }
}

class Student extends Person{
    long id;//学号
    public void work(){
        System.out.println("学生写作业");
    }
    public Student(String name,int age,long id){
        this.id = id;
        this.age = age;
        this.name = name;
    }
    public Student(){}
}
/*输出结果为：
学生写作业
人类吃东西
*/

abstract不能用来修饰构造器。属性等结构。且不能用来修饰私有方法，静态方法，final的方法，类。

创建抽象类的匿名子类对象：

public class test {
    public static void main(String[] args){
        Person p = new Person() {
            @Override
            public void work() {
                
            }
        };
    }
}

abstract class Biology{
    int age;
    abstract public void work();
    abstract public void eat();
}

abstract class Person extends Biology{
    String name;
    public void eat(){
        System.out.println("人类吃东西");
    }
}