JAVA关键字自测

1，final,finally,finalize。

final用于修饰类、成员变量和成员方法。

final修饰的类，不能被继承（String、StringBuilder、StringBuffer、Math，不可变类），其中全部的方法都不能被重写，因此不能同时用abstract和final修饰类（abstract修饰的类是抽象类，抽象类是用于被子类继承的，和final起相反的做用）；

Final修饰的方法不能被重写，可是子类能够用父类中final修饰的方法；

Final修饰的成员变量是不可变的，若是成员变量是基本数据类型，初始化以后成员变量的值不能被改变，若是成员变量是引用类型，那么它只能指向初始化时指向的那个对象，不能再指向别的对象，可是对象当中的内容是容许改变的。使用final关键字修饰一个变量时，是引用不能变，不是引用的对象不能变

finally和try catch 搭配使用，用于处理异常。throws, throw, try, catch, finally分别表明什么意义？

try块表示程序正常的业务执行代码。若是程序在执行try块的代码时出现了“非预期”状况，JVM将会生成一个异常对象，这个异常对象将会被后面相应的catch块捕获。

catch块表示一个异常捕获块。当程序执行try块引起异常时，这个异常对象将会被后面相应的catch块捕获。

throw用于手动地抛出异常对象。throw后面须要一个异常对象。

throws用于在方法签名中声明抛出一个或多个异常类，throws关键字后能够紧跟一个或多个异常类。

finally块表明异常处理流程中总会执行的代码块。

对于一个完整的异常处理流程而言，try块是必须的，try块后能够紧跟一个或多个catch块，最后还能够带一个finally块。try块中能够抛出异常。

finalize是object类中的一个方法，子类能够重写finalize()方法实现对资源的回收。

finalize在什么状况下被调用？有三种状况1.全部对象被Garbage Collection时自动调用,好比运行System.gc()的时候.2.程序退出时为每一个对象调用一次finalize方法。3.显式的调用finalize方法
除此之外,正常状况下,当某个对象被系统收集为无用信息的时候,finalize()将被自动调用,可是jvm不保证finalize()必定被调用,也就是说,finalize()的调用是不肯定的,这也就是为何sun不提倡使用finalize()的缘由。

构造函数的一个重要做用是为对象申请资源，相应地，析构函数要负责释放这些资源。GC原本就是内存回收了，应用还须要在finalization作什么呢？ 答案是大部分时候，什么都不用作(也就是不须要重载)。只有在某些很特殊的状况下，好比你调用了一些native的方法(通常是C写的)，能够要在finaliztion里去调用C的释放函数。

2，static,静态修饰符，

static方法的做用：“static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是能够的。并且能够在没有建立任何对象的前提下，仅仅经过类自己来调用static方法。这实际上正是static方法的主要用途。简而言之，在没有建立对象的状况下能够调用方法和变量。

static方法通常称做静态方法，因为静态方法不依赖于任何对象就能够进行访问，所以对于静态方法来讲，是没有this的，由于它不依附于任何对象，既然都没有对象，就谈不上this了。而且因为这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，由于非静态成员方法/变量都是必须依赖具体的对象才可以被调用。可是要注意的是，虽然在静态方法中不能访问非静态成员方法和非静态成员变量，可是在非静态成员方法中是能够访问静态成员方法/变量的。

咱们最多见的static方法就是main方法，至于为何main方法必须是static的，如今就很清楚了。由于程序在执行main方法的时候没有建立任何对象，所以只有经过类名来访问。另外记住，即便没有显示地声明为static，类的构造器实际上也是静态方法。

static变量也称做静态变量，静态变量和非静态变量的区别是：静态变量被全部的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在建立对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。static成员变量的初始化顺序按照定义的顺序进行初始化。

static关键字还有一个比较关键的做用就是 用来造成静态代码块以优化程序性能。static块能够置于类中的任何地方，类中能够有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每一个static块，而且只会执行一次。为何说static块能够用来优化程序性能，是由于它的特性:只会在类加载的时候执行一次。

与C/C++中的static不一样，Java中的static关键字不会影响到变量或者方法的做用域。在Java中可以影响到访问权限的只有private、public、protected（包括包访问权限）这几个关键字

静态成员变量虽然独立于对象，可是不表明不能够经过对象去访问，全部的静态方法和静态变量均可以经过对象访问（只要访问权限足够）

在C/C++中static是能够做用域局部变量的，可是在Java中切记：static是不容许用来修饰局部变量。不要问为何，这是Java语法的规定。

带有static代码块的继承关系类的代码的执行顺序，main方法入口，先执行父类的静态代码块，后执行子类静态代码块，最后执行子类的普通方法

具体参考http://www.cnblogs.com/dolphin0520/p/3799052.html

静态类和非静态类的区别，static修饰，可否直接使用类名进行调用

Java中是否能够覆盖(override)一个private或者是static的方法？

若是在父类中修饰了一个private的方法，子类继承以后，对子类也是不可见的。那么若是子类声明了一个跟父类中定义为private同样的方法，那么编译器只看成是你子类本身新增的方法，并不能算是继承过来的。

Static表示静态的意思，可用于修饰成员变量和成员函数，被静态修饰的成员函数只能访问静态成员，不能够访问非静态成员。静态是随着类的加载而加载的，所以能够直接用类进行访问。

重写是子类中的方法和子类继承的父类中的方法同样（函数名，参数，参数类型，反回值类型），可是子类中的访问权限要不低于父类中的访问权限。重写的前提是必需要继承，private修饰不支持继承，所以被私有的方法不能够被重写。

静态方法形式上能够被重写，即子类中能够重写父类中静态的方法。可是实际上从内存的角度上静态方法不能够被重写。

main() 方法为何必须是静态的？能不能声明 main() 方法为非静态？

由于程序在执行main方法的时候没有建立任何对象，所以只有经过类名来访问，不能

是否能够从一个静态（static）方法内部发出对非静态（non-static）方法的调用？

不能，

静态变量和静态代码块何时加载？

当类加载器将类加载到JVM中的时候就会建立静态变量，这跟对象是否建立无关。静态变量加载的时候就会分配内存空间

静态代码块的代码只会在类第一次初始化的时候执行一次。

三、java修饰符：public、protected、default、private

修饰范围从对象类，包，子包，其余包逐渐减小

四、volatile是Java提供的一种轻量级的同步机制，在并发编程中，它也扮演着比较重要的角色。同synchronized相比（synchronized一般称为重量级锁），volatile更轻量级，相比使用synchronized所带来的庞大开销。

所谓可见性，是指当一条线程修改了共享变量的值，新值对于其余线程来讲是能够当即得知的。

volatile并不能彻底替代synchronized，它依然是个轻量级锁，在不少场景下，volatile并不能胜任

num++不是个原子性的操做，而是个复合操做

禁止指令重排序优化

volatile有什么实践应用？一种实践是用 volatile 修饰 long 和 double 变量，使其能按原子类型来读写。double 和 long 都是64位宽，所以对这两种类型的读是分为两部分的，第一次读取第一个 32 位，而后再读剩下的 32 位，这个过程不是原子的，但 Java 中 volatile 型的 long 或 double 变量的读写是原子的。

volatile 修复符的另外一个做用是提供内存屏障（memory barrier），例如在分布式框架中的应用。简单的说，就是当你写一个 volatile 变量以前，Java 内存模型会插入一个写屏障（write barrier），读一个 volatile 变量以前，会插入一个读屏障（read barrier）。意思就是说，在你写一个 volatile 域时，能保证任何线程都能看到你写的值，同时，在写以前，也能保证任何数值的更新对全部线程是可见的，由于内存屏障会将其余全部写的值更新到缓存

volatile 变量是什么？volatile 变量和 atomic 变量有什么不一样

volatile 变量和 atomic 变量看起来很像，但功能却不同。Volatile变量能够确保先行关系，即写操做会发生在后续的读操做以前, 但它并不能保证原子性。例如用volatile修饰count变量那么 count++ 操做就不是原子性的。而AtomicInteger类提供的atomic方法可让这种操做具备原子性如getAndIncrement()方法会原子性的进行增量操做把当前值加一，其它数据类型和引用变量也能够进行类似操做。

volatile 类型变量能使得一个非原子操做变成原子操做吗

一个典型的例子是在类中有一个 long 类型的成员变量。若是你知道该成员变量会被多个线程访问，如计数器、价格等，你最好是将其设置为 volatile。为何？由于 Java 中读取 long 类型变量不是原子的，须要分红两步，若是一个线程正在修改该 long 变量的值，另外一个线程可能只能看到该值的一半（前 32 位）。可是对一个 volatile 型的 long 或 double 变量的读写是原子。

能建立 volatile 数组吗？

能，Java 中能够建立 volatile 类型数组，不过只是一个指向数组的引用，而不是整个数组。个人意思是，若是改变引用指向的数组，将会受到 volatile 的保护，可是若是多个线程同时改变数组的元素，volatile 标示符就不能起到以前的保护做用了。

volatile修饰的变量若是是对象或数组之类的，其含义是对象获数组的地址具备可见性，可是数组或对象内部的成员改变不具有可见性：

五、transient变量有什么特色

https://www.cnblogs.com/lanxuezaipiao/p/3369962.html

什么是序列化？

序列化 (Serialization)将对象的状态信息转换为能够存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。之后，能够经过从存储区中读取或反序列化对象的状态，从新建立该对象

为何要实现序列化？

序列化是为了解决在对对象流进行读写操做时所引起的问题。序列化以后，就能够把序列化后的内容写入磁盘，或者经过网络传输到别的机器上。反过来，把变量内容从序列化的对象从新读到内存里称之为反序列化

如何实现序列化?

将须要被序列化的类实现Serializable接口，该接口没有须要实现的方法，implements Serializable只是为了标注该对象是可被序列化的。而后使用一个输出流(如：FileOutputStream)来构造一个 ObjectOutputStream(对象流)对象。接着，使用ObjectOutputStream对象的writeObject(Object obj)方法,就能够将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

何时实现类的序列化

能够在程序再次运行时读取这些对象的值，或者在其余程序中利用这些保存下来的对象。这种状况下就要用到对象的序列化。 对象序列化的最主要的用处就是在传递,和保存对象(object)的时候,保证对象的完整性和可传递性。 譬如经过网络传输,或者把一个对象保存成一个文件的时候,要实现序列化接口 。

      咱们都知道一个对象只要实现了Serilizable接口，这个对象就能够被序列化，java的这种序列化模式为开发者提供了不少便利，咱们能够没必要关系具体序列化的过程，只要这个类实现了Serilizable接口，这个类的全部属性和方法都会自动序列化。

      然而在实际开发过程当中，咱们经常会遇到这样的问题，这个类的有些属性须要序列化，而其余属性不须要被序列化，打个比方，若是一个用户有一些敏感信息（如密码，银行卡号等），为了安全起见，不但愿在网络操做（主要涉及到序列化操做，本地序列化缓存也适用）中被传输，这些信息对应的变量就能够加上transient关键字。换句话说，这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。

      总之，java 的transient关键字为咱们提供了便利，你只须要实现Serilizable接口，将不须要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

六、this和super关键字

super主要存在于子类方法中，用于指向子类对象中父类对象，用于访问父类的构造函数，方法，变量。

this和super很像，this指向的是当前对象的调用，super指向的是当前调用对象的父类。类加载完毕，建立对象，父类的构造方法会被调用（默认自动无参），而后执行子类相应构造建立了一个子类对象，该子类对象还包含了一个父类对象。该父类对象在子类对象内部。this super只能在有对象的前提下使用，不能在静态上下文使用

super的使用：super();第一行隐式语句

super(y)；调用父类构造函数；

Java关键字this只能用于方法方法体内。当一个对象建立后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是this。所以，this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this

 第1、经过this调用另外一个构造方法，用发是this(参数列表)，这个仅仅在类的构造方法中，别的地方不能这么用。
 第2、函数参数或者函数中的局部变量和成员变量同名的状况下，成员变量被屏蔽，此时要访问成员变量则须要用“this.成员变量名”的方式来引用成员变量。固然，在没有同名的状况下，能够直接用成员变量的名字，而不用this，用了也不为错，呵呵。
 第3、在函数中，须要引用该函所属类的当前对象时候，直接用this。

七、public static void 写成 static public void会怎样？

main函数写成这样能出结果和原来同样

八、说明一下public static void main(String args[])这段声明里每一个关键字的做用

 public关键字声明主函数为public就是告诉其余的类能够访问这个函数。

static关键字，告知编译器main函数是一个静态函数。也就是说main函数中的代码是存储在静态存储区的，即当定义了类之后这段代码就已经存在了。若是main()方法没有使用static修饰符，那么编译不会出错，可是若是你试图执行该程序将会报错，提示main()方法不存在。由于包含main()的类并无实例化（即没有这个类的对象），因此其main()方法也不会存。而使用static修饰符则表示该方法是静态的，不须要实例化便可使用。

void关键字代表main()的返回值是无类型。

String是命令行传进参数的类型，args是指命令行传进的字符串数组。

九、sizeof 是Java 的关键字吗？

不是，Java是一种纯面向对象的编程语言，它将内存管理的细节都交给Java Virtual Machine（JVM）进行。同时Java是一种跨平台的语言，可移植性好，它在数据类型在机器中的大小都相同。而在C/C++中须要sizeof是由于移植，不一样的数据类型在不一样的机器上大小可能不一样，程序员必须知道对应的数据类型大小。

十、switch

switch后面的表达式类型，支持枚举类型，java 1.6(包括)之前，只是支持等价成int 基本类型的数据:byte ,short,char,int(其余的都不能够）。1.7加入的新特性能够支持String类型的数据。long是不能够的。就算是经过强制的转化也必须是转成int。