初始化块

初始化块

• 作用类似构造方法，可以对对象进行初始化操作。
• 无法传入任何参数，可以理解为提前执行的代码

使用初始化块

//class 类名{
//[修饰符]{
//        初始化块的可执行代码
//    }
//}

class Demo{
    {
        System.out.println("初始化块");
    }

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

}

public class Demo1 {
    public static void main(String[] args) {
        Demo Demo = new Demo();
    }
}

[buy] 如果有静态初始化块，会优先执行[/buy]

class Demo{
    static {　//属于类
        System.out.println("静态初始化块");
    }
    {　//属于对象  在初始化块中的变量属于局部变量，需要初始化
        System.out.println("初始化块");
    }

    public Demo(){　//属于对象
        System.out.println("构造方法");
    }
}

public class Demo1 {
    public static void main(String[] args) {
        Demo Demo = new Demo();
    }
}

运行结果：

Final 修饰符

final 关键字可用于修饰类，变量和方法。用来表示修饰的变量不可改变。

一旦初始化就无法赋值了。

[warning]final 只能在定义时，构造方法里以及初始化块中，无法在Main方法中赋值[/warning]

• Final 修饰变量

定义必须初始化，一旦初始化就无法赋值

class Demo{
    final static int A  ;
    final int B  ;
    final int C = 10 ;  //定义

    static {  //静态初始化块
        A = 10 ;
    }

    public Demo (){ //构造方法
        B = 10 ;
    }

    public int getA(){
        return A ;
    }
    public int getB(){
        return B ;
    }
    
    public int getC(){
        return C;
    }

}

public class Demo1 {
    public static void main(String[] args) {

        Demo Demo = new Demo();

        System.out.println(Demo.getA());
        System.out.println(Demo.getB());
        System.out.println(Demo.getC());

        
    }

}

• Final修饰数组

指向的地址无法改变，可以改变数组中元素的值

public class Demo {
    public static void main(String[] args) {
        final int[] Arr = {1,2,3};  //定义数组Arr 元素有 1,2,3
        for (int i = 0;i<Arr.length;i++){
            Arr[i] = Arr[i] * 2 ;  //元素大小乘2
            System.out.print(Arr[i] +" ," );  //遍历输出
        }
    }
}

输出结果：

• Final 修饰方法

如果有子类，则无法对加 Final 的方法进行重写

• Final 修饰类

将无法被继承

抽象类(abstract )

不包含方法体的方法称为 “抽象方法”，（在JAVA中只要有花括号括起来的都是方法体）

• 作用＆注意

拿来当父类使用，无法被实例化，abstract方法只能存在于abstract类中,abstract方法只能被重写

无法修饰属性,无法修饰构造方法，abstract只有重写才有意义

abstract class DemoAbstract {
    public abstract void Print1();  //抽象方法 Print1
    public void Print2(){ //普通方法 Print2
        System.out.println("DemoAbstract.Print2");
    }
}
public class Demo extends DemoAbstract{
    public void Print1(){  //重写抽象方法
            System.out.println("Demo.Print");
    }

    public static void main(String[] args) {
        Demo Demo = new Demo();
        Demo.Print1();  //继承重写的抽象方法
        Demo.Print2();  //抽象类写的普通方法
    }
}

[noway] abstract无法和final同时使用[/noway]

abstract 构造方法

abstract class DemoAbstract {

    String Name ;

    public DemoAbstract(String Name){
        this.Name = Name;  //抽象类中的构造方法 DemoAbstract
    }

}

public class Demo extends DemoAbstract{

    public Demo(String Name){  //子类的构造方法
        super(Name); //super调用父类 DemoAbstract 的构造方法
    }

    public static void main(String[] args) {
        Demo Demo = new Demo("Name");
        System.out.println(Demo.Name);  //输出父类 DemoAbstract 的属性 Name 的值
    }

}