JAVA 关键字

参考博客：https://www.cnblogs.com/yan-linxi/p/7977947.html

JAVA的关键字都是小写的

 

(1)简述Java访问修饰符

private: 在同一类内可见，不能修饰类

default: 默认访问修饰符，在同一包内可见
protected : 对同一包内的类和所有子类可见，不能修饰类
public: 对所有类可见

 

 

访问修饰符(private/public/protected/缺省)学习

https://blog.csdn.net/so_geili/article/details/106006740

Parent类

package com.learning.protectedDemo;
/**
 * 父类(基类).
 */
public class Parent {
    protected void getName() {
        System.out.println("I'm Parent!");
    }
}

Son类

package com.learning.protectedDemo.package_one;
import com.learning.protectedDemo.Parent;
/**
 * Son类.（位置：和Parent类不同包。）
 */
public class Son extends Parent {
    // Son自身也可以定义protected访问级别的方法
    protected void sing() {
        System.out.println("I'm son!");
    }

    public static void main(String[] args) {
        Parent parent = new Parent();
        parent.getName();       //(1) 编译失败。子类与父类不在同一包中时，子类中不能访问父类实例的protected方法。只有当子类与父类同包时，子类中才能访问父类实例的protected方法。

        Son son = new Son();
        son.sing();             //(2) 编译通过。原因：在Son类自身中创建了一个Son类的实例，那么该实例总是可以通过“.”运算符访问继承的或自己定义的protected变量和方法；
        son.getName();          //(3) 编译通过。原因同上。
    }
}

Other类

package com.learning.protectedDemo.package_one;
import com.learning.protectedDemo.Parent;
/**
 * 其他类.(位置：和Son类同包，和Parent类不同包)
 */
public class Other {
    public static void main(String[] args) {
        Son son = new Son();
        son.sing();                 //(4) 编译通过：由于Other类和Son类在同一个包下，所以可以声明Son实例，通过实例中定义的protected修饰的sing方法；
        son.getName();              //(5) 编译失败：由于Son类中的getName方法是继承于Parent类，Other类和Parent类不在同一个包下，无法访问Son类继承而来的protected方法。

        Parent parent = new Parent();
        parent.getName();           //(6) 编译失败：由于Other类和Parent类不在同一个包内，Other类中不可以访问Parent类实例的protected方法；
    }
}

 

(2)类成员变化修饰符

参考链接：https://skydai.github.io/2020/11/21/Java%E5%85%B3%E9%94%AE%E5%AD%97static%E5%92%8Cfinal/

1  static

通常情况下， 类成员需要通过它的类的对象访问，如果一个成员被声明为static，它能够在它的类的任何对象创建之前被访问， 而不用引用任何对象。
声明为static的一个类变量或方法，所有的该类的实例都会共享这个static变量或方法。

static修饰变量

静态变量在内存中只有一份， jvm只为静态变量分配一次内存，随着类的加载而加载到静态方法区内存中。由于静态变量属于类，和类的实例无关， 所以可以直接通过类名进行访问。

对于成员变量，每创建一个该类的实例就会创建该成员变量的一个拷贝，分配一次内存，由于成员变量是和类的实例绑定的，所以不能直接通过类名对它进行访问。

static修饰方法

• 只能调用其他的static方法
• 只能访问static数据
• 不能以任何方式引用this 和super
• static 方法独立于任何实例， 所以static方法必须被实现，不能是抽象的absract，在static方法里引用任何的实例变量都是违法的。

 

静态方法可以直接通过类名调用， 任何该类的实例也可以调用它的静态方法， 所以静态方法不能用this或者super。

static修饰代码块。

它独立于类成员，可以有多个， jvm 加载类的时候会执行这些静态代码块， 如果有static代码块多个，jvm会按照他们在类中出现的顺序执行且每个只执行一次。可以通过静态代码块对static变量进行赋值。

 

2 final

final可以修饰非抽象类， 非抽象类成员方法和变量。使用final关键字可以声明类、成员变量和成员方法，一经声明，便不可继承、不可修改和不能覆盖。

final修饰变量

修饰的变量是基本数据类型则值不能改变，修饰的变量是引用类型则不能再指向其他对象。一个变量可以声明为final， 目的是阻止它的内容被修改， 这意味着声明final变量的时候， 必须对其进行初始化，这种用法有点类似于c++的const。

按照编码约定， final变量的所有字符选择大写，final修饰的变量实际中不占用内存， 它实质上是一个常数。

final修饰方法

被final修饰的方法可以被子类继承， 但不能被子类的方法覆盖。 如果一个类不想让其子类覆盖它的某个成员方法， 就可以用 final关键字修饰该方法。

使用final修饰成员方法除了不想让子类覆盖外， 还有一个原因就是高效，Java编译器在遇到final修饰的方法的时候会转入内嵌机制， 提高执行效率。

内嵌机制 ，类似于c++ inline, 调用方法的时候直接将方法的主题插入到调用处， 而不用去访问类或者对象， 这样会提高50%左右效率。然而，如果方法主体比较庞大， 
且多处被调用将导致主体代码膨胀， 同时也产生效率问题， 所以需要慎用。

class Base {
    private final void method() {
        System.out.println("In Base...");
    }
}
class Sub extends Base {
    public void method() {
        System.out.println("In Sub...");
    }
}

本例中，基类方法 是private ，他在子类中是不可见的，故子类中的 同名方法 不再是覆盖，相当于一个新的方法名。

final修饰类

final修饰的类不能被继承。

 

(3) final、finally和finalize的区别是什么？

1. final用于声明属性、方法和类，分别表示属性不可变、方法不可覆盖、类不可继承。
2. finally作为异常处理的一部分，只能在try/catch语句中使用，finally附带一个语句块用来表示这个语句最终一定被执行，经常被用在需要释放资源的情况下。
3. finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的finalize()方法。当垃圾回收器准备好释放对象占用空间时，首先会调用finalize()方法，并在下一次垃圾回收动作发生时真正回收对象占用的内存。