java中关键字匹配返回关键字

转载

游侠小影 2024-10-29 13:56:53

文章标签 java中关键字匹配返回关键字 python c/c++ java System 文章分类 Java 后端开发

关键字：

final finalize finally
throws和throw
static关键字的作用
abstract和 interface
super和 this
synchronize和 volatile
String、StringBuffer、StringBuilder

1. final、finalize、finally对比

（1）性质不同

final为关键字；
finalize为方法；
finally为为区块标志，用于try语句中；

（2）作用不同

final：用于标识常量的关键字，final标识的关键字存储在常量池中（在这里final常量的具体用法将在下面进行介绍）；final定义的变量值不可变，方法不可覆写，类不可继承。
定义变量：一旦初始化（声明处或构造函数中）便不可改变。对基本类型是其值不可变，对引用类型是引用不可变；（String天生就是final的）
定义方法：1）使用final定义的方法，不允许覆写，认为其功能满足要求无需扩展时；2）允许编译器将所有对此方法的调用转化为inline（行内机制），即可以将此方法直接复制在调用处，而不是进行例行的方法调用（保存断点、压栈），可以提高效率。但如果过多的话，会造成代码膨胀，反而会影响效率，慎用。
定义类：无法被继承，这也就意味着此类在一个继承树中是一个叶子类；类成员是不是final都可以。
finalize：方法在Object中进行了定义，用于在对象“消失”时，由JVM进行调用用于对对象进行垃圾回收，类似于C++中的析构函数；用户自定义时，用于释放对象占用的资源（比如进行I/0操作）；
finally{}：用于标识代码块，与try{}进行配合，是异常处理模型的补充，不论try中的代码执行完或没有执行完（这里指有异常），该代码块之中的程序必定会进行；不可单独使用，在一个try...catch...finally语句块中最多只有一个finally；一般用来维护对象的内部状态，清理非内存资源。

2. throws和throw对比（Java中throws和throw的区别讲解）

（1）使用位置不同

throw位于方法体内部，可以作为单独语句使用；
throws位于方法头部的参数列表后面，不能单独使用；

（2）内容不同

throw抛出一个具体的异常对象，而且只能是一个；
throws声明抛出的异常类，可以同时声明多个；

（3）作用不同

throw用于在程序中抛出异常，一旦执行说明一定有异常抛出，由方法体内部语句处理异常；
throws用于声明在该方法内可能抛出的异常类，如果抛出了异常，由该方法的调用者处理，层层上抛；

总结：函数调用时，如果需要向上层抛出异常，就必须在函数头部显式地声明（throws Exception1, Exception2）异常类型；如果仅需要在方法体内部处理异常，方法体内部可自行处理该异常，thorw抛出具体的异常实例（catch(Exception1 e){...}）。

3. static关键字的作用

static关键字可用来修饰属性、方法、代码块，目的是把对象相关的变成类相关的，即：不加static的成员是对象相关的，归单个对象所有；加static修饰的成员是类成员，可以通过类名直接调用，归所有对象所有。

static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：

类名.静态方法名(参数列表…)
类名.静态变量名

（1）static修饰属性（类变量、静态变量）

被static修饰的变量，叫静态变量或类变量，可通过类名直接访问；没有被static修饰的变量，叫实例变量。
静态变量为本类所有对象共享；实例变量只属于单个对象。
静态变量在内存中只有一个拷贝，在类加载时被创建和初始化，JVM只为其分配一次内存（节省内存）。类加载过程只进行一次，因此静态变量也只会被创建一次；实例变量在创建对象时被初始化，在内存中有多个拷贝，每创建一个对象就会为其分配一次内存，各实例变量间互不影响（灵活）。

所以一般在需要实现以下两个功能时使用静态变量：

1）在对象之间共享值时；2）方便访问变量时

（2）static修饰方法（静态方法）

static修饰的方法，叫静态方法，可通过类名直接访问，为本类所有对象共享；
静态方法不能访问本类的非静态成员（包括实例变量和方法，因为非静态则和特定的对象关联，就不能全类共享了），但是非静态方法可以访问静态成员（ofcourse，静态成员全类共享）；
静态方法中不能出现this和super关键字（因为this是指向当前对象，super.成员名调用父类成员）；
因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract；
子类覆盖父类的静态方法时，只能依然覆盖为静态方法（一日static终生static），但是没有多态。

Java中main方法必须为static的原因：

在类加载时无法创建对象，而静态方法可以不通过对象调用，所以在类加载时可以通过main方法入口运行程序。

（3）static修饰代码块（初始化块、静态代码块）

格式： static{...}

static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

初始化总结（静态变量->实例变量->按声明初始化->执行构造方法）

1）首次使用某个类时，JVM查找相应的类文件并加载（Java只有在必要时才会逐步载入相应的类文件）

首先为所有的静态变量分配存储空间并初始化为默认值（全局变量），然后按照声明静态变量时指定的初始化动作的顺序，以及静态初始化块中的语句在类定义中出现的顺序依次执行。这些静态的初始化动作只会在其所属类的类文件加载时执行一次。

2）类文件加载完毕后，如果需要创建类的对象，则进行如下初始化动作

JVM为所有的实例变量分配足够的存储空间并初始化为默认值（局部变量）；然后按声明实例变量时指定初值的初始化动作和实例初始化块中的语句在类中出现的顺序依次执行，之后再调用相应的构造方法。

4. abstract和 interface对比

abstract class和interface是支持抽象类定义的两种机制。正是由于这两种机制的存在，才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性，区别：

抽象类（Abstract Class）：

（1）只能作为其他类的基类，不能被实例化（new）；

（2）抽象类中的成员是不是abstract无所谓，并不是必须的。（可以有抽象成员，也可以没有任何抽象成员）

（3）抽象类不能同时是final的。抽象的总是希望被继承，而final类不可被继承。final和abstract不可同时存在。

（4）非抽象类继承抽象类，必须覆盖其所有的抽象成员。抽象类继承抽象类，可以不覆盖所有的抽象成员。

（5）抽象类允许被声明

接口（interface）：

接口的本质是一种特殊的抽象类，用来描述系统对外提供的所有服务。

（1）接口中，所有方法都是公开、抽象的：public abstract。（都必须被继承）

（2）接口中，所有属性都是公开、静态、常量：public static final，且必须赋初值。（所有实现类共享且不可改变）

接口总是希望被实现被访问的，因此所有成员都必须是公开的（public），确保外界可以访问。接口仅仅描述系统可以做什么，但不指明如何去做，具体操作由实现类完成，因此方法都是abstract的，都必须被继承；接口不涉及任何的实现细节，因此无构造方法，接口不能被实例化；无变量，只有静态常量（static final），因为要被所有的实现类共享；类的继承只能单继承，但是接口可以一次实现多个，用“,”隔开。

5. super和 this对比

super：

super可以理解为是指向自己父类对象的一个指针，指的是离自己最近的一个父类。

用法：

super.成员名（变量名或者方法名）：显式调用父类的同名成员，当然成员不能是private的（不允许子类访问）。因为当子类和父类存在同名成员时，因为子类成员优先级更高，此时会隐藏父类的相应成员。
super（参数列表）;：调用父类的构造函数，注意super语句一定要放在函数体的第一条：

this：

this可以理解为指向当前对象自身的一个指针，即当前正在执行本方法的那个对象实例。位于函数体内部。

用法：

this.成员名：引用成员变量。因为函数参数或者函数中的局部变量和成员变量同名的话，成员变量被屏蔽，此时要访问成员变量则需要使用“this.成员变量”的方式引用。
this（参数列表）;：调用本类中参数表一致的另一个构造函数，注意应作为构造函数中的第一条语句。

引用构造函数时：

super（参数）：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。this（参数）：调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）。

this和super都无需声明。

6. synchronize和 volatile对比

（1）作用范围：volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别；

（2）volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取；synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。

（3）volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。

（4）volatile只能在线程内存和主内存之间同步一个变量的值，而synchronized则同步在线程内存和主内存之间的所有变量的值，通过锁住和释放监听器来实现。

（5）volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化

（6）显然，synchronized在性能上将比volatile更加有所消耗

（7）volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性

7. String、StringBuffer、StringBuilder对比

（1）可变与不可变

　　String类中使用字符数组保存字符串，如下就是，因为有“final”修饰符，所以可以知道string对象是不可变的。

　　　　private final char value[];

　　StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，如下就是，可知这两种对象都是可变的。

　　　　char[] value;

（2）是否多线程安全

　　String中的对象是不可变的，也就可以理解为常量，显然线程安全。

　　AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。

　　StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。看如下源码：

public synchronized StringBuffer reverse() {

    super.reverse();

    return this;

}

public int indexOf(String str) {

    //存在 public synchronized int indexOf(String str, int fromIndex) 方法

    return indexOf(str, 0);       

}

　　StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。

（3）StringBuilder与StringBuffer共同点

　　StringBuilder与StringBuffer有公共父类AbstractStringBuilder(抽象类)。

　　抽象类与接口的其中一个区别是：抽象类中可以定义一些子类的公共方法，子类只需要增加新的功能，不需要重复写已经存在的方法；而接口中只是对方法的申明和常量的定义。

　　StringBuilder、StringBuffer的方法都会调用AbstractStringBuilder中的公共方法，如super.append(...)。只是StringBuffer会在方法上加synchronized关键字，进行同步。

　　最后，如果程序不是多线程的，那么使用StringBuilder效率高于StringBuffer。

关于String、StringBuffer、StringBuilder

Java中String、StringBuffer、StringBuilder区别与理解

一、先比较String、StringBuffer、StringBuilder变量的HashCode值

使用System.out.println(obj.hashcode())输出的时对象的哈希码，
而非内存地址。在Java中是不可能得到对象真正的内存地址的，因为Java中堆是由JVM管理的不能直接操作。
只能说此时打印出的Hash码表示了该对象在JAVA虚拟机中的内存位置，
Java虚拟机会根据该hash码最终在真正的的堆空间中给该对象分配一个地址.
但是该地址是不能通过java提供的api获取的

String变量连接新字符串会改变hashCode值，变量是在JVM中“连接——断开”；
StringBuffer变量连接新字符串不会改变hashCode值，因为变量的堆地址不变。
StringBuilder变量连接新字符串不会改变hashCode值，因为变量的堆地址不变。

小结：哈希码相同的变量，其内容不一定相同；内容向同变量，哈希码不一定相同；

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

        String str1="学海无涯苦作舟";
        System.out.println("String 的 str1的hascode"+str1.hashCode());
        str1=str1+"人间正道是沧桑";      //注意此str1的存储地址已发生变化
        System.out.println("String 的 str1的hascode"+str1.hashCode());
        System.out.println(str1);
        StringBuffer sb1=new StringBuffer("弟子规");
        System.out.println("原来StringBuffer 的 hascode:"+sb1.hashCode());
        StringBuffer sb2=sb1.append("圣人教");    //注意sb1和sb2指向同一个地址
        System.out.println("添加字符串后StringBuffer 的 hascode:"+sb2.hashCode());
        sb2.insert(6,"海纳百川");
        StringBuilder sb=new StringBuilder("这显然是上半年");
        System.out.println("改变前StringBuilder变量的hashCode值"+sb.hashCode());
        sb.append("哦是的啊");
        System.out.println("改变后StringBuilder变量的hashCode值"+sb.hashCode());
    }
}

    结果：
        String 的 str1的hascode-2054942391
        String 的 str1的hascode895667206
        学海无涯苦作舟人间正道是沧桑
        原来 StringBuffer 的 hascode:1311053135
        添加字符串后StringBuffer 的 hascode:1311053135
        改变前StringBuilder变量的hashCode值118352462
        改变后StringBuilder变量的hashCode值118352462

二、比较String、StringBuffer、StringBuilder性能（仅在繁复操作）

String类由于Java中的共享设计，在修改变量值时使其反复改变栈中的对于堆的引用地址，所以性能低。

StringBuffer和StringBuilder类设计时改变其值，其堆内存的地址不变，避免了反复修改栈引用的地址，其性能高。

其中StringBuilder是专门类似于StringBuffer类的非线性安全类，即StringBuffer是线性安全的，适合于多线程操作；

StringBuilder是线性不安全的，适合于单线程操作，其性能比StringBuffer略高。

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

        long begin1 = System.currentTimeMillis();
        String str = "";
        for(int i=0;i<10000;i++){
            str = str+i;
        }

        long end1 = System.currentTimeMillis();
        long time1 = end1 - begin1;
        System.out.println("1、String + time="+time1);   

        long begin2 = System.currentTimeMillis();
        String str2 = "";
        for(int i=0;i<10000;i++){
            str2 = str2.concat(i+"");
        }

        long end2 = System.currentTimeMillis();
        long time2 = end2 - begin2;
        System.out.println("2、String concat time="+time2); 

        long begin3 = System.currentTimeMillis();
        StringBuffer str3 = new StringBuffer();
        for(int i=0;i<10000;i++){
            str3.append(""+i);
        }

        long end3 = System.currentTimeMillis();
        long time3 = end3 - begin3;
        System.out.println("3、StringBuffer time="+time3);  

        long begin4 = System.currentTimeMillis();
        StringBuilder str4 = new StringBuilder();
        for(int i=0;i<10000;i++){
            str4.append(""+i);
        }

        long end4 = System.currentTimeMillis();
        long time4 = end4 - begin4;
        System.out.println("4、StringBuilder time="+time4);
    }
}

    结果：
        1、String + time=241
        2、String concat time=92
        3、StringBuffer time=4
        4、StringBuilder time=2

三、String共享设计

当String使用引号创建字符串时，会先去字符串池中找，找到了就返回，找不到就在字符串池中增加一个然后返回，这样由于共享提高了性能。

而new String()无论内容是否已经存在，都会开辟新的堆空间，栈中的堆内存也会改变。

下面是==来比较地址是否相等。

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

        String str1="学海无涯苦作舟人间正道是沧桑";
        String str11=str1;
        String str12="学海无涯苦作舟人间正道是沧桑";
        String str13=new String("学海无涯苦作舟人间正道是沧桑");

        System.out.println("String 的 str1 的hascode"+str1.hashCode());
        System.out.println("String 的 str11的hascode"+str11.hashCode());
        System.out.println("String 的 str12的hascode"+str12.hashCode());
        System.out.println("String 的 str13的hascode"+str13.hashCode());
        System.out.println("str1==str11  "+(str1==str11));
        System.out.println("str1==str12  "+(str1==str12));
        System.out.println("str1==str13  "+(str1==str13));
    }
}

    结果：
        String 的 str1 的hascode895667206
        String 的 str11的hascode895667206
        String 的 str12的hascode895667206
        String 的 str13的hascode895667206
        str1==str11 true
        str1==str12 true
        str1==str13 false

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。