JAVA关键字

关键字

修饰符

abstract

抽象类修饰符。

抽象函数——表达概念而无法实现具体代码的函数。
抽象类——表达概念而无法构造出实体的类，且不能生成对象，通常被继承。

1.abstract的特点
(1).用abstract关键字修饰的函数是抽象函数。
(2).类内含有抽象函数的类叫做抽象类，类需要用abstract修饰。
(3).抽象类不能被实例化，所以无法对抽象类进行new。
(4).继承自抽象类的子类必须覆盖实现父类中的抽象函数。
(5).抽象类可以有构造函数，当被继承的时候，子类会用super()调用父类的构造函数。

2.抽象类的使用场景
(1).不可以直接使用抽象类进行实例化，只可以对所用抽象类的子类进行方法重写，通过调用子类重写的方法进行使用。
(2).abstract不可以和final一同使用：被final修饰后的类不能出现子类，而abstract的类需要子类来重写方法（不然毫无意义）。
(3).abstract不和可以和private一同使用: 当用private修饰抽象函数的时候，子类继承会无法重写父类的抽象方法（private不被子类继承）。

class

标准类修饰符。

final

修饰变量（成员变量和局部变量）、方法、类。

（1）修饰变量
用final关键字修饰的变量，只能进行一次赋值操作，并且在生存期内不可以改变它的值。final修饰的变量可以先声明，后赋值。final修饰基本类型时，起到常量的作用，基本类型的值不可变。final修饰引用类型时，不能再指向其他的对象，但被引用的对象的值是可以改变的（引用变量的值，实际上是它所引用的对象的地址）。当用final作用于类的成员变量时，成员变量（局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值。
（2）修饰方法参数
编写方法时，可以在参数前面添加final关键字，它表示在整个方法中，不会（实际上是不能）改变参数的值，具体类似于修饰数据。即不能改变参数的值，但是可以改变引用类型参数的对象的值。同时，即使没有final的修饰，参数的改变也不会影响到方法外的变量。
（3）修饰方法
final关键字修饰方法，它表示该方法不能被覆盖（重写）。另外，类中所有的private方法都隐式地指定为是final的，由于无法在类外使用private方法，所以也就无法覆盖它。此时可以在子类中定义相同的方法名和参数，这种情况不再产生重写与final的矛盾，而是在子类中重新定义了新的方法。可以对private方法添加final修饰符，但并没有添加任何额外意义。
（4）修饰类
用final修饰的类是无法被继承的。且final类中的所有成员方法都会被隐式地指定为final方法。

final关键字的好处：
（1）final关键字提高了性能。JVM和Java应用都会缓存final变量。
（2）final变量可以安全的在多线程环境下进行共享，而不需要额外的同步开销。
（3）使用final关键字，JVM会对方法、变量及类进行优化。
（4）final和abstract这两个关键字是反相关的，final类就不可能是abstract的。
（5）在匿名类中所有变量都必须是final变量。

static

修饰变量、方法、代码块。

被static修饰的成员变量和成员方法独立于该类的任何对象，即它不依赖于类的实例，被类的所有实例共享。
只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内找到他们。因此，static对象可以
在它的任何对象之前访问，无需应用任何对象。

1. 在static方法内部不能调用非静态方法，反过来是可以的。
2. static目的是，方便在没有创建对象的情况下来进行调用（方法/变量）。被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。
3. 对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。
4. 在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。
5. 在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。
6. 静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够）。
7. 静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一份儿，它当且仅当在类初次加载时会被初始化，由JVM对它初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多份儿，各个对象拥有的份儿互不影响。
8. static代码块，用来优化程序的性能。当类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次（只会在类加载的时候执行一次）。
9. 在Java中切记：static是不允许用来修饰局部变量。

// static作用于成员变量用来表示只保存一份副本，而final的作用是用来保证变量不可变。
public class Test {
    public static void main(String[] args) {
        MyClass myClass1 = new MyClass();
        MyClass myClass2 = new MyClass();
        System.out.println(myClass1.i);
        System.out.println(myClass1.j);
        System.out.println(myClass2.i);
        System.out.println(myClass2.j);
    }
}

class MyClass {
    public final double i = Math.random();
    public static double j = Math.random();
}
// 运行这段代码就会发现，每次打印的两个j值都是一样的，而i的值却是不同的。从这里就可以知道final和static变量的区别了。

public class B {
	static {
		System.out.print("Sb");
	}
	{
		System.out.print("-B");
	}
	public B() {
		System.out.print("~Cb");
	}
}

public class A extends B {
	static {
		System.out.print("Sa");
	}
	{
		System.out.print("-A");
	}
	public A() {
		System.out.print("~Ca");
	}
}

	public static void main(String[] args) {
		System.out.println("===mian===");
		new A();
		System.out.println();
		new B();
		System.out.println();
		new A();
	}

/*
===mian===
SbSa-B~Cb-A~Ca
-B~Cb
-B~Cb-A~Ca
*/

//执行顺序：1.静态代码块 --> 2.普通代码块 --> 3.构造方法
//1是类级别的，2和3是实例级别的，所以在父子类关系中，执行顺序为：
//父类静态代码块-->子类静态代码块-->父类普通代码块-->父类构造方法-->子类代码块-->子类构造方法；

public class TestClass {
	private static void testMethod(){
		System.out.println("testMethod");
	}
    
	public static void main(String[] args) {
		((TestClass)null).testMethod();//运行正常，输出testMethod
	}
}
// 静态变量/方法是属于类，在对象实例创建前就已经存在了，使用不依赖于对象是否被创建。

final、static、static final修饰的字段赋值的区别
（1）static修饰的字段在类加载过程中的准备阶段被初始化为0或null等默认值，而后在初始化阶段（触发类构造器）才会被赋予代码中设定的值，如果没有设定值，那么它的值就为默认值。
（2）final修饰的字段在运行时被初始化（可以直接赋值，也可以在实例构造器中赋值），一旦赋值便不可更改；
（3）static final修饰的字段在Javac时生成ConstantValue属性，在类加载的准备阶段根据ConstantValue的值为该字段赋值，它没有默认值，必须显式地赋值，否则Javac时会报错。 可以理解为在编译期即把结果放入了常量池中。

private

修饰仅限于类的内部访问变量的修饰符。

protected

修饰可以用于子类的访问变量的修饰符。

public

修饰最大访问权限的访问变量的修饰符。

数据类型

boolean

布尔型。

byte

字节类型。

char

字符型。

double

双精度浮点型。

float

单精度浮点型。

int

整型。

long

长整型。

short

短整型。

void

空类型，通常用于方法返回。

语句组成

if

条件选择修饰符。

else

条件选择修饰符。

for

循环修饰符。

do

循环修饰符。

while

循环处理修饰符。

switch

条件选择修饰符。

case

条件选择修饰符。

break

中断循环修饰符。

continue

循环跳过修饰符。

try

异常处理修饰符。

catch

异常处理修饰符。

finally

异常处理修饰符.finally作为异常处理的一部分,不管是否异常最后都要处理这部分内容。

public static int func() {
	try {
        return 1;
    } catch(Exception e) {
        return 2;
    } finally {
        return 3;// 返回3
    }
}
// （1）try catch中只要有finally语句都要执行。
// （2）finally语句在try或catch中的return语句执行之后返回之前执行，且finally里的修改语句不能影响try或catch中 return已经确定的返回值，若finally里也有return语句则覆盖try或catch中的return语句直接返回。
// （3）在遵守第（2）条return的情况下，执行顺序是：try-->catch（如果有异常的话）-->finally。

throw

语句异常抛出修饰符。

throws

方法异常抛出修饰符。

super

父类指针修饰符。

default

条件选择默认条件修饰符。

extends

扩展子类修饰符。

implements

加载接口类修饰符。

package

命名空间修饰符。

import

引用类修饰符。

instanceof

支出判断对象是否是特定类修饰符。

interface

接口类定义修饰符。

new

新建类修饰符。

return

返回修饰符。

sychronized

同步块修饰符。

this

本类指针修饰符。

特殊含义关键字

assert

断言，用于调试，多被junit代替，IDE默认不开启。

const

预留关键字。

goto

预留关键字。

enum

枚举。

native

本地方法。

strictfp

精确浮点，可用于类、接口、方法。

transient

免除变量序列化。

volatile

被设计用来修饰被不同线程访问和修改的变量。

非java关键字

true

布尔值真。

false

布尔值假。

null

空值修饰符。

serilizable

序列化修饰符。