java关键字 订阅
Java关键字是电脑语言里事先定义的,有特别意义的标识符,有时又叫保留字,还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义,他们用来表示一种数据类型,或者表示程序的结构等,关键字不能用作变量名、方法名、类名、包名和参数。 展开全文
Java关键字是电脑语言里事先定义的,有特别意义的标识符,有时又叫保留字,还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义,他们用来表示一种数据类型,或者表示程序的结构等,关键字不能用作变量名、方法名、类名、包名和参数。
信息
关键字
是电脑语言里事先定义的
有特别
意义的标识符
别    名
保留字
有    时
又叫保留字,还有特别意义的变量
中文名
Java关键字
简    介
Java关键字是对Java编译器有特殊含义的字符串
java关键字简介
Java关键字是对Java编译器有特殊含义的字符串,是编译器和程序员的一个约定,程序员利用关键字来告诉编译器其声明的变量类型、类、方法特性等信息。Java语言共定义了如下所示的关键字。 [1] 
收起全文
精华内容
下载资源
问答
  • java关键字

    2019-04-22 20:06:12
    java关键字 关键字也称为保留字,是指java语言中规定了特定含义的标示符。对于保留字,用户只能按照系统规定的方式使用,不能自行定义。Java中有50个常用关键字:
  • Java关键字大全

    2014-04-17 09:12:45
    Java关键字大全,Java中关键字解析
  • JAVA关键字及作用详解

    2020-08-31 06:29:14
    本文主要介绍了Java关键字及作用,具有很好的参考价值,下面跟着小编一起来看下吧
  • Java关键字

    2013-07-18 17:55:10
    总结珍藏版(48个) java
  • java关键字总结文档

    2018-03-26 11:34:38
    java 关键字总结大全,最新版本的java8中所有的关键字总结
  • 主要为大家详细介绍了Java关键字volatile和synchronized的作用和区别,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要介绍java关键字和java命名规范,主要介绍java关键字和java命名规范
  • JAVA关键字表格

    2017-06-12 11:58:52
    整理JAVA关键字信息
  • .JAVA关键字和英语单词,有祝于学习Java基础的加快进步
  • java关键字详解

    千次阅读 多人点赞 2018-11-22 15:29:32
    java中有两个特殊的关键字goto、const,我们称这两个关键字为保留字。 二、java中有哪些关键字? 先来介绍几个特殊的关键字,我们称之为访问修饰符。另一个名字被叫做访问控制符。 1.什么是访问修饰符? java...

     

    首先来说说我对关键字的理解!

    一、什么是关键字?

    关键字是java语言中一些被赋予特定意义的一些单词,不可以把它当做标识符来使用。

    在java中有两个特殊的关键字goto、const,我们称这两个关键字为保留字。

    二、java中有哪些关键字?

    先来介绍几个特殊的关键字,我们称之为访问修饰符。另一个名字被叫做访问控制符。

    1.什么是访问修饰符?

    java通过修饰符来控制类、属性和方法的访问权限和其他功能,一般放再java语句的最前端。

    2.访问修饰符的访问权限的范围

    修饰符说明                       
    public共有的,对所有类可见。
    protected受保护的,对同一包内的类和所有子类可见。
    默认的在同一包中可见,默认不使用任何修饰符。
    private私有的,在同一类可见,也就是在同一类中可访问。

    从上述表格可以看出从public、protected、默认的、private的访问权限范围依次减少。

    class:定义类的关键字。

    interface:定义接口的关键字。

    abstract :定义抽象类或者抽象方法的关键字。

    enum:定义枚举的关键字。

    extends:继承类或者继承接口的关键字。

    implements:实现接口的关键字。

    new:实例化对象的关键字。

    void:数据类型的关键字。

    byte、short、int、long:整型数据的关键字  是指十进制类型的

    整数数据类型:

    数据类型内存空间(8位等于一个字节)取值范围
    byte8位-2^7~2^7-1
    short16位-2^15~2^15-1
    int 32位-2^31~2^31-1
    long64位-2^63~2^63-1

    float、double是指浮点型数据的关键字。

    浮点型类型数据:

    数据类型内存空间取值范围
    float32位1.4E-45~3.4028235E38
    double64位4.9E-324~1.7976931348623157E308

    在默认的情况下,小数被看做是double型,若使用float型的小数,则需要在小数后面加上f或者F。若是double型数据,可以在小数后面加d或者D,不加d也不会出错

    char:字符的关键字       16位        范围是0~65535

    boolean:布尔类型的关键字   它的值有true和false

    this关键字:

    this关键字用来表示当前对象本身,或者当前类的一个实例化对象,通过this可以调用对象的所有属性和方法。静态方法中不能使用this关键字。

    this关键字的三个用法:

    1.通过this关键字可以明确地去访问一个类的成员变量和成员方法,解决与局部变量名的冲突。

    2.this关键字调用构造方法:构造方法是在实例化对象时java虚拟机自动调用的,不能像调用普通方法那样去调用,可以通过this(参数1,参数2.....)的型式调用其他的构造方法。

    使用this关键字调用构造方法时需要注意的是:

    *只能在构造方法中使用this调用其他构造方法,不能在对象的成员方法中使用this调用构造方法

    *在构造方法中,用this调用构造方法的语句必须放在第一位,并且写一次。

    *不能再一个类的两个方法中使用this相互调用,不然会报错。

    3.this还可以表示当前对象,也就是哪个对象在调用this所在的方法,那么此时this就是代表着这个对象。

    super关键字:

    super关键字代表父类对象,主要用于指定父类的属性和方法,也用于在子类中初始化父类。子类的静态方法中不能使用super关键字。

    那么为什么super不能用于子类的静态方法中呢?

    原因是super指代的是父类的一个对象,它需要在运行的时候才会被创建,二静态方法是指类方法,当类加载的时候,静态方法就已经存在,但是父类对象还没有被初始化。

    super关键字的用法:

    • 使用super关键字可以在子类中调用父类的属性和方法,当子类和父类拥有相同的属性和方法时,此时如果你想调用父类的属性和方法,那么就必须使用super关键字,如果不使用的话,父类的方法和属性就会被子类覆盖。
    • 子类是父类的派生类,它的实例化依赖于父类的实例化。所以它的任何一个构造函数都必须要初始化父类,Java就是super关键字调用父类构造方法,来完成这个操作。如果在父类没有无参构造方法,那么在子类中必须显示调用super来调用已有的有参构造函数来初始化父类。

    下面是一个关于构造方法的例子:讲的是如果在父类没有无参构造方法,那么在子类中必须显示调用super来调用已有的有参构造函数来初始化父类。

    public class Demo1 {
    public String name="小明";
    public Demo1(String name){
    	System.out.println(name+"正在运动");
    }
    public void play(String name){
    	System.out.println(name+"正在休息");
    }
    }
    
    
    public class Demo2 extends Demo1{
    public Demo2(String name) {
    	super("张三");
    }
    }
    
    

     异常的关键字:

    try:用来检测语句块中是否有异常       try{}

    catch:用来捕获异常,然后进行处理    catch(异常类型){}

    如果在try-catch语句进行异常处理,当try代码块中的语句发生了异常,程序就会调转到catch代码中执行,执行完catch代码块中的程序代码后,将继续执行catch代码后的其它代码,而不会执行try代码块中发生异常语句后面的代码。由此可知,java的异常处理机制是结构化的,不会因为一个异常影响整个程序的执行。

    finally:不管是否发生异常,都会执行的语句块       finally{}

    注意,在以下四种特殊情况下finally语句块不会执行:

    在finally语句块中发生了异常;

    在前面的代码中使用了System.exit()退出程序;

    程序所在的线程死亡;

    关闭cpu;


    volatile:数据同步。

    synchronized:同步              可以用来同步方法、同步代码块

    循环的关键字: for 、while、do、break、continue

    接下来主要讲讲break和continue关键字:

    break关键字和continue关键字是用来控制循环的跳转的;

    break语句可以用来跳出switch结构。在循环结构中,同样可以用break语句跳出当前循环体,从而中断循环。
    1.break跳出循环。下面是实例代码

    public class Demo1 {
    public static void main(String []args){
    	for(int i=0;i<=100;i++){
    		System.out.println(i);
    		if(i==4){
    			break;
    		}
    	}
    	System.out.println("end");
    }
    }

    输出结果为:

    2. 在内层嵌套循环中使用break跳出内层循环。下面是实例代码:

    public class Demo1 {
    public static void main(String []args){
    	for(int i=0;i<3;i++){
    		for(int j=0;j<10;j++){
    			if(j==3){
    				break;
    			}
    			System.out.println("i="+i+"  j="+j);
    		}
    	}
    }
    }

    输出结果:

     

     continue语句是对break语句的补充。continue不是立即跳出循环体,而是指跳出本次循环结束前的语句,回到循环的条件测试部分,重新开始执行。

    下面试一个实例,输出1~10之间的奇数,使用continue跳出循环。

    public class Demo1 {
    public static void main(String []args){
    	for(int i=1;i<=10;i++){
    		if(i%2==0){
    			continue;       //如果i为偶数,跳到下一循环
    		}
    		System.out.println(i);//输出i的值
    	}
    }
    }

    输出结果:

     使用break 标签名可以跳出指定的循环体,此循环体的标签名必须与break标签名一直。这个循环可以是内循环也可以是外循环。

    语法如下:

    标签名:循环体{ 

    break  标签名;

    }

    下面是带有标签的break跳出外层循环的实例。

    public class Demo1 {
    public static void main(String []args){
    	Loop:for(int i=0;i<3;i++){
    		for(int j=0;j<=5;j++){	//for循环前用标签标记
    			if(j==3){			//如果j等于3就结束外层循环,跳出Loop标签的循环体
    				break Loop;
    			}
    			System.out.println(j);
    		}
    	}
    }
    }

    输出结果:

     与break语句一样,continue也支持标签功能。语法如下:
    标签名:循环体{

              continue 标签名;

    }

    标签名:可以说任意标识符;  循环体:任意循环语句; continue标签名:continue跳出指定的循环体,此循环体的标签名必须与continue的标签名一致;

    条件关键字:if、else、switch、case、default

    return:返回结果的关键字;

    package:定义包的关键字;

    native:调用C或者C++的代码;

    assert:断言;

    transient:瞬时的   IO流的对象流

    instanceof关键字:

    java中,instanceof运算符的前一个操作符是一个引用变量,后一个操作数通常是一个类(可以是接口),用于判断前面的对象是否是后面的类,或者其子类、实现类的实例。如果是返回true,否则返回false。

    也就是说:使用instanceof关键字做判断时, instanceof 操作符的左右操作数必须有继承或实现关系
    例如a是A类的一个实例对象,那么     a  instanceof   A ;  则会返回一个true的布尔值。

    static关键字:

    由static修饰的变量、常量、和方法称作静态变量、常量、方法;

    有时候在处理问题时会需要两个类或者多个类在一个内存空间区域共享一个数据。那么在此时需要将它定义为静态的数据;

    被声明为static的变量、常量和方法被称为静态成员。静态成员属于类所有,区别于个别的对象,可以在本类或其他类使用类名和其他类名和“.”运算符调用静态成员。

    static的主要作用:为特定数据类型或对象分配单一的存贮空间,而与创建对象的个数无关。或者把某个方法或属性与类而不是对象关联在一起。

    static的使用:参考:https://blog.csdn.net/chaoshenzhaoxichao/article/details/80402768

    1.可以用来修饰常量;

    2.可以用来修饰成员变量,通过static关键字来达到全局的效果。静态变量 属于类,在内存中只有一个副本。只要静态变量所在的类被加载,这个静态类就会被分配空间,因此就可以被使用。对静态变量的引用有两种方式,分别为“类.静态变量”和“对象.静态变量”。实例变量属于对象,只有对象被创建后,实例变量才会被分配空间,才能被使用,他在内存中存在多个副本,只能用“对象.静态变量”的方式来引用。静态变量只有一个,被类所拥有,所有的对象都共享这个静态变量。

    3.可以用来修饰成员方法,static方法是属于类的方法不需要创建对象就可以被使用,而非static方法是对象的方法,只有对象被创建出来后才可以被使用。static方法中不能使用this和super关键字,不能调用非静态方法,只能访问静态的成员变量和方法。static谁能实现单例模式,单例模式的特点是该类只有一个实例。

    4.static可以用来修饰代码块,static代码块在类中是独立与成员变量和成员函数的代码块,他不在任何一个方法体内,JVM在加载里的时候会执行static代码块,如果有多个static代码块,JVM将会按顺序来执行,static代码块经常会被用来初始化静态变量,需要注意的是static代码块只会被执行一次。

    5.static可以用来修饰内部类,static内部类是指被申明为static的内部类,他可以不依赖于外部类实例对象而被实例化,而通常的内部类需要外部类实例化后才能实例化。静态内部类不能与外部类有相同的名字,不能访问外部类的普通成员变量,只能访问外部类中的静态成员和静态成员方法,只有内部类才能被申明为static。

    final关键字:

    final表示最终的,final可以用来修饰普通方法、属性、变量、形参、常量、类、内部类。

    如果修饰普通方法,表示该方法不能被重写;

    如果修饰属性、变量、形参,表示值不能改变;

    如果修饰类,表示类不能被继承。

    属性、变量、形参、常量的名字中的存储的内容是不能改变的;

    展开全文
  • Java关键字(Java 8版本)

    万次阅读 多人点赞 2019-09-28 22:11:04
    定义 被Java语言赋予了特殊含义,用作专门...Java关键字(Java 8版本) Java关键字(Java 8 以后版本) 注意事项 true,false和,null看起来像关键字,但它们实际上是文字; 您不能在程序中将它们用作标识符。 ...

    定义

    • 被Java语言赋予了特殊含义,用作专门用途的字符串(单词),这些关键字不能用于常量、变量、和任何标识符的名称。

    Java关键字(Java 8版本)

    Java关键字(Java 8版本)

    Java关键字(Java 8 以后版本)

    在这里插入图片描述

    注意事项

    • true,false和,null看起来像关键字,但它们实际上是文字; 您不能在程序中将它们用作标识符。
    展开全文
  • JAVA关键字

    2011-09-30 14:54:43
    这是我自己整理制作的50个java关键字,是用html制作的类似与API的网页格式的文档,里面内容详细,且便于查询。
  • Java关键字以及含义

    千次阅读 2020-04-12 18:27:06
    Java关键字是电脑语言里事先定义的,有特别意义的标识符,有时又叫保留字,还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义,他们用来表示一种数据类型,或者表示程序的结构等,关键字不能用作变量名、...

    前言

    Java关键字是电脑语言里事先定义的,有特别意义的标识符,有时又叫保留字,还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义,他们用来表示一种数据类型,或者表示程序的结构等,关键字不能用作变量名、方法名、类名、包名和参数。

    一、关键字分类

    • 访问控制
      private
      protected
      public

    • 类与方法和变量修饰符
      abstract
      class
      extends
      final
      implements
      interface
      native
      new
      static
      strictfp
      synchronized
      transient
      volatile

    • 程序控制
      break
      continue
      return
      do
      while
      if
      else
      for
      instanceof
      switch
      case
      default

    • 错误处理
      try
      catch
      throw
      throws

    • 包相关
      import
      package

    • 基本类型
      boolean
      byte
      char
      double
      float
      int
      long
      short
      null
      true
      false

    • 变量引用
      super
      this
      void

    • 保留字
      goto
      const

    二、关键字以及含义

    A
    abstract 表明类或者成员方法具有抽象属性
    assert 用来进行程序调试

    B
    boolean 基本数据类型之一,布尔类型
    break 提前跳出一个块
    byte 基本数据类型之一,字节类型

    C
    case 用在switch语句之中,表示其中的一个分支  
    catch 用在异常处理中,用来捕捉异常
    char 基本数据类型之一,字符类型
    class 类
    const 保留关键字,没有具体含义
    continue 回到一个块的开始处

    D
    default 默认,例如,用在switch语句中,表明一个默认的分支
    do 用在do-while循环结构中
    double 基本数据类型之一,双精度浮点数类型

    E
    else 用在条件语句中,表明当条件不成立时的分支
    enum 枚举
    extends 表明一个类型是另一个类型的子类型,这里常见的类型有类和接口

    F
    final 用来说明最终属性,表明一个类不能派生出子类,或者成员方法不能被覆盖,或者成员域的值不能被改变
    finally 用于处理异常情况,用来声明一个基本肯定会被执行到的语句块
    float 基本数据类型之一,单精度浮点数类型
    for 一种循环结构的引导词

    G
    goto 保留关键字,没有具体含义

    I
    if 条件语句的引导词
    implements 表明一个类实现了给定的接口
    import 表明要访问指定的类或包
    instanceof 用来测试一个对象是否是指定类型的实例对象
    int 基本数据类型之一,整数类型
    interface 接口

    L
    long 基本数据类型之一,长整数类型

    N
    native 用来声明一个方法是由与计算机相关的语言(如C/C++/FORTRAN语言)实现的
    new 用来创建新实例对象

    P
    package 包
    private 一种访问控制方式:私用模式
    protected 一种访问控制方式:保护模式
    public 一种访问控制方式:共用模式

    R
    return 从成员方法中返回数据

    S
    short 基本数据类型之一,短整数类型
    static 表明具有静态属性
    strictfp 用来声明FP_strict(单精度或双精度浮点数)表达式遵循IEEE 754算术规范
    super 表明当前对象的父类型的引用或者父类型的构造方法
    switch 分支语句结构的引导词
    synchronized 表明一段代码需要同步执行

    T
    this 指向当前实例对象的引用
    throw 抛出一个异常
    throws 声明在当前定义的成员方法中所有需要抛出的异常
    transient 声明不用序列化的成员域
    try 尝试一个可能抛出异常的程序块

    V
    void 声明当前成员方法没有返回值
    volatile 表明两个或者多个变量必须同步地发生变化

    W
    while 用在循环结构中

    展开全文
  • 【java基础】java关键字总结及详解

    万次阅读 多人点赞 2018-08-26 16:19:17
    Java关键字是电脑语言里事先定义的,有特别意义的标识符,有时又叫保留字,还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义,他们用来表示一种数据类型,或者表示程序的结构等,关键字不能用作变量名、...

     

    Java关键字是电脑语言里事先定义的,有特别意义的标识符,有时又叫保留字,还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义,他们用来表示一种数据类型,或者表示程序的结构等,关键字不能用作变量名、方法名、类名、包名和参数。

    (一)总表:java关键字共53个(其中包含两个保留字const,goto)

    abstract

    assert

    boolean

    break

    byte

    case

    catch

    char

    class

    const
    continuedefaultdodoubleelse
    enumextendsfinalfinallyfloat
    forgotoifimplementsimport
    instanceofintinterfacelongnative
    newpackageprivateprotectedpublic
    returnstrictfpshortstaticsuper
    switchsynchronizedthisthrowthrows
    transienttryvoidvolatilewhile
    truefalsenull  

     另外,Java还有3个保留字:true、false、null。它们不是关键字,而是文字。包含Java定义的值。和关键字一样,它们也不可以作为标识符使用。参考https://baike.baidu.com/item/java%E5%85%B3%E9%94%AE%E5%AD%97/5808816?fr=aladdin#3_43

    (二)大致含义

    关键字含义
    abstract表明类或者成员方法具有抽象属性
    assert断言,用来进行程序调试
    boolean基本数据类型之一,布尔类型
    break提前跳出一个块
    byte基本数据类型之一,字节类型
    case用在switch语句之中,表示其中的一个分支
    catch用在异常处理中,用来捕捉异常
    char基本数据类型之一,字符类型
    class声明一个类
    const保留关键字,没有具体含义
    continue回到一个块的开始处
    default默认,例如,用在switch语句中,表明一个默认的分支
    do用在do-while循环结构中
    double基本数据类型之一,双精度浮点数类型
    else用在条件语句中,表明当条件不成立时的分支
    enum枚举
    extends表明一个类型是另一个类型的子类型,这里常见的类型有类和接口
    final用来说明最终属性,表明一个类不能派生出子类,或者成员方法不能被覆盖,或者成员域的值不能被改变,用来定义常量
    finally用于处理异常情况,用来声明一个基本肯定会被执行到的语句块
    float基本数据类型之一,单精度浮点数类型
    for一种循环结构的引导词
    goto保留关键字,没有具体含义
    if条件语句的引导词
    implements表明一个类实现了给定的接口
    import表明要访问指定的类或包
    instanceof用来测试一个对象是否是指定类型的实例对象
    int基本数据类型之一,整数类型
    interface接口
    long基本数据类型之一,长整数类型
    native用来声明一个方法是由与计算机相关的语言(如C/C++/FORTRAN语言)实现的
    new用来创建新实例对象
    package
    private一种访问控制方式:私用模式
    protected一种访问控制方式:保护模式
    public一种访问控制方式:共用模式
    return从成员方法中返回数据
    short基本数据类型之一,短整数类型
    static表明具有静态属性
    strictfp用来声明FP_strict(单精度或双精度浮点数)表达式遵循IEEE 754算术规范 [1] 
    super表明当前对象的父类型的引用或者父类型的构造方法
    switch分支语句结构的引导词
    synchronized表明一段代码需要同步执行
    this指向当前实例对象的引用
    throw抛出一个异常
    throws声明在当前定义的成员方法中所有需要抛出的异常
    transient声明不用序列化的成员域
    try尝试一个可能抛出异常的程序块
    void声明当前成员方法没有返回值
    volatile表明两个或者多个变量必须同步地发生变化
    while用在循环结构中

    (三)详细介绍

    1.关键字abstract

    abstract关键字可以修饰类或方法。

    abstract类可以扩展(增加子类),但不能直接实例化。

    abstract方法不在声明它的类中实现,但必须在某个子类中重写。

    public abstract class MyClass{}

    public abstract String myMethod();

    采用abstract方法的类本来就是抽象类,并且必须声明为abstract。

    abstract类不能实例化。

    仅当abstract类的子类实现其超类的所有abstract方法时,才能实例化abstract类的子类。这种类称为具体类,以区别于abstract类。

    如果abstract类的子类没有实现其超类的所有abstract方法,该子类也是abstract类。

    abstract关键字不能应用于static、private或final方法,因为这些方法不能被重写,因此,不能在子类中实现。

    final类的方法都不能是abstract,因为final类不能有子类。

    2.关键字assert(断言)

    断言在软件开发中是一种常用的调试方式,很多开发语言中都支持这种机制。一般来说, 断言用于保证程序最基本、关键的正确性。断言检查通常在开发和测试时开启。为了保证程序 的执行效率,在软件发布后断言检查通常是关闭的。

    断言是一个包含布尔表达式的语句,在执 行这个语句时假定该表达式为 true;如果表达式的值为 false,那么系统会报告一个 AssertionError。 断言的使用如下面的代码所示:

    assert(a > 0); // throws an AssertionError if a <= 0

    断言可以有两种形式:

    assert Expression1;
    assert Expression1 : Expression2 ;

    3.关键字boolean

    boolean类型适用于逻辑运算,一般用于程序流程控制。boolean类型数据只允许取值true或false,不可以0或非0的整数代替true和false,这点与C语言不同。

    4.关键字break&Continue&case&switch

    break&Continue语句

    break语句用于终止某个语句块的执行。用在循环语句体中,可以强行推出循环。

    public class BreakTest {
        public static void main(String[] args) {
            int stop = 5;
            for (int i = 0; i < 10; i++) {
                if (i == stop) {
                    break;
                }
                System.out.println("i="+i);
            }
        }
    }
    结果:
    i=0
    i=1
    i=2
    i=3
    i=4
    
    
    /**
     * 说明:输出1~100内前5个可以被3整除的数
     *
     * @author huayu
     * @date 2018/8/1 下午4:14
     */
    public class BreakTest {
        public static void main(String[] args) {
           int num=0,i=1;
           while (i<=100){
               if(i%3==0){
                   System.out.println(i+" ");
                   num++;
               }
               if(num==5){
                   break;
               }
               i++;
           }
        }
    }

    continue语句用在循环语句体中,用于终止某次循环过程,跳过循环体中continue语句下面未执行的循环,开始下一次循环。

    public class ContinueTest {
        public static void main(String[] args) {
            int skip = 5;
            for (int i = 0; i < 10; i++) {
                if (i == skip) {
                    continue;
                }
                System.out.println("i="+i);
            }
        }
    }
    结果:
    i=0
    i=1
    i=2
    i=3
    i=4
    i=6
    i=7
    i=8
    i=9
    
    
    /**
     * 说明:输出101~200内的质数
     *质数又称素数。一个大于1的自然数,除了1和它自身外,不能整除其他自然数的数叫做质数;
     * @author huayu
     * @date 2018/8/1 下午4:21
     */
    public class ContinueTest {
        public static void main(String[] args) {
            //只算奇数就可以,偶数肯定不是质数
            for (int i = 101; i < 200; i+=2) {
                //置个标记,首先默认是质数
                boolean flag=true;
                //如果进入这层for循环flag被置为false,则表示不是质数,那么就跳出内层循环不执行了
                for (int j = 2; j < i; j++) {
                    if(i%j==0){
                        flag=false;
                        break;
                    }
                }
                //筛选,如果不是质数,也就是flag是false就跳过外层这一次循环,继续下一次循环
                if(!flag){
                    continue;
                }
                //如果是质数则能走到这一步,输出出来
                System.out.println(" "+i);
            }
        }
    }

    5)switch语句

    语句形式:switch(choice){

         case xx:

                ....

            break;

        case xx:

                ....

             break;

        default:

                ....

            break;

    }

    5.关键词byte,short,int,long

    整数类型(java里面所有的数都是带符号的)

    java各整数类型有固定的表数范围和字段长度,其不受具体操作系统(windows,linux,mac...)的影响,以保证java程序的可移植性。

    java语言整型常量的三种表示形式:

    1)十进制整数,如:12,-31,0

    2)八进制整数,要求以0开头,如:012(因0开头,010就不确定是什么进制表示的了,为了避免混淆不建议用八进制)

    3)十六进制数,要求Ox或OX开头,如:OX12

    注意:不管是什么进制在计算机中都是以二进制表示,所以不管是十进制,八进制,十六进制来表示,只要是表示的同一个数它在计算机中的存储都是一样的。

    java语言的整型常量默认为int型,声明long型常量可以加l或L(我建议加L好区分)

    类型占用存储空间表数范围
    byte1字节-128~127(-2^7~2^7-1)
    short2字节-2^15~2^15-1
    int4字节-2^31~2^31-1
    long8字节-2^63~2^63-1

    6.关键字char

    char型数据用来表示通常意义上“字符”。

    字符常量为用单引号括起来的单个字符,例如:

    char e='a'; 

    char e='中';

    java字符采用Unicode编码,每个字符占两个字节(1个字节占8位,数据在计算机底层存储,用0101表示,每一个0,1都叫一个位(bit)),因而可用十六进制编码形式表示。例如:

    char c1='\u0061';(在内存中应是01100001,\u指的是后面4位数是十六进制的Unicode编码)

    注:Unicode编码是全球语言统一编码。

    java语言中还允许使用转义字符‘\’来将其后的字符转变为其它的含义,例如:

    char c2='\n';

    7.可控制访问权限的四个关键字private,default,protected,public

    java权限修饰符public protected private置于类的成员定义前,用来限定其他对象对该类对象成员的访问权限。

    修饰符类内部同一个包子类任何地方
    privateyes(可以访问)   
    defaultyes(可以访问)yes(可以访问)  
    protectedyes(可以访问)yes(可以访问)yes(可以访问) 
    publicyes(可以访问)yes(可以访问)yes(可以访问)yes(可以访问)

    注意:1)对于class的权限修饰只可以用public和default。

              2)类的成员(包括内部类)的修饰符可以是以上四种。

              3)类的成员不写访问修饰时默认为 default,默认对于同一个包中的其他类相当于公开 (public),对于不是同一个包中的其                 他类相当于私有(private)。

              4)受保护(protected)对子类 相当于公开,对不是同一包中的没有父子关系的类相当于私有。

    8.关键字float,double

    浮点类型:java浮点类型有固定的表数范围和字段长度,不受平台影响。

    java浮点型常量有两种表示形式

    1.十进制数形式,例如:3.14    41.0   .314

    2.科学计数法形式,如3.14e2   3.14E2   100E-2

    java浮点型常量默认为double,如果声明一个常量为float,则需在数字后面加f或F,如:

    double d=123.4; float f=12.3f;//不加f则出错,f必须加

    类型占用存储空间表数范围
    float4字节-3.403E38~3.403E38(小数点后有效位数7位)
    double8字节-1.798E308~1.798E308(小数点后有效位数15位)

    注意:浮点数在计算机中表示是离散的,有误差,在有效位数(精度)之后就不精确了,浮点数值不适用于禁止出现舍入误差的金融计算中。如果需要在数值计算中不含有任何舍入误差,就应该用BigDecimal类。

    9.关键字extends

    类的继承与权限控制(继承关系:能说通XX是XX就可以看作继承关系,比如,狗是动物)

    1)java中使用extends关键字实现类的继承机制,其语法规则为:<modifier>class<name>[extends<superclass>]{... ...}

    2)通过继承,子类自动拥有了父类(基类superclass)的所有成员(成员变量和方法)。

    3)java只支持单继承,不允许多继承(一个子类只能有一个基类,一个基类可以派生出多个子类)。

    释例:public class Student extends Person{}

    10.关键字import(引入):用于引入非同包类,同胞类不需要引入,直接用就可以。

         例:import oop.Birthday;  //引入oop包下的Birthday类

    11.关键字package

    package (包)例如:package  com.jd;

    1)为了便于管理大型软件系统中数目众多的类,解决类的命名冲突问题,java引入包(package)机制,提供类的多重类命名空  间。

    2)约定俗称的包起名方式:把公司的域名倒过来。如:package  com.jd;这个包包了两层(建包可不是只能建两层哈,别误会,只是这个例子中有两层),公司域名不是一样的,这样起名避免类名产生重复。

    3)package语句作为java源文件的第一条语句,指明该文件中定义的类所在的包。(若缺省该语句,则指定为无名包)。

    它的格式为package pkg1[.pkg2[.pkg3....]];

    4)java编译器把包对应于文件系统的目录管理,package语句中,用“.“来指明包(目录)的层次,例如package  com.jd;则该文件中所有的类位于.\com\jd 目录下

    5)class文件的最上层包的父目录应位于classpath下(在公司不同的项目一般设置不同的classpath)。

    6)要想执行一个类必须写全包名。如:java com.jd.TestPackage

    12.关键字static

    1)在类中,用static声明的成员变量为静态成员变量,它为该类的公用变量。在第一次使用时候被初始化,对于该类的所有对象来说,static成员变量只有一份。

    2)用static声明的方法为静态方法,在调用该方法时,不会将对象的引用传递给它,所以在static方法中不可访问非static的成员。(静态方法只能访问静态成员,因为非静态方法的调用要先创建对象,在调用静态方法时可能对象并没有被初始化)。

    3)可以通过对象引用或类名(不需要实例化)访问静态成员。

    4)static静态变量存在在data seg数据区,就算是不new它,它也会在data seg部分保留一份。静态变量是属于整个类的,它不属于某一个对象。  

    知识链接:字符串常量在内存中分配也是在data segment部分。

    /**
     * 说明:静态变量内存分析举例
     * 
     * @author huayu
     * @date 2018/8/3 
     */
    public class Cat {
        //静态成员变量,就算不new对象它也会在data seg里面保存一份,它属于整个类
        //不属于某个对象。int静态变量可以用来计数。
        //对静态值访问:1.任何一个对象通过对象的引用都可以访问这个静态对象,访问的时候都是同一块内存
        //2.即便是没有对象,也可以通过 类名. 来访问 如:System.out  out是个静态变量
    1.    private static  int sid=0;
        //非静态成员变量 new对象的时候在堆内存对象中保存,每new一个对象产生一块
    2.    private  String name;
        //非静态成员变量 new对象的时候在堆内存对象中保存,每new一个对象产生一块
    3.    private int id;
    
        public Cat(String name) {
    4.        this.name = name;
    5.        id=sid++;
        }
    
        public void info(){
    6.        System.out.println("My name is "+name+" No."+id);
        }
    
        public static void main(String[] args) {
            //静态变量sid属于整个Cat类,不属于某个对象,可以用类名.来访问,所以这儿没有new任何对 
            //象,直接用类名.(Cat.sid)来访问的。
    7.        Cat.sid=100;
            //字符串常量分配在data seg
    8.        Cat mimi=new Cat("mimi");
    9.        Cat pipi=new Cat("pipi");
    10.       mimi.info();
    11.       pipi.info();
    
        }
    }
    
    打印结果:
    My name is mimi No.id=100 sid= 102
    My name is pipi No.id=101 sid= 102
    

    执行完7Cat.sid时,静态变量sid值为100。内存分布状态如下:

    (1)执行第7句构造方法

    第一步:执行第7句Cat mimi=new Cat("mimi");字符串常量“mimi”分布在data segment部分,内存分布如下(这儿看不懂的再回去看以前我的java程序内存分析的博客):

    第二步:调到上面后就该到Cat的构造方法了,执行第4句this.name = name;这时根据传入构造方法的name形参,栈中就会为其开辟一块名为name的空间,实参“mimi”传了进来,这时候栈中name的引用指向了data segment中的字符串常量“mimi”,因为this.name = name,所以自身成员变量的this.name也指向了data segment中的字符串常量“mimi”。

    第三步:执行id=sid++;mimi对象的成员变量i值为原来sid的值100,接下来sid++,将sid的值改为101,内存状态如下图:

    第四步:构造方法执行完成后,为执行这个方法在栈中分配的形参变量的内存空间收回,name在栈中的空间消失(当然,为执行方法而在栈中分配的局部变量空间,方法执行完毕后都应该被收回了)

    (2)执行Cat pipi=new Cat("pipi"); 方法跟执行上面那个构造方法原理是一样的(当然,为执行方法而在栈中分配的局部变量空间,方法执行完毕后都应该被收回了),大家自己画一下,我这边把最后的内存分布状态给一下大家:

    从以上sid(static id)的变化不难看出,int的静态变量可以用作计数用。

    (3)将以上程序的static静态变量static int sid;再改为非静态变量 int sid;后做内存分析对比

    代码:

    /**
     * 说明:将上面代码静态变量改为非静态的再做内存分析
     *
     * @author huayu
     * @date 2018/8/3 下午6:32
     */
    public class Cat1 {
        //成员变量在new的时候才会在堆内分配
        private  int sid=0;
        private  String name;
        private int id;
    
        public Cat1(String name) {
            this.name = name;
            id=sid++;
        }
    
        public void info(){
            System.out.println("My name is "+name+" No.id="+id+" sid= "+sid);
        }
    
        public static void main(String[] args) {
    //        Cat1.sid=100;
            Cat1 mimi=new Cat1("mimi");
            Cat1 pipi=new Cat1("pipi");
            mimi.info();
            pipi.info();
    
        }
    }
    输出结果:
    My name is mimi No.id=0 sid= 1
    My name is pipi No.id=0 sid= 1

    对以上程序进行内存分析:这儿上面以前详细的讲过,大家亲自动手去画一画,感受了解一下静态变量跟非静态变量的区别,下面我给贴个最终状态的图(记得,为执行方法而在栈中分配的局部变量空间,最终方法执行完毕后都应该被收回了):

    从以上过程不难看出当静态变量static int sid;改为非静态变量int sid;后,每new一个对象,sid不再发生变化,故用它来计数是不可能了。

    13.this关键字

    1)在类的方法定义中使用this关键字代表代表使用该方法的对象的引用

    2)当必须指出当前使用方法的对象是谁时要用this。

    3)有时使用this可以处理方法中成员变量和参数重名的情况。

    4)this可以看作是一个变量,它的值是当前对象的引用。

    强调:this一般出现在方法里面,当这个方法还没调用的时候,this指的是谁并不知道,但是实际当中你如果new一个对象出来的话,this指的就是当前这个对象。你对那个方法调这个对象,那么this指的就是谁。

    /**
     * 说明:this用法举例
     *
     * @author huayu
     * @date 2018/8/3 下午5:39
     */
    public class Leaf {
        int i=0;
    
        public Leaf(int i) {
    1.        this.i = i;
        }
        public Leaf increament(){
    2.        i++;
    3.        return  this;
        }
        void print(){
    4.        System.out.println("i="+i);
        }
    
        public static void main(String[] args) {
    5.        Leaf leaf=new Leaf(100);
    6.        leaf.increament().increament().print();
        }
    }
    

    上面代码内存分析:

    第一步:通过执行main方法第5句,调到了Leaf类的构造方法Leaf(int i),这时栈空间为形参i开辟了一块内存,实参传入的值为100,又将栈内存中形参i的值赋值给了堆内存成员变量i,所以this.i=100。

    第二步:构造方法完成,为它分配的局部变量形参i消失。

    第三步:执行第6句leaf.increament().increament().print();  leaf.increament()执行leaf对象的increament()方法,执行i++;

    第四步:执行第3句return this;return会在栈空间分配一块临时的内存,这块空间是this的内容,而this指向它自身,所以这块临时内存也指向了对象leaf。leaf.increament()执行完成之后内存分布如下图:

    第五步:对leaf.increament()结果再调用increament()方法,即还是对原来的对象调用,执行完i++;后,成员变量i值变为102。

    第六步:再执行return this;return又会在栈空间分配一块临时的内存,这块空间是this的内容,而this指向它自身,所以这块临时内存也指向了对象leaf。

    第7步,调用完print()方法,整个方法执行完成后,栈中局部变量的内存空间回收。

    14.关键字super

    在java类中使用super来引用基类的成分;

    /**
     * 说明:super关键字引用父类成员演示,基类
     *
     * @author huayu
     * @date 2018/8/5 2:57 PM
     */
    public class Foo {
        public int value;
        public void f(){
            value=100;
            System.out.println("Foo.value="+value);
        }
    }
    
    /**
     * 说明:super关键字引用父类成员演示,子类
     *
     * @author huayu
     * @date 2018/8/5 2:58 PM
     */
    public class Coo extends Foo{
        public int value;
        public void fcoo(){
            //引用父类的f(0)方法
            super.f();
            value=200;
            System.out.println("Coo.value="+value);
            System.out.println(value);
            System.out.println(super.value);
        }
    }
    
    import oop.Coo;
    
    /**
     * 说明:测试方法继承
     *
     * @author huayu
     * @date 2018/8/5 3:05 PM
     */
    public class TestInherit {
        public static void main(String[] args) {
            Coo coo = new Coo();
            coo.fcoo();
        }
    }
    
    
    测试结果:
    Foo.value=100
    Coo.value=200
    200
    100
    

    内存分析图:

    把这个子类继承父类程序并子类调用父类成员的内存分配过程,这儿常出面试题:子类是怎么对父类的成员进行调用的。因为以前教过内存分析的具体过程,这儿我就只给了个最后的内存分布图,大家自己好好分析一遍。(当然,方法调用完,栈内为其分配的空间应被收回)。

    15.关键字:while

    while语句形式:while(逻辑表达式){语句;....;}

    执行过程:先判断逻辑表达式的值,若为true则执行其后面的语句,然后再次判断条件并反复执行,直到条件不成立为止

     

    更多讲解可看我以前的博客,java基础,面向对象那几部分。

     

    展开全文
  • Java关键字及其作用详解

    万次阅读 多人点赞 2019-04-07 18:52:36
    Java中的关键字有如下表格中这么多 下面分别解释一下每个关键字的含义。 private 一种访问控制方式:私用模式 protected 一种访问控制方式:保护模式 public 一种访问控制方式:共用模式 ...
  • java 关键字const const关键字最早是在javascript中作为ECMAScript 6标准的一部分于2015年引入的。它可能是在javascript中声明变量的最流行的方法,但是javascript在它们之前又是如何呢? 嗨,岩石,萨沙在这里。 ...
  • java关键字、保留字

    2018-09-09 14:14:18
    本文档包含了java所有的关键字以及一些说明,Java关键字java的编译器有特殊的意义,他们用来表示一种数据类型,或者表示程序的结构等。
  • Java关键字大全 doc 文档 ,学习必备,目前我看到的最好的关键字文档
  • Java关键字列表

    千次阅读 2019-10-01 00:48:48
  • Java 关键字及其作用(保留字)

    千次阅读 多人点赞 2019-02-22 18:45:07
    java关键字总览表: 除了上述关键字,Java还有以下保留字:true,false,null Java中的名称命名规范: 包名:多单词组成时所有字母都小写:xxxyyyzzz 类名、接口名:多单词组成时,所有单词的首字母大写:...
  • java关键字名单

    千次阅读 2019-07-11 09:10:00
    大家好,我是本周的带班编辑 子悠(这个月来的早了点),本周由于轮班小哥懿在出差,所以就由我为大家排版并送出技术干货,大家可以在公众号后台回复“java”,获得作者 Ja...
  • Java 关键字定位位置

    2018-06-26 11:20:18
    对pdf文件通过关键字输入匹配,找到该关键字的位置,对定位到该位置可进行处理.
  • java 关键字(面试题)

    2019-05-13 11:28:37
    学而时习之,温故而知新。 今天群里有人问java中true ...关键字 goto 和 const 是 C++ 保留的关键字,目前并没有在 Java 中使用到。如果它们出 现在 java 程序中,Java 编译器能够识别它们,并产生错误信息。 ...
  • java 关键字小结

    2018-03-21 16:03:59
    所以,Java虚拟机会在你初始化子类的时候默认的初始化子类的父类。 当上面程序执行main方法中的输出1时,控制台输出为 父类构造2this:nihao 子类构造2this:son test.KeyWordSonTest@79fc7299 由结果可以看到super...
  • Java关键字使用:private 关键字

    千次阅读 多人点赞 2020-03-16 10:17:43
    private关键字作用: 在这里不用官方的话来解释,说简单一点就是,当你设置了private 变量,你需要注意两点: 你可以对类中的属性进行更加精确、细化的限制 在类 → 对象实例化实现的时候要注意使用一对setter 和 ...
  • java关键字总结

    2020-12-22 15:22:09
    访问修饰符的关键字(共3个)  关键字  意思  备注,常用  public  公有的  可跨包,(默认选择)  protected  受保护的  当前包内可用  private  私有的  当前类可用  2).定义类、接口、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 765,432
精华内容 306,172
关键字:

java关键字

java 订阅