java笔记java中static/final/abstract关键字的辨析

Posted 棉花糖灬

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java笔记java中static/final/abstract关键字的辨析相关的知识,希望对你有一定的参考价值。

1. static关键字

static关键字在java中的主要用来修饰变量、方法名和形成静态代码块。

(1) 静态变量

  • 变量可以分为实例变量和静态变量
  • 被static修饰的属性(变量)被成为静态变量(类变量),其不依赖于类的特定实例,而是被类的所有实例所共享
  • 在静态变量所在的类中,可以通过直接访问、类名访问或类的实例方法等进行方法,其他类中可以使用类名.静态变量来使用
  • 静态变量是可以修改的(区别于final)
public class StaticVar {
    public static String str1 = "Hello";
    public static void main(String[] args) {
        String str2 = "World!";
        // 直接访问str1
        String accessVar1 = str1+str2;
        System.out.println("第 1 次访问静态变量,结果为:"+accessVar1);
        // 通过类名访问str1
        String accessVar2 = StaticVar.str1+str2;
        System.out.println("第 2 次访问静态变量,结果为:"+accessVar2);
        // 通过对象svt1访问str1
        StaticVar svt1 = new StaticVar();
        svt1.str1 = svt1.str1+str2;
        String accessVar3 = svt1.str1;
        System.out.println("第3次访向静态变量,结果为:"+accessVar3);
        // 通过对象svt2访问str1
        StaticVar svt2 = new StaticVar();
        String accessVar4 = svt2.str1+str2;
        System.out.println("第 4 次访问静态变量,结果为:"+accessVar4);
    }
}

(2) 静态方法

  • 被static修饰的方法被称为静态方法(类方法),其他的被称为实例方法
  • 静态方法不需要通过其所属类的实例就可以被调用,因此静态方法中不能使用this和super关键字,也不能直接访问所属类的实例变量和实例方法,但可以访问所属类的静态变量和静态方法
  • 访问静态方法时,可以直接访问,也可以通过类名来访问,还可以通过实例化对象来访问
public class StaticMethod {
    public static int count = 1;    // 定义静态变量count
    public int method1() {    
        // 实例方法method1
        count++;    // 访问静态变量count并赋值
        System.out.println("在静态方法 method1()中的 count="+count);    // 打印count
        return count;
    }
    public static int method2() {    
        // 静态方法method2
        count += count;    // 访问静态变量count并赋值
        System.out.println("在静态方法 method2()中的 count="+count);    // 打印count
        return count;
    }
    public static void PrintCount() {    
        // 静态方法PrintCount
        count += 2;
        System.out.println("在静态方法 PrintCount()中的 count="+count);    // 打印count
    }
    public static void main(String[] args) {
        StaticMethod sft = new StaticMethod();
        // 通过实例对象调用实例方法
        System.out.println("method1() 方法返回值 intro1="+sft.method1());
        // 直接调用静态方法
        System.out.println("method2() 方法返回值 intro1="+method2());
        // 通过类名调用静态方法,打印 count
        StaticMethod.PrintCount();
    }
}public class StaticMethod {
    public static int count = 1;    // 定义静态变量count
    public int method1() {    
        // 实例方法method1
        count++;    // 访问静态变量count并赋值
        System.out.println("在静态方法 method1()中的 count="+count);    // 打印count
        return count;
    }
    public static int method2() {    
        // 静态方法method2
        count += count;    // 访问静态变量count并赋值
        System.out.println("在静态方法 method2()中的 count="+count);    // 打印count
        return count;
    }
    public static void PrintCount() {    
        // 静态方法PrintCount
        count += 2;
        System.out.println("在静态方法 PrintCount()中的 count="+count);    // 打印count
    }
    public static void main(String[] args) {
        StaticMethod sft = new StaticMethod();
        // 通过实例对象调用实例方法
        System.out.println("method1() 方法返回值 intro1="+sft.method1());
        // 直接调用静态方法
        System.out.println("method2() 方法返回值 intro1="+method2());
        // 通过类名调用静态方法,打印 count
        StaticMethod.PrintCount();
    }
}

(3) 静态代码块

  • 静态代码块指 Java 类中的 static{ } 代码块,主要用于初始化类,为类的静态变量赋初始值
  • 静态代码可类似于一个方法,可以位于类中的任意位置,一个类中也可以有多个静态代码块
  • java虚拟机在加载类时按其出现的顺序执行一次静态代码块
  • 静态代码块中不能访问类的实例变量和实例方法,而需要类的实例对象来访问
public class StaticCode {
    public static int count = 0;
    
    // 非静态代码块
    {
        count++;
        System.out.println("非静态代码块 count=" + count);
    }
    
    static {
        count++;
        System.out.println("静态代码块1 count=" + count);
    }
    
    static {
        count++;
        System.out.println("静态代码块2 count=" + count);
    }

    public static void main(String[] args) {
        System.out.println("*************** StaticCode1 执行 ***************");
        StaticCode sct1 = new StaticCode();
        System.out.println("*************** StaticCode2 执行 ***************");
        StaticCode sct2 = new StaticCode();
    }
}

上述代码中 { } 代码块为非静态代码块,非静态代码块是在创建对象时自动执行的代码,不创建对象不执行该类的非静态代码块。代码域中定义的变量都是局部的,只有域中的代码可以调用。

2. final关键字

final表示对象是最终形态的,不可改变的。可用作变量、方法和类。

(1) 修饰变量

  • final修饰的变量即常量,其值不可改变(区别与不能赋值)
  • final修饰的成员变量如果没有赋值时,需要在构造方法或者静态代码块中初始化
  • final修饰的局部变量必须在使用前被赋值一次
  • 对基本类型变量来说是其值不可变,而对对象引用类型变量来说其引用不可再变
  • 使用 final 修饰的引用类型变量不能被重新赋值,但可以改变引用类型变量所引用对象的内容
  • 在使用 final 声明变量时,要求全部的字母大写
public class FinalDemo {
    void doSomething() {
        // 没有在声明的同时赋值
        final int e;
        // 只能赋值一次
        e = 100;
        System.out.print(e);
        // 声明的同时赋值
        final int f = 200;
    }

    // 实例常量
    final int a = 5; // 直接赋值
    final int b; // 空白final变量
    // 静态常量
    final static int c = 12;// 直接赋值
    final static int d; // 空白final变量
    // 静态代码块
    static {
        // 初始化静态变量
        d = 32;
    }

    // 构造方法
    FinalDemo() {
        // 初始化实例变量
        b = 3;
        // 第二次赋值,会发生编译错误
        // b = 4;
    }
}

(2) 修饰方法

final 修饰的方法不可被重写,但可重载,若不希望子类重写父类的某个方法,则可以使用 final 修饰该方法。

public class FinalMethodTest {

    public final void test() {
    }
}

class Sub extends FinalMethodTest {

    // 下面方法定义将出现编译错误,不能重写final方法
    public void test() {
    }
}

(3) 修饰类

final 修饰的类不能被继承。

final class SuperClass {
}

class SubClass extends SuperClass {    //编译错误
}

3. abstract关键字

  • java中有两种类,一种是具体类,另一个种是抽象类
  • 用abstract修饰的类叫做抽象类,用abstract修饰的方法叫做抽象方法,抽象方法只有方法的声明,没有方法的实现
  • abstract不能用于修饰静态方法和构造方法
  • 抽象方法无方法体,必须存在于抽象类中,子类重写父类时,必须重写父类所有的抽象方法。
  • 在使用 abstract 关键字修饰抽象方法时不能使用 private 修饰,因为抽象方法必须被子类重写,而如果使用了 private 声明,则子类是无法重写的
  • 抽象类中也可以有具体方法,抽象类不能实例化,即不能用new关键字创建对象

图形的抽象类:

public abstract class Shape {
    public int width; // 几何图形的长
    public int height; // 几何图形的宽

    public Shape(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public abstract double area(); // 定义抽象方法,计算面积
}

正方形类:

public class Square extends Shape {
    public Square(int width, int height) {
        super(width, height);
    }

    // 重写父类中的抽象方法,实现计算正方形面积的功能
    @Override
    public double area() {
        return width * height;
    }
}

以上是关于java笔记java中static/final/abstract关键字的辨析的主要内容,如果未能解决你的问题,请参考以下文章

Java笔记

Java笔记(继承)

JAVA笔记(11)--- 精讲异常(附枚举);

Java学习笔记

Java学习笔记之:Java数组

Java基础笔记2