Java中所有的关键字及用法

大家好，又见面了，我是你们的朋友全栈君。

基本数据类型：

int：

int 基本数据类型，内存空间占8位取值范围-128～127 int i=10;

float

float 基本数据类型，内存空间占32位取值范围 -2^31～-2^31-1 float f=10.0f;

long

long 基本数据类型内存空间占 64位取值范围 -2^63～-2^63-1 long l=10l;

short

short 基本数据类型内存空间占16位取值范围 -2^15～-2^15-1 short s=10;

byte

byte 基本数据类型内存空间占8位取值范围 -2^7～-2^7-1 byte b=10;

char

char 基本数据类型内存空间占16位取值范围 0～-2^16-1 char c=’c’;

double

double 基本数据类型内存空间占32位取值范围 -2^63～-2^63-1 double d=10.0d;

boolean

boolean 基本数据类型内存空间占8位取值范围 true～false boolean b=true;

权限修饰符：

public

Java语言修饰符，翻译为公共的。被public修饰的类，属性和方法不仅可以跨类使用，还可以跨包使用。

private

Java语言修饰符，翻译为私有的。是java语言中，访问权限最窄的修饰符。被private修饰的属性和方法，只能由本类使用，其子类不可以访问，更不可以跨包访问。

default

Java语言权限修饰符，在java语句中，通常称为默认修饰符，只允许同包的中的类进行访问。

protected

Java语言权限修饰符，在java语句中，介于public和private之间的修饰符，起到保护的作用，即使不是同包的子类也可以访问，被protected修饰的类，方法，属性只能被本身的方法和子类访问。

条件判断语句：

if else

if用于条件判断，一般配合 elseif else使用

public void test(){

int a=10;
int b=5;

if(a>b){
sout（"a大于b");
}
elseif（b>a）{
sout（"b大于a"）;
}
else{
sout（"a和b相等"）;
}



}

switch一般和case和break一起联合使用

String name="lixiaobin"；
switch（name）{

case "lixiaobin"：
sout（"lixiaobin"）；
break；

case "lixiaobin"：
sout（"zhangsan"）；
break；

case "lixiaobin"：
sout（"lisi"）；
break；
default:
sout("无效")
}

在switch中，查找name相同的值，如果不管找不找得到都break，跳出。

1、switch分支语句中的表达式可以为byte,short,int,char型，常量值也是byte,short,int,char型，且常量值必须不同。注意：表达式的值不可以是long型数据，否则会导致编译错误。

2、switch语句中，如果表达式的值和case后面的常量值相同，则执行其后语句，直到遇到break语句或执行至switch完结为止。如果表达式的值和case后面的常量值都不相同，则直接执行default后语句，若无default，switch不会有任何处理。

循环语句

while

while一般和else 和continue break一起用

public void test（）{

int i=1；
whlie（true）

sout（“学习java”）；
i++;
if（i=5）
{

break;  
//i=5的时候跳出循环
}
}

continue

continue为跳出本次循环

public class Main {
    public static void main(String[] args) {
        int n=5,j=12;
        while(n<=j){
            System.out.print(n+"\t");
            n++;
            continue;
        }
        System.out.println("n="+n);
    }
}

do while

语法结构：

do{
循环结构

}while(判断条件);

先执行do循环结构里面的代码，然后判断

while里面的条件是否符合，直到不成立为止，

所以do……while至少会被执行一次。

for 语句

public void test（）{

int[] integers = {1， 2， 3， 4};
for (int j = 0; j<integers.length; j++){

int i = integers[j];

System.out.println(i);

}

}

for语句有一个加强foreach语句

public void test（）{

int[]numbers={1，2，3，4，5，6，7}

for（int num：numbers）{

    sout（num）
} 
}

abstract

abstract解释为抽象的，可以用来修饰的结构：类、方法。

Person p1=new Person();//一旦Person类抽象了就不可以实例化了。

abstract class Person{
    
}

abstract修饰类：抽象类

此类不能实例化
抽象类中一定有构造器。便于子类实例化时调用、
开发中，都会提供抽象类的子类，让子类对象实例化。完成相关的操作。

abstract修饰方法：抽象方法。

抽象方法只有方法的声明，没有方法体。
包含抽象方法的类，一定是抽象类。反之，类如果是抽象类，不一定有抽象方法。
若子类重写了父类中的所有的抽象方法后，此子类方可实例化。
若子类没有重写父类中所有的抽象方法，则此子类也是个抽象类。需要用abstract修饰一下。

static

static被解释为静态方法，静态方法不需要依赖任何对象就可以访问，所有，对于静态方法来说，是没有this的，但是要注意的是，虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。

    public class MyObject {
    	//非静态变量
    	private String str1 ="property";
    	//静态变量
    	private static String str2 ="staticProperty";
    	
    	public MyObject() {
    		
    	}
    	//非静态方法
    	public void print1() {
    		System.out.println(str1);
    		System.out.println(str2);
    		print2();
    	}
    	
    	//静态方法
    	public static  void print2() {
    		//这一句报错，报错信息是Cannot make a static reference to the non-static field str1
    		System.out.println(str1);
    		System.out.println(str2);
    		/*
    		 * 调用非静态的方法会报错，
    		 * Cannot make a static reference to the non-static method print1() from the type MyObject
    		 */
    		print1();
    	}
    }

final

1.当用final修饰一个类的时候，这个类不能被继承，如果你想让一个类永远不被继承，那么就可以用final修饰。final类中的成员变量需要根据需要设为final，但是要注意，final类中的所有成员方法都会被隐式的指定为final方法。

finally

是在异常处理时提供finally块来执行任何清除操作。不管有没有异常被抛出、捕获，finally块都会被执行。try块中的内容是在无异常时执行到结束。catch块中的内容，是在try块内容发生catch所声明的异常时，跳转到catch块中执行。finally块则是无论异常是否发生，都会执行finally块的内容，所以在代码逻辑中有需要无论发生什么都必须执行的代码，就可以放在finally块中。

finalize

finalize是方法名。java技术允许使用finalize（）方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在object类中定义的，因此所有的类都继承了它。子类覆盖finalize（）方法以整理系统资源或者被执行其他清理工作。finalize（）方法是在垃圾收集器删除对象之前对这个对象调用的。

extends

在java中，extends是继承。 a extends b。此处a为子类，b为父类。

在java中，一个子类只可以有一个父类，但是一个父类可以有多个子类。

super

1.子类重写父类的方法。

public class A {
	
	private String nameA="A";
	
	public void getName() {
		System.out.println("父类"+nameA);
	}
	public static void main(String[] args) {
	}
	
}
 
 
public class B extends A{
	private String nameB="B";
	
	@Override
	public void getName() {
		System.out.println("子类"+nameB);
		super.getName();
	}
	
	public static void main(String[] args) {
		B b=new B();
		b.getName();
	
	}
}

输出结果：

子类B

父类A

在子类B中，我们重写了父类的getName（）方法，如果在重新的getName方法中我们去调用父类的相同方法，必须要通过super关键字显示的指明出来。

如果不表明出来，按照子类的优先原则，相当于还是在调用重写的getName方法，就形成了死循环。

2.子类重新父类的变量。

public class A {
	
	 String nameA="A";
 
}
 
public class B extends A{
	 String nameA="B";
	
	
	public void getName() {
		System.out.println("子类"+nameA);
		System.out.println("父类"+super.nameA);
	}
	
	public static void main(String[] args) {
		B b=new B();
		b.getName();
	
	}
}

输出结果：

子类B

父类A

在这段代码中，把B赋值给nameA。重写了父类的变量。在调用时，为了区分哪个是子类的变量，哪个是父类的变量，在父类变量前面加 super，指明这个是父类的变量。

3.在子类的构造方法中。

1、调用父类被子类重写的方法；

2、调用父类被子类重定义的字段（被隐藏的成员变量）；

3、调用父类的构造方法；

其他情况，由于子类自动继承了父类相应属性方法，关键字super可以不显示写出来。

4.关于构造器方法中的super

如果一个类中没有写任何的构造方法，JVM会生成一个默认的无参构造方法。在继承关系中，由于在子类的构造方法中，在继承关系中，由于在子类的构造方法中，第一条语句默认为调用父类的无参构造方法（即默认为super()，一般这句话省略了）。所以当在父类中定义了有参构造函数，还是没有定义无参构造函数时，IDE会强制要求我们定义一个相同参数类型的构造器。

第一种情况：编译不通过

Java中所有的关键字及用法

不能直接继承A类，因为A类中存在有参构造函数

第二种情况：编译不通过

重写有参函数以后，还是报错，因为在子类的构造方法中，系统会默认这个有参函数是父类的，不是子类的。

第三中情款：编译通过

在子类的方法体中，调用super，这样就可以区分出来。哪个是父类的方法，哪个是子类的方法。

异常处理：

throw
就是自己进行异常处理，throw一旦进入被执行，程序立即会转入异常处理阶段，后面的语句就不再执行，而且所在的方法不再返回有意义的值！

throws

用来声明一个方法可能抛出的所有异常信息，将异常声明但是不处理，而是将异常往上传，谁调用我就交给谁处理。

try

出现在方法体中，它自身是一个代码块，表示尝试执行代码块的语句。如果在执行过程中有某条语句抛出异常，那么代码块后面的语句将不被执行

catch

出现在try代码块的后面，自身也是一个代码块，用于捕获异常try代码块中可能抛出的异常。catch关键字后面紧接着它能捕获的异常类型，所有异常类型的子类异常也能被捕获。

finally

this

this关键字主要有三个应用：

this调用本类中的属性，也就是类中的成员变量；
this调用本类中的其他方法；
this调用本类中的其他构造方法，调用时要放在构造方法的首行。

调用成员变量

public class Student{
    String name;
    private void SetName(String name){
        this.name = name;
    }
}

调用成员方法

public class ThisTest {
    String name;

   private void setName(String name) {
        this.name = name;
        System.out.println("setName: " + this.name);
    }


    private void thisTest(String name) {
        this.setName(name);
        System.out.println("thisTest: " + this.name);
    }

    public static void main(String[] args) {
        ThisTest tt = new ThisTest();

        tt.setName("Yida");
        tt.thisTest("Jenny");

    }
}

调用构造方法

public class Student { //定义一个类，类的名字为student。 
    public Student() { //定义一个方法，名字与类相同故为构造方法
        this(“Hello!”);
    }
    public Student(String name) { //定义一个带形式参数的构造方法
    }
}

package

在package是包名

return

java中的return语句总是和方法有密切关系，return语句总是用在方法中，有两个作用，一个是返回值方法指定的类型的值（这个值总是确定的），一个是结束方法的执行（仅仅返回一个return）。

return 有两种形式。

一个是有返回值类型的，另一个是没有返回值类型的。

一般方法前有void代表无返回值，没有void有返回值。

public class TestReturn { 
    public static void main(String args[]) { 
       TestReturn t = new TestReturn(); 
        t.test1(); 
        System.out.println(t.test2()); 
    } 
 
 
    /** 
     * 无返回值类型的return语句测试 
     */ 
    public void test1() { 
        System.out.println("---------无返回值类型的return语句测试--------"); 
        for (int i = 1; ; i++) { 
            if (i == 4) return; 
            System.out.println("i = " + i); 
        } 
        //System.out.println("hello,this world");此句不能执行，不可达代码
    } 
 
 
    /** 
     * 有返回值类型的return语句测试 
     * @return String 
     */ 
    public String test2(){ 
        System.out.println("---------有返回值类型的return语句测试--------"); 
        return "返回一个字符串"; 
    } 
}

new

new被翻译为“新的”。在java中，创建一个实例，或者说有一个新的对象，都需要new。在new之前，它的属性，方法在内存中是不存在的。只有使用new之后，这个类的东西才会真实存在在内存中存在的，也就是说new出来之后，才能使用。

interface

在java中，interface被翻译为接口。

在java中使用inplements关键字实现接口，并重写接口中的方法。

inplements

inplements也可以用作类的继承，不常用！

类 A 继承类 B 写成 class A implements B{}.

class

一般在java中，class用来创建对象。

有三种获得Class对象的方式：

Class.forName(“类的全限定名”)
实例对象.getClass()
类名.class （类字面常量）

void

在java中，void表示为null。所有没有返回值的方法都使用它来表示返回值类型。

Void是void的封装类型，API上称其为占用符（placeholder）。

声明一个 Void 变量通常是没有什么意义的，因为没有可为其赋值的实例，注意不能用 void 为其赋值（void 是类型而不是值）。
Void 变量唯一能持有的是 null。

import

import就是在java文件开头的地方，先说明会用到那些类别。
接着我们就能在代码中只用类名指定某个类，也就是只称呼名字，不称呼他的姓。

在程序开头写

import java.lang.System;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.BufferedReader;

synchronized

修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁
修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁
修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

作用于实例方法

public class AccountingSync implements Runnable{
    //共享资源(临界资源)
    static int i=0;

    /**
     * synchronized 修饰实例方法
     */
    public synchronized void increase(){
        i++;
    }
    @Override
    public void run() {
        for(int j=0;j<1000000;j++){
            increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        AccountingSync instance=new AccountingSync();
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
    /**
     * 输出结果:
     * 2000000
     */
}

修饰静态方

public class AccountingSyncClass implements Runnable{
    static int i=0;

    /**
     * 作用于静态方法,锁是当前class对象,也就是
     * AccountingSyncClass类对应的class对象
     */
    public static synchronized void increase(){
        i++;
    }

    /**
     * 非静态,访问时锁不一样不会发生互斥
     */
    public synchronized void increase4Obj(){
        i++;
    }

    @Override
    public void run() {
        for(int j=0;j<1000000;j++){
            increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        //new新实例
        Thread t1=new Thread(new AccountingSyncClass());
        //new心事了
        Thread t2=new Thread(new AccountingSyncClass());
        //启动线程
        t1.start();t2.start();

        t1.join();t2.join();
        System.out.println(i);
    }
}

修饰代码块

public class AccountingSync implements Runnable{
    static AccountingSync instance=new AccountingSync();
    static int i=0;
    @Override
    public void run() {
        //省略其他耗时操作....
        //使用同步代码块对变量i进行同步操作,锁对象为instance
        synchronized(instance){
            for(int j=0;j<1000000;j++){
                    i++;
              }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();t2.start();
        t1.join();t2.join();
        System.out.println(i);
    }
}

strictfp （不常用）

trictfp的意思是FP-strict，也就是说精确浮点的意思。在Java虚拟机进行浮点运算时，如果没有指定strictfp关键字时，Java的编译器以及运行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作，以致于得到的结果往往无法令你满意。而一旦使用了strictfp来声明一个类、接口或者方法时，那么所声明的范围内Java的编译器以及运行环境会完全依照浮点规范IEEE-754来执行。因此如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，那就请用关键字strictfp。
你可以将一个类、接口以及方法声明为strictfp，但是不允许对接口中的方法以及构造函数声明strictfp关键字。

volatile（JMM线程安全的保证）

volatile 是java虚拟机提供的轻量级同步机制

transient

（1）序列化
Java中对象的序列化指的是将对象转换成以字节序列的形式来表示，这些字节序列包含了对象的数据和信息，一个序列化后的对象可以被写到数据库或文件中，也可用于网络传输。一般地，当我们使用缓存cache（内存空间不够有可能会本地存储到硬盘）或远程调用rpc（网络传输）的时候，经常需要让实体类实现Serializable接口，目的就是为了让其可序列化。当然，序列化后的最终目的是为了反序列化，恢复成原先的Java对象实例。所以序列化后的字节序列都是可以恢复成Java对象的，这个过程就是反序列化。

（2）为什么要用transient关键字？
在持久化对象时，对于一些特殊的数据成员（如用户的密码，银行卡号等），我们不想用序列化机制来保存它。为了在一个特定对象的一个成员变量上关闭序列化，可以在这个成员变量前加上关键字transient。

（3）transient的作用
transient是Java语言的关键字，用来表示一个成员变量不是该对象序列化的一部分。当一个对象被序列化的时候，transient型变量的值不包括在序列化的结果中。而非transient型的变量是被包括进去的。注意static修饰的静态变量天然就是不可序列化的。

goto 非常不常用

Java中对标签的功能进行了限制，使它只能对迭代语句起作用，唯一的作用就是跳出循环嵌套

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/156378.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权正版激活】： 官方授权正版激活支持Jetbrains家族下所有IDE 使用个人JB账号...