java的关键字和保留字

最新推荐文章于 2022-05-24 10:12:17 发布

Believe丶城

最新推荐文章于 2022-05-24 10:12:17 发布

阅读量1.5k

点赞数 1

分类专栏： java 文章标签： java 实例 class

本文链接：https://blog.csdn.net/qq_38095094/article/details/74937492

版权

java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

java关键字和保留字

保留字

goto

const

保留字表明在如今的java没有什么用处，但在以后的java上可能还会派上用场，因此将之保留起来

关键字

abstract

用来修饰抽象类和抽象方法，抽象类和抽象方法不能被实例化
被abstract修饰过的类不能被final，private，static修饰，因为被这些关键字修饰的类不能被重写
abstract类中可以有非抽象方法，但是一定要存在至少一个abstract类
要想作为一个abstract类的子类，则必须实现所有的抽象类，否则他还是一个抽象类

public abstract class A{
    public abstract void method();
    //抽象类和抽象方法
    public void hello(){
        System.out.println("Hello");
    }
}

assert

用来进行程序调试
*

boolean

用来判断正确与否，只能以true和false作为值
java中的==true==和==false==不能以0和1来代替
包含boolean操作数的表达式只能包含boolean操作数

System.out.println(true||false);

Boolean是boolean的包装对象类

break

用于当循环满足某一条件时提前退出
break当放在多层循环中时，只能够退出最深一层
break还可以用于switch的case情况，满足某一种case执行后将推出switch

for(int i=0;i<100;i++){
    for(int k=0;;k++){
        if(k>40){
            System.out.println("full");
            break;
        }
    }
}

byte

基本数据类型之一，字节类型
储存范围在[-128,127]之间
Byte是byte的包装对象类

int a = Byte.MAX_VALUE;  //最大值127；
int b = Byte.MIN_VALUE;  //最小值-128；
int c = Byte.parseByte("121");//把字符串转为byte类型

case

用于switch类型的一个分支
case分支后面要写上break语句，否则之后的case情况会继续执行下去

switch(a){
    case 1:xxx;
        break;
    case 2:yyy;
        break;
    default:zzz;
        break;
}

catch

用于捕获异常，并在下列语句中对异常进行处理
在捕获异常时，应该先写小异常，后写大异常
如果某一个异常未被任何catch语句处理，该异常则沿着传递到下一个封闭try区域，如果都没有处理则退出编译器显示错误

try{
    //可能引发异常的区域
}catch(Exception A){

}catch(Exception B){

}finally{
    //无论如何finally语句包含的内容一定会被执行
}

char

基本数据类型之一，字符类型
Character是char的包装类
对于一些特殊字符，可以用’\’加上你需要的特殊字符打出

char a = '\"';  //输出a的结果的双引号的左半边
char w = '\t';  //水平制表符
int b = Character.compare('d','r');  //比较两个字符的ASCII码

class

用来声明新的java类的关键字
类有一般类抽象类，子类需要继承父类并可以重写父类的方法
类是面向对象的重要组成部分，每个对象都是类的具体实例
当class前面有static修饰时，不需要新建一个对象，通过类名直接调用
被final，private和static修饰的类不能有子类继承，因此也不能是抽象类

public class A{
    public void methodA(){
        ......
    }

    public static void main(String args[]){
        A getA = new A();
        getA.methodA();
    }
}

continue

当某次循环满足要求时，将本次循环跳转到下一次循环
总是跳转最深层次的循环

int sum = 0;
for(int i=0;i<10;i++){
    if(i == 5)
        continue;
    sum+=i;
}

default

用于switch中不符合列出的case情况的统一处理

switch(a){
    case 1{
        xxxx;
        break;
    }case 2{
        xxxx;
        break;
    }default{
        xxxx;
        break;
    }
    //当不满足1、2两种情况时，将执行defaul中的语句
}

do

用于do…while循环语句
用do…while语句时，while表达式后面需要加分号

int n = 0 ;
 do{
     n++;
 }while(n<6);

double

java数据类型之一，代表双精度浮点类型的数，float代表的是单精度浮点数
在32位和64位机器中占8位
Double是double的包装类，Double类中有对double类型数据的多种操作

double c= 0.12456;
Double d = 0.145878;  //java中有自动封箱拆箱机制，因此可以这样书写
Double.MAX_VALUE;  //代表双精度浮点数的最大值

else

else一般与if构成条件语句，当不符合if条件句时，就会执行else语句
if-else 组成的条件语句可以有多层

    if(condition 1){
        //满足条件1的执行指令
    }else{
        //不满足条件1的执行指令
    }

enum

枚举的关键字

extends

用于class或者interface声明中，用于声明该类或者接口继承了某一个类或者接口
继承的类叫做子类，被继承的类叫做父类
继承的类可以重写父类中任意非final、static、private类
没有重写父类的方法则将沿袭父类的方法

public class A{
    public void doA(){
        //doA方法的功能
    public static void doAA(){
        //function doAA
    }
}
public class B extends A{
    public void doA(){
        //new function doA;
    }
}

false

代表两个boolean变量的两个合法值之一，还有一个是true

    boolean check = false;
    boolean change = true;

final

final关键字适用于类，在class前面加上fianl表明该类不能被继承，也就是不能含有子类
final关键字还可应用于方法，表示这个方法不能被重写
一个类或者一个方法不能同时有abstract和final修饰，abstract代表必须被继承，final代表不能被继承

    public final class A{
        public final void methodA(){
        }
    }
    //以下的做法是错误的  
    public class B extends A{
        public void methodA(){}
    } //final修饰的类不允许被继承

finally

finally关键字用于组成try-catch-finally体系
在try-catch-finally体系中，finally语句必定会被执行，即使在catch中有return，break等关键字，finally也照样会执行

    try{
        //可能引发的异常
    }catch{
        //对异常的处理
    }finally{
        //无论如何，finally语句都会执行
    }

float

java数据类型之一，单精度浮点数，在32位和64位机器中占4个字节
java中浮点数默认为是双精度，要想指定单精度文字，应该在数值后面加上f或者F，比如0.04F
Float是float数据类型的包装类，同样具有装箱拆箱机制

    public static void main(String args[]){
        float d = 0.01;
        Float.MAX_VALUE; //单精度浮点数的最大值       
    }

for

代表循环语句for(;;),第一个分号前写的是初始条件，两个分号之间写的是对条件的判断，第二个分号之后写的是满足条件后执行的指令
这三个空之间的条件都可以省略不写，但有可能会构成死循环
continue和break会影响循环的执行

    int sum = 0;
    for(int i=0;i<20;i++){
        if(sum>=30) break;
        sum+=i;
        if(i==6) continue;
    }

goto

作为java的保留字段，现在没有什么用处。
C语言的goto语句用于跳转指针，java已使用类+方法进行代替

if

与else构成if-else条件语句
符合if语句时执行if指令，否则执行else指令

     if(condition A){
         //do function A
     } else{
        //do function B  
    }

implements

implements关键字在class类中使用，表示这个类实现了某一个接口，实现了该接口必须要实现该接口的所有抽象类
一个类可以实现多个接口

    public interface A{
        public abstract void methodA();  //抽象方法
    }

    public class implements A{
        public void methodA(){
            //functionA...;
        }
    }

import

import 用于导入某一个包，当要导入整个包时，在导入的包后面加上“*”；

    import java.util.*;
    import java.io.FileInputStream;  //导入特定的类名，避免不确定性

instanceof

instanceof用来确定所属对象的类是否属于某个类或者某个类的子类

    public class A{
        //function
    }
    public static void main(String args[]){
        A a = new A();
        System.out.println(a instanceof A); //a是类A的实例，返回true;
        System.out.println(a instanceof B); //a不是类B的实例，编译无法通过
    }

int

java的基本数据类型之一，代表整数
Integer是int的包装类，同样含有装箱拆箱机制，方法和Double基本相似

interface

声明这是一个接口，抽象类中可以含有一般方法，接口中只能含有抽象方法
一个类可以继承多个抽象类
实现了某个接口的类必须实现该接口的所有抽象类

    public interface A{
        public abstract void method1();
        public method2(){};  //拥有一般类是错误的
    }
    public interface B{
        public abstract void method2();
    }
    public class C implements A,B{
        //必须实现两个抽象方法
        public void method1(){}  
        public void method2(){}
    }

long

java的基本数据类型之一，表示长整型，在32位和64位计算机中占8位
Long是long的包装类，方法和Integer中的方法基本相似

new

当要新建一个实例对象时，需要用到new关键字来创建；
new 后面带的必须是类名，类名后面跟上的是该类中含有的构造方法，默认有的构造方法是类名+();
含有static 修饰的类可以直接用类名不用创建实例

    public class A{
        public A(int a,int b){}
        public void method(){}
        public static void main(String args[]){
        //以下是两种不同的构造方法
            A a = new A();
            A b = new A(3,4);
        }
    }

null

null是java的保留字，表示空值
不能将null赋值给int，double，short，long，char，byte , boolean 这些对象

package

表示java源文件中声明的类所驻留的java包
package 语句必须是java源程序中的第一句非注释性文本

    //这是注释性文本，可以防御package语句之前 
    package com.cheng;  //必须位于java程序中的第一句

private

用于对类，方法或者字段的修饰
用private修饰的类，方法，字段只在该类、该方法、该字段中可见，对于其它类甚至是它的子类也一样不可见
一般对于一个类的某个成员一般使用private，通过get、set方法来对成员进行赋值和取值，这样会有较高的安全性

    public class A{
        private String name;
        private int age;
        //通过暴露接口来获取成员变量
        public String getName(){
            return this.name;
        }
        //一下此方法只在此类中可见
        private int methodA(){
            //functionA;
        }
    }

    public class B{
        A a = new A();
        //下面是错误的
        a.methodA();
        a.name;   //无法得到
    }

protected

用于类、方法或者字段的修饰
被protected修饰的类、方法或者字段可在本包内的任一地方使用，外部包只有继承了该类成为他的子类才可以使用，否则会产生错误

package 1
    protected class A{
        public void methodA(){
                //function A;
            }
    }
    public class B{
        //在同一个包内可以使用
        A a = new A();
        a.methodA();
    }

package 2
    public class C extends A{
        public void methodA(){
        //new function A;
        }
    }

    public class D{
        //在外包且无继承A类，一下方法不能使用 
        A a = new A();
    }

public

用于类、方法和字段的访问控制修饰符
用public修饰的类在任何地方都可以使用
被public修饰的类、方法、字段对外界是公开的，任何人都可以看到

return

作为返回的标志
返回的类型要和声明这个类时的返回类型一致
return后面加括号也可以不加括号

    public class A{
        public String methodA(){
            //function A;
            return +String类型数据
        }
    }

short

short是java基本数据类型之一，代表整型
Short是short的包装类，详细方法类似于Integer包装类

static

被static修饰的变量称为静态变量，修饰的方法称为静态方法，修饰的类称为静态类
被static修饰的类可以直接通过类名调用，不需要新创建实例
被static修饰的方法和成员变量也可以被子类重写

    public static class A{
        static int ss = 10;
        public void methodA(){
            //function A;   
        }
        public static void main(String[] args){
            A.methodA();  //通过类名直接调用方法
        }
    }
    class B entends A{
        static int ss = 20;
    }

strictfp

精确浮点数
strictfp 关键字可应用于类、接口或方法。使用 strictfp 关键字声明一个方法时，该方法中所有的float和double表达式都严格遵守FP-strict的限制,符合IEEE-754规范。当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算

super

一个指向父类的指针，当子类的方法使用super时代表它继承了父类对这个方法的指令
直接父类的引用，super.xxx表示引用了父类的成员变量
super还可以用来调用构造函数

    public class A{
        piublic A(int a,int b){
            //function...
        }
        int a = 20;
        public void methodA(){} 
    }
    public class B extends A{
        super(int a,int b);//引用父类构造函数
        super a;
        public void methodA(){
            super.methodA();
        }

    }

switch

和case构成switch-case条件语句，具体方法请看case关键字叙述
switch后面跟的可以是变量，但case后面只能跟常量

synchronized

运用于多线程同步锁，当运用到该类或者实例时，它们将被锁定
当一个线程在进行时会获得一个同步锁，此时其它线程不能拿到这个同步锁，因此也无法执行下去，只有当正在执行的线程结束之后释放同步锁才可以交给其它线程执行。

防止了多线程并发出现的错误情况

接下来举一个银行账户的例子

  //首先创建一个账户类 
  public class Account {

//封装账号  
private String accountNo;     //账户名
private double balance;        //账户余额
public String getAccountNo() {
    return accountNo;
}
public void setAccountNo(String accountNo) {
    this.accountNo = accountNo;
}
public double getBalance() {
    return balance;
}
public void setBalance(double balance) {
    this.balance = balance;
}

public Account(){};
//构造方法
public Account(String accountNo,double balance){
    this.accountNo = accountNo;
    this.balance = balance;

}

public int hashCode(){
    return accountNo.hashCode();
}
比较是否是同一个账户名
public boolean equal(Object obj){
    if(obj == this)
        return true;
    if(obj!=null && obj.getClass() == accountNo.getClass()){
        Account target = (Account) obj;
        return target.accountNo.equals(accountNo);
    }
    return false ; 
}
}

public class withDraw extends Thread{
    private Account account ; 
    private double accountSum;
    public withDraw(String name,Account account,double accountSum){
        super(name);
        this.account = account;
        this.accountSum = accountSum;
    }
        public void run() {
            //给account加上一个同步锁，当一个线程在进行时，其它线程无法执行，无法对账户进行操作
            //等其中一个account执行完毕之后才释放同步锁
            synchronized (account) {
                if(account.getBalance()>=accountSum){
                    System.out.println(getName()+"取钱成功");
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    //取钱后修改余额
                    account.setBalance(account.getBalance() - accountSum);
                    System.out.println("余额为"+account.getBalance());
                }else{
                    System.out.println("余额不足");
                }
            }

    }
        public static void main(String[] args) {
            Account account = new Account("12345",4000);
            withDraw a1 = new withDraw("a1", account, 2500);
            withDraw a2 = new withDraw("a2",account,2000);
            a1.start();
            a2.start();

        }

}

运行结果如下

假如没有了同步锁，便很有可能出现如下情况
这里写图片描述

this

this指的是当前对象本身
形参与成员变量名字重名，用this来区别
调用构造方法
方法和前面的super类似，只是super主要调用父类的成员变量和方法，this主要调用的是自身的成员变量的方法

throw 和 throws

都应用在异常处理上
throws应用在方法声明上，throw应用在方法内部
throws表明该方法可能会产生这种异常；而throw表示必会抛出这种异常，而且是异常实例
throws每次可以抛出多个异常，throw每次只能抛出一个异常实例
使用了throw和throws的方法在使用时将不需要使用try-catch

    //throws:
    public void methodA () throws Exception1，Exception2{
        //在方法外部声明可能会抛出这种异常,可以抛出多个异常
    }

    //throw：
    public void methodA(){
        if(xxx==false){
            throw new Exception("error!!");
            //抛出一个异常实例
        }
    }

transient

java的serialization提供了一种持久化的实例对象。有时候为了关闭这种实例化对象，就在那个特定的对象前面加上transient来修饰。
当一个对象创建后，当通过ObjectOutputStream把这个类的实例保存到磁盘上时，被transient修饰的类是不会被保存的。也就是说，当你通过ObjectInputStream将对象重新拿出来时，得到的是个null，它不能被序列化

try

和catch、finally构成try-catch-finally语句，用来处理异常，例子详见catch
每一个try都至少有一个catch和finally语句

true

boolean变量其中之一，表示正确，另外一个是false

void

表示返回值为null类型

    public void method(){
    ...
    return ;
    }

volatile

应用于多线程的共享变量关系，当几个线程同时使用一个变量时候，可能会因为CPU和主存数据的不同而产生错误。比如说：在多核处理器中，i的初始值为0，线程1将i赋值为10。在CPU1中对i进行高速缓存，而并没有更新到主存中。当线程2调用i时，从主存中拿到的i值还是0，因此会产生一些数据上的错误。无法保证可见性
java运用volatile关键字来保证可见性
当一个共享变量被volatile修饰之后，他会保证修改的值立刻更新到主存中
volatile只能保证可见性，不能保证原子性
volatile能够保证有序性
synchronized 和 Locked 可以保证原子性

while

构成while循环
构成do…while循环

Believe丶城

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java的关键字和保留字

java关键字和保留字保留字gotoconst保留字表明在如今的java没有什么用处，但在以后的java上可能还会派上用场，因此将之保留起来关键字abstract用来修饰抽象类和抽象方法，抽象类和抽象方法不能被实例化被abstract修饰过的类不能被final，private，static修饰，因为被这些关键字修饰的类不能被重写abstract类中可以有非抽象方法，但是一定要存在至少一个ab
复制链接

扫一扫