Java基础课程-Java语言基础

1. 本章内容

　　1. Java语言基础
　　2. 运算符、表达式
　　3. 流程控制

1.1 Java语言基础

1.1.1 标识符

1. 什么是标识符？
   
   • Java语言中，为各种变量、方法和类等起的名字称为标识符
2. 标识符的命名规则
   
   • 标识符应以字母、下划线、美元符$开头，不能以数字开头,汉字也可以通过编译(不推荐)
     
   • 标识符可以由字母、下划线、美元符或数字组合而成。在实际编程时，在命名标识符时，应该使其在一定程度上反映它所表示的变量、常量、类名和对象名的实际意义
   • Java标识符大小写敏感，长度无限制
   • 系统的关键字（又叫保留字）不能作为标识符

1.1.2 关键字

1. 概念
   
   • Java语言将一些特定的单词（或字符序列）保留做专门用途，这些单词或字符序列被称为关键字（Keyword）或保留字（Reserved Word）

2. 注意事项

   • goto和const虽未起任何作用，但为避免无用也被作为关键字保留下来
   • true和false虽不是关键字，但也已被用作专门用途，因此不可做标识符使用
   • Java关键字都是小写

3. Java中的关键字如下图所示
   

1.1.3 分隔符

1. 分隔符的组成
   
   • 分号 “;”
   • 花括号 {}
   • 空格 ” ”
     备注:都是英文状态下的符号！
2. 分隔符的作用
   
   • Java允许用花括号“{}”将一组语句括起来，形成一个语句块(block)
   • Java程序源代码中各组成部分之间可以插入任意数量的空格，包括换行
   • 分号语句结束
3. 注意
   
   • 在定义类时，类体必须采用语句块形式
   • 在定义方法时，方法体必须采用语句块的形式
   • 在定义循环语句时，循环体可以语句块的形式，采用将0~多条语句集合到一起，作为一个整体进行处理
   • 语句块可以嵌套，嵌套层数无限制，以实现较复杂的功能

代码示例1：语句块

    public int getInt(){
        return 1  ;
    }
    {  }//语句块
    {  }//语句块

1.1.4 注释

1. 概念
   
   • 是对源程序起解释说明作用的文本信息，适当的使用注释可以增强程序代码的可读性和可维护性
2. 格式
   
   • 以 // 开头，注释内容从 // 开始到本行行尾结束

代码示例1：

    int i //定义变量

• 以 /* 开头，直到遇到 */ 结束，注释内容可以跨行，适用于内容较长的注释

代码示例2：

    /*
    public void getData(){
    System.out.println("Hello chj！");
    }
   */

• 以 /* 开头，直到遇到 / 结束，注释内容可以跨行。使用JDK中提供的文档化工具javadoc可以将这种注释的内容提取出来自动生成软件说明(比如作者、创建时间、方法参数、方法的返回值等)

代码示例3：

 /** 
 *@author change 
 *
 */
public class VarDemo {

   /**
    * 
    * @param args
    */
  public static void main(String[] args) {

  }
}

备注:请参考:集成开发工具Eclipse IDE设置注释模板文档，进行修改注释模板操作。

1.1.5 数据类型

数据类型在数据结构中的定义是一个值的集合以及定义在这个值集上的一组操作。
变量是用来存储值的所在处，它们有名字和数据类型。变量的数据类型决定了如何将代表这些值的位存储到计算机的内存中。在声明变量时也可指定它的数据类型。所有变量都具有数据类型，以决定能够存储哪种数据。

1.数据类型的分类

1. 将数据按数据性质进行分类，每一类称为一种数据类型（datatype）。数据类型定义了数据的性质、取值范围、存储方式以及对数据所能进行的运算和操作。
2. 数据类型：
   

2.基本数据类型

1. 概念
   基本数据类型是Java语言中预定的、长度固定的、不能再分的类型，数据类型的名字都被当做关键字保留，并且都是小写。
   
   特殊说明:
   boolean:类型只有true和false
   char:表示16位Unicode字符;字符的字面值使用单引号(”)引起;例如:’A’、’\n’ 换行、’\t’制表符、’\u03a6’希腊字母Φ
   代码示例1:基本数据类型案例

               byte b=1;
               short s=1;
               int i =1;
               long l=1;
               float f=1;
               double d=1;
               char c=65;
               System.out.println(b);
               System.out.println(s);
               System.out.println(i);
               System.out.println(l);
               System.out.println(f);
               System.out.println(d);
               System.out.println(c);
   

3.类型转换

1. 划分
   
   • 自动类型转换
   • 强制类型转换

2. 自动类型转换

   • 概念：从低数据类型向高数据类型转换

   • 关于java自动类型的转换有这样一个形象的比喻，当一个小的容器的水换到一个大的容器中毫无问题，但是一个大的容器的水换成小的容器则会装不下，就会溢出。
     
     代码示例1:自动类型转换案例

     //也就是说byte类型的变量可以自动转换为short类型，示例代码：
     byte b = 10;
     short sh = b;
     //这里在赋值时，JVM首先将b的值转换为short类型，然后再赋值给sh
     int i=1;
     double d=1;
     System.out.println(i+d);
     //输出结果为:2.0
     //在计算i+d时，i自动转化为double类型进行计算

注意：自动转换是程序在执行过程中“悄然”进行的转换，不需要用户提前声明，一般是从位数低的类型向位数高的类型转换；强制类型转换则必须在代码中声明，转换顺序不受限制.
3. 强制类型转换
对于基本数据类型简单说:就是把占用高字节位的类型转换低位字节类型.
对于引用类型简单地说:就是把父类型转换为子类型。因为子类型比父类型的内涵要丰富，无非就是属性更多功能更强，所以要把父类型转换为子类型，需要强制，所以叫强制类型转换

代码示例2：强制类型转换案例

    long l=100; //高字节位的类型
    int ll=(int)l;//转换成低字节位的类型
    Person p = new Person();//父类对象
    Student stu = (Student)p; //把父类对象强制转换成子类对象
    String s="123";
    int i=Integer.valueOf(s); //类型转换的方法

    //解释一下代码
    byte a = 1;  //1行
    byte b = 2;  //2行
    byte c = (byte) (a + b);
    float a1 = 0.1f;
    float b1 = 0.2f;
    float c1 = a1 + b1; //6行

    System.out.println(c);
    System.out.println(c1);

备注思考:
（1）java中为什么要有整数默认为int类型，浮点数默认为double类型的设定？如上面的例子第3行 如果不加强制转换（byte）（..） 编译是会报错 需要byte 实际为int。1、2行中已经定义a b为byte类型了，在第三行中又做默认的int类型处理。
（2）而第6行中为什么a1和b1又不做为默认的double类型处理而报错了。是否和0.1f 0.2f的写法有关？

扩展:

 short s1 = 1; s1 = s1 + 1;//有什么错? 

1.1.6 编码惯例

1.作用

• 程序设计的标准化非常重要,有利于程序的可读性，便于以后的维护。

2 常用命名惯例

1. 包名
   包名一般小写

     package banking;
     package com.oristand.college;
   

2. 类名
   类名一般使用（动）名词或（动）名词组合来表示，并且各个名词的首字母大写，其他字母小写

     class Student{}
     class RegisteringStudent{}
   

3. 接口名
   接口的命名规则与类的命名规则一致，一般也是用（动）名词或（动）名词组合来表示，并且各个名词的首字母大写，其他字母小写

     interface Person;
   

4. 方法名
   方法一般用一个动宾短语组成，表示一个动作。方法的首字母小写（通常是动词的首字母），而其他单词的首字母大写（通常是一个名词的首字母）

     public void balanceAccount(){... ...}
   

5. 变量名
   变量的名称一般使用一个（动）名词或其组合来表示，并且首字母小写，其他单词的首字母大写，而其他字母小写

     private int age;
     private String studentName;
   

6. 常量名
   常量用于表示一个不能改变值的“变量”，通常，常量由形容词+名词组成，所有单词都大写，各个单词间用下划线”_”来分割

     static final int MAX_SIZE=12;
   

7. 数组名
   虽然数组可以用两种命名方式，但是为了直观起见，一般使用第一种方式

     String[] args; 
     String args[];
   

1.2 运算符、表达式

1.2.1 运算符

1.基本概念

1. 运算符:用于标记对数据执行某种运算的特定符号
2. 操作数：参加运算的数据称为运算对象（操作数）
3. 分类
   
   • 按照运算符功能划分为：算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符等
   • 按照参与运算的操作数划分为：单目运算符、双目运算符、三目运算符

2.算数运算符

1. 整数型运算（int型）
   对于int型的相关操作，加、减、乘的结果都是非常容易理解的，重点讲一下除（/）的运算。
   两个整数相除的结果是整数，这一点与数学中是不同的，在Java中，两个整数相除的结果类似于数学中的求模运算。整除的余数是用%表示，例如15 / 2 = 7，而不是7.5，15 % 2 = 1。

代码示例1:算数运算符案例

    public class Divide{
        public static void main(String[] args){
        int a = 15;
        int b = 2;
        double c = 2;
        System.out.println(a + "/" + b + "=" + (a / b));
        System.out.println(a + "%"+ b + "=" + (a % b));
        System.out.println(a + "/" + c + "=" + (a / c));
        System.out.println(a + "%" + c + "=" + (a % c));
        }
    }

输出结果：

     15 / 2 = 7  
     15 % 2 = 1  
     15 / 2.0  =  7.5  
     15 % 2.0 = 1.0  

扩展1:

        复习sql语句
        1.select count(*) as c from user;//总计记录数(复习sql语句)
        2.select * from user limit 0,3;//第一页数据
        3.设定每页显示的数量3；
        写出根据当前页计算出每页开始的记录数和每页结束的记录数.

1. 自增和自减运算符
   在循环与控制中，我们经常会用到类似于计数器的运算，它们的特征是每次的操作都是加1或减1.在Java中提供了自增、自减运算符，X++使变量X的当前值每次增加1，而X–是自减运算符，每次操作使当前X的值减1。

代码示例2: 自增和自减运算符案例

    int a=5;

    System.out.println(a++);
    System.out.println(++a);

    System.out.println(a--);
    System.out.println(--a);

扩展1:

    public class Inc{
       void fermin(int i){
          i++;
        }
       public static void main(String[] args) {
          Inc inc = new Inc();
          int i=0;
          inc.fermin(i);
          i=i++;
         System.out.println(i);
       }
    }

扩展2：

       x=x+1;x+=1;x++;那个效率高？为啥?

1. 数字精度
   所谓数字精度，也就是系统在做数字之间的算术运算时，为了尽最大可能地保持计算机的准确性，而自动进行相应的转换，将不同的数据类型转变为精度最高的数据类型。

代码示例3：数字精度案例

    int i=1; //int类型
    double d=1.1; //double类型
    double result;
    result=i+d; //计算的结果就是double类型
    System.out.println(result);

输出：

   2.1

3.关系运算符

Java具有完美的关系运算符。这些关系运算符基本上同数学中的关系运算符是一致的。“>”大于、“<”小于、“>=”大于等于、“<=”小于等于、“==”等于、“!=”不等于。

代码示例1：关系运算符案例

    public class RelationTest{
        public static void main(String[] args){
            boolean x, y, z;
            int a = 15;
            int b = 2;
            double c =15;
            x = a > b;  //true;
            y = a < b;  //false;
            z = a != b;  //true;
            System.out.println("x =" + x);
            System.out.println("y =" + y);
            System.out.println("z =" + z);
        }   
    }

输出结果：

     x = true  
     y = false  
     z = true  

4.逻辑运算符

在Java语言中有三种逻辑运算符，它们是NOT（非，以符号“!”表示）、AND（与，以符号“&&”表示、）OR（或，以符号“||”表示）。

1. NOT运算符
   NOT运算符是用来表示相反的意思。
   
   代码示例1：！案例

   boolean A=true;
   System.out.println(A);
   System.out.println(!A);
   

2. AND运算符
   AND运算符表示“与”的意思，也就是和的意思。
   
   代码示例2：&&案例

   boolean A=true;
   boolean B=false;
   System.out.println(A&&B);
   

3. OR运算符
   OR运算符是用来表示“或”就像我们日常生活中理解的一样，两者只要有一个为“真”，结果就为“真”。
   
   代码示例3：||案例

   boolean A=true;
   boolean B=false;
   System.out.println(A||B);
   

4. 短路现象
   在运用逻辑运算符进行相关的操作时，我们会遇到一种很有趣的现象；短路现象。
   对于false && true根据我们的讲述，处理的结果已经是false了，也就是说无论后面是结果是“真”还是“假”，整个语句的结果肯定是false了，所以系统就认为已经没有必要再进行比较下去了。也就不会再执行了，这种理象就是我们所说的短路现象。

代码示例4：短路现象案例

    int a=3;
    int b=5;
    if(a>5&&b>0){
           System.out.println("Hello World");
    }

备注:当程序进行到a>5时，已经判断为false,所以系统就认为已经没有必要再执行后面的b>0。无输出

5.位运算符

所有的数据、信息在计算机中都是以二进制形式存在的。我们可以对整数的二进制位进行相关的操作。这就是按位运算符，它主要包括：位的“与”、位的“或”、位的“非”、位的“异或”。
1. 位的“与”，用符号“&”表示，它属于二元运算符。

2. 位的“或”用符号“|”表示，它属于二元运算符。

3. 位的“非”，用符号“~”表示，它是一元运算符，只对单个自变量起作用。它的作用是使二进制按位“取反”

4. 位的“异或”，用符号“^”表示，它属于二元运算符。

代码示例1:位运算符案例

 int a=1; //把a改成3 b改成4 让学生计算各个结果
 int b=0;
 System.out.println(a&b);
 System.out.println(a|b);
 System.out.println(~a);
 System.out.println(a^b);

备注:参考关于原码、反码、补码的详解

6.复合的赋值运算符

复习赋值运算符:
赋值运算符是程序中最常用的运算符了，只要有变量的声明，就要有赋值运算。如a = 3；这里的a我们都知道是变量名，根据前面对变量的定义，我们可以知道这里的a实际上就是内存空间的一个名字，它对应的是一段内存空间，一在要在这个空间放入3这个值。这个放入的过程就实现了赋值的过程。
下面我看一下常见的复合的赋值运算符:

代码示例1:-=案例

  short value=2;
  value-=2; //严格说明:value-=2;  等价于 value=(value 的类型) (value-2);
  System.out.println(value);

代码示例2:类型转换bug案例与-=案例对比

  short value=2;
  value=value-2; //出现bug
  System.out.println(value);

备注:在复合赋值运算当中，会自动将他计算的结果值强制类型转换为左侧的类型,当然结果和左侧类型相同的时候就不会有任何的影响

扩展1：精度溢出案例

    byte value=2;
    //系统自动隐身的类型转换
    value+=129;//从高位截断，发生了溢出，结果不是你想要的
    System.out.println(value);

备注:1.如果左边的类型要比计算结果的那个类型范围要小？肯定会丧失精确;
2.思考结果怎么计算出来的?

7.三目条件运算符

• 语法格式

  x?y:z
  

• 其中x为boolean类型表达式，先计算x的值，若为true，则整个运算结果为表达式y的值,否则为z

代码示例1:三目运算符案例

    int a=6;
    int b=3;
    String whoBig=a>b?"a大":"b大";
    System.out.println(whoBig);

8.instanceof

该运算符是双目运算符，左面的操作元是一个对象，右面是一个类或接口。当左面的对象是右面的类(或右边类的子孙类)创建的对象、或者是右边接口的实现类(或实现类的子孙类)的对象时，该运算符运算结果是true，否则是false.
备注:讲继承和接口的时候详细讲解.

9.运算符优先级

代码示例1：优先级案例

    System.out.println(5<3||4>3);//true
    System.out.println(5-3|5-2);//3

代码示例2:优先级案例

 int x=2,y=2;
 x *= y+8;
 System.out.println(x); //输出x的结果

1.2.2 表达式

表达式（expression）是由若干操作数（operand）和运算符（operator）按照约定规则构成的一个序列.

• 运算符标明对操作数进行何种操作；
• 操作数可以是变量、常量或有返回值的方法调用等其他的表达式

表达式的类型和值

• 对表达式中操作数进行运算得到的结果称为表达式的值
• 表达式的值的数据类型即为表达式的类型

表达式的运算顺序

• 首先应按照运算符的优先级从高到低的顺序进行
• 优先级相同的运算符按照事先约定的结合方向进行

1.3 流程控制

1.3.1 分类

1. 顺序结构
2. 选择结构
3. 循环结构

1.3.2 顺序结构

1. 是程序中最简单的基本流程控制，没有特定的语法结构，按照先后顺序，依次执行。总的来说就是前面的先执行，后面的后执行。

代码示例1:顺序执行案例

    System.out.println("Hello World"+1);
    System.out.println("Hello World"+2);
    System.out.println("Hello World"+3);
    System.out.println("Hello World"+4);
    System.out.println("Hello World"+5);

代码示例2：方法调用执行顺序案例

      public static void main(String[] args) {
               log1();
               log2();
               log3();
      }

      private static void log3() {
                System.out.println("log3");
      }

      private static void log2() {
                System.out.println("log2");
      }

      private static void log1(){
                System.out.println("log1");
      }

代码示例3：方法调用执行顺序案例

      public static void main(String[] args) {
               log1();
      }

      private static void log3() {
                System.out.println("log3");
      }

      private static void log2() {
                log3();
                System.out.println("log2");
      }

      private static void log1(){
                log2();
                System.out.println("log1");
      }

备注:查看三个例题的输出结果,加强断点调试的讲解说明.关于断点调试，请参考断点调试详解.

1.3.3 选择结构

1. if选择结构

if条件结构是根据条件判断之后再做处理的一种语法结构。语法如下:

    if(条件){
        //代码
    }

**代码示例1：**boolean类型案例

    boolean flag=true;
    if(flag){
        System.out.println("Hello World");
    }

备注:if后小括号里的条件必须是一个布尔表达式,即表达式值必须为布尔值true或false

代码示例2:表达式判断

    //声明条件
    int a=10;
    //判断
    if(a<11)
        System.out.println("条件为真");
    System.out.println("我执行了吗");  

代码示例3:表达式判断

   //声明条件
    int a=10;
    //判断
    if(a>11)
        System.out.println("条件为真");
    System.out.println("我执行了吗");

备注:讲解例2与例3程序的执行过程。

2. if-else选择结构

if-else选择结构除了要实现条件成立执行的操作,同时还要实现条件不成立时执行的操作。语法如下：

    if(条件){
        //代码
    }else{
        //代码
    }

代码示例1:数字判断

 int a=10;
 int b=16;   
 if(a>b){
     System.out.println("a大于b");
 }else{
     System.out.println("a小于b");
 }

3. if-else if-else选择结构

多重if选择结构在解决需要判断的条件是连续的区间时有很大的优势。语法如下

    if (条件1) {
        //代码1
    }else if (条件2) {
        //代码2
    }else{
        //代码3
    }

代码示例1：数字判断

    int a=10;
    int b=10;
    if(a>b){
        System.out.println("a大于b");
    }else if(a==b){
        System.out.println("a等于b");
    }else{
        System.out.println("a小于b");
    }

案例1.1：成绩判断

    //成绩60分
    int score=80;

    if(score>90){
        System.out.println("成绩优秀");
    }else if(score>70){
        System.out.println("成绩优良");
    }else if(score>60){
        System.out.println("成绩合格学生");
    }else{
        System.out.println("成绩不合格学生");
    }

备注:加深选择结构的理解

4. 嵌套if选择结构

嵌套if选择结构就是在if里面再嵌入if选择结构。语法如下：

    if(条件1){
        if(条件2){
            //代码1
        }else{
            //代码2
        }
     }else{
        //代码3
     }

案例1.2：成绩判断

    //成绩60分
    int score=80;
    //判断成绩是否大于60
    if(score>60){
        //在大于60的基础上，再进行判断成绩是否大于90，是否大于70.
        if(score>90){
            System.out.println("成绩优秀");
        }else if(score>70){
            System.out.println("成绩优良");
        }else{
            System.out.println("成绩合格");
        }
    }else{
        System.out.println("成绩不合格学生");
    }

5. switch选择结构

当分支结构的条件是等值的时候，可以使用switch结构，从而使代码简洁，减少重复操作。语法如下

案例2.1：数字实现季节判断

    //假设用数字1代表春天、数字2代表夏天、数字3代表秋天、数字4代表冬天
    int season=3;
    //判断季节
    switch(season){
    case 1:
        System.out.println("春天");
        break;
    case 2:
        System.out.println("夏天");
        break;
    case 3:
        System.out.println("秋天");
        break;
    case 4:
        System.out.println("冬天");
        break;
    default:
        System.out.println("不是季节");
    }

备注:把season的类型改成byte、short、char、long分别测试讲解.
改成long之后的bug提示：
Only convertible int values, strings or enum variables are permitted
注意:swtich（）里面必须是int和enum–即枚举类型,short、 char 或者 byte他会自动转换为int,long不能自动转换为int,因为long比int范围大

案例2.2:字符串实现判断季节

   //假设用字符串1代表春天、字符串2代表夏天、字符串3代表秋天、字符串4代表冬天
    String season="3";
    //判断季节
    switch(season){
    case "1":
        System.out.println("春天");
        break;
    case "2":
        System.out.println("夏天");
        break;
    case "3":
        System.out.println("秋天");
        break;
    case "4":
        System.out.println("冬天");
        break;
    default:
        System.out.println("不是季节");
    }

注意:java1.6和之前版本的switch是不支持String类型的，只支持int，char，byte，short几种类型，1.7的版本才支持String类型。
案例2.3：枚举实现判断季节

//定义枚举
public enum Season {
    SPRING,SUMMER,AUTUMN,WINTER
}

//测试枚举
public class SwitchDemo {

public static void main(String[] args) {

    //获取枚举中的值
    Season season =Season.SPRING;
    //判断
    switch(season){
    case SPRING:
        System.out.println("春天");
        break;
    case SUMMER:
        System.out.println("夏天");
        break;
    case AUTUMN:
        System.out.println("秋天");
        break;
    case WINTER:
        System.out.println("冬天");
        break;
    default:
        System.out.println("不是季节");
    }

  }
}

1.3.4 循环结构

1.分类

1. for循环
2. while循环
3. do/while循环

2.for循环

语法：

    for(表达式1;表达式2;表达式3){
        //循环体
    }

循环执行过程：

    for(1初始部分;2条件判断;4改变循环变量值){
        3循环操作
    }
    - 第一步初始部分
    - 第二部条件判断（条件为真）
    - 第三步循环操作，循环体被执行
    - 第四步循环变量值被改变

常见错误：省略了①在for前加上;省略了①在for里面加if条件;省略了④在for里面最后加上;省略了两个分号语法会编译出错,缺一不可

代码示例1:重复输出”当你不敢面对失败的时候，你就是个失败者！” 100次

    for(int i=0;i<100;i++){
        System.out.println("当你不敢面对失败的时候，你就是个失败者!")
    }

**代码示例2：**1到100的和

   //定义变量
    int sum = 0;
    //for循环
    for (int i = 0; i <= 100; i++) {
        //求和
        sum += i;
    }
    //输出结果
    System.out.println(sum);

3.嵌套for循环

语法:

    for(初始值1;条件判断1;循环体变量1){
        for(初始值2;条件判断2;循环体变量2){
            ...
        }
    }

内层for为外层for循环体。执行完内层for后，再返回外层for执行下一层迭代。
案例3:计算1到10的数字的因数

    for(int i=1;i<=10;i++){
          System.out.println("数字"+i+"的因数有:");
          for(int j=1;j<=i;j++){
                if(i%j==0){
                    System.out.println(j);
                }
          }
    }

4.while循环

特点：先判断，再执行
语法：

    while(循环条件) {
        循环操作
    }    

**代码示例1：**1到10求和

    int i=1;
    while(i<=10){
        System.out.println(i);
        i+=1;
    }

5.do/while循环

特点：先执行，再判断
语法：

    do {
        //循环操作
    } while (循环条件);    

**代码示例1：**1到10求和

    int i=0;
    do{
        i+=1;
        System.out.println(i);
    }while(i<10);

代码示例2：演示先执行，再判断的特性

    //声明变量
    int i=0;
    do{
        System.out.println(i);
        i++; //递增
    }while(i>2);

    System.out.println(i);

6.跳转语句

1. break语句的使用
   break语句用于终止某个循环,使程序跳到循环块外的下一条语句.在循环中位于break后的语句将不再执行,循环也停止执行
   案例4：循环求和，当总数大于20时结束

   int sum=0;
   for(int i=0;i<100;i++){
             sum+=i;
             if(sum>20){
                  System.out.println(sum);
                  break;
             }
   }
   

2. continue语句的使用
   continue 可以用于for循环,也可以用于while和do-while循环.在for循环中, continue 使程序先跳转到迭代部分,然后判断循环条件.如果为true,继续下一次循环;否则终止循环.在while循环中, continue 执行完毕后,程序将直接判断循环条件. continue 语句只能用在循环结构中
   案例5：输出10以内的双数

   for(int i=1;i<=10;i++){
        if(i%2!=0){
            continue;
        }
        System.out.println(i);
   }
   

以上都是个人整理资料部分，有问题欢迎大家留言！如需转载，请注明出处！