Bootstrap

Java入门的基础学习

Java的基础语法知识


前言

Java 语言最初由 Sun Microsystems 公司的 James Gosling(Java之父） 和他的团队在 1991 年开始开发，当时名为 Oak，目的是用于嵌入式设备编程。但由于 Oak 名称已被注册，1995 年正式更名为 Java。2006 年，Sun 公司将 Java 开源，进一步推动了其发展。2010 年，Oracle 公司收购 Sun，Java 的开发和维护权也随之转移到 Oracle。
java最新版本网站

一 初始Java

我们先来了解java的第一个第一个代码,打印出hello world
在这里插入图片描述

public class test {
    public static void main(String[] args) {
        System.out.println("hello world");
    }
}

输出结果如下
在这里插入图片描述
源⽂件（扩展名为*.java)：源⽂件带有类的定义。类⽤来表⽰程序的⼀个组件，⼩程序或许只会有⼀个类。类的内容必须包含在花括号⾥⾯。
类：类中带有⼀个或多个⽅法。⽅法必须在类的内部声明。
⽅法：在⽅法的花括号中编写⽅法应该执⾏的语句。
分析我们第一个代码
在这里插入图片描述
可以看出Java的main函数和打印函数都比较长
当然这个都是快捷键的
我们的main方法直接输入main + 按一下ENTER回车键就可以直接出来
输出的话我们直接输入sout + 按一下ENTER回车键就可以直接出来
这样的话我们在编写代码时间会大大降低
下面我们介绍Java的数据类型

二 Java数据类型和变量

1.字面常量

上面我们输出hello world的的程序中System.out.println(“hello world”)；
这里输出中"hello world"就是字面常量。
常量就是在运行期间，无法改变的量

public class test {
    public static void main(String[] args) {
        System.out.println("hello world");
        System.out.println(100);
        System.out.println(3.14);
        System.out.println('a');
        System.out.println(true);
        System.out.println(false);
    }
}

在这里插入图片描述

1.字符串常量：必须要用 " " 括起来的，⽐如"12345"、"hello"等。
2. 整型常量：程序中直接写的数字，⽐如：10，20
3. 浮点数常量：程序中直接写的⼩数，⽐如：3.14、5.21
4. 字符常量：由单引号括起来的当个字符，⽐如：‘A’、'C'
5. 布尔常量：只有两种true和false
等等

上面的字符串、整型、浮点型、字符型以及布尔型，在Java中都是数据类型

2.数据类型

Java有自己的数据类型，主要分为基本数据类型和引用数据类型

基本数据类型

基本数据类型，主要分四类：整型、浮点型、字符型和布尔类型
八种类型：

数据类型关键字占用空间范围
字节型byte1个字节-128~ 127
整型int4个字节-2^31 ~ 2^31-1
短整型short2个字节-32768 ~ 32767
长整型long8个字节-2^63 ~ 2^63-1
单精度浮点型float4个字节一般不关注
双精度浮点型double8个字节一般不关注
字符型char2个字节0 ~ 65535
布尔类型boolean没有明确规定true和false

这里的浮点型数字在存储的时候比较复杂，所以我们不关注
整型默认为int型，浮点型默认为double

引用数据类型

在Java中字符串就是引用数据类型，那在Java中字符串如何定义呢
需要使用String来定义，注意这里的S是大写

public class test {
    public static void main(String[] args) {
        String str = "hello world";
        System.out.println(str);
    }
}

输出结果如下
在这里插入图片描述

3.变量

除了常量以为，也有变量，就像生活中的温度，体重等等会变化的量，在Java中这些被称为变量

数据类型    变量名    =    初始化；

例如：

public class test{
    public static void main(String[] args) {
        int a = 10;
        a=100;//修改数值
        char ch = 'c';
        double c = 3.14;
        boolean d = true;
        //输出，快捷键sout
        System.out.println(a);
        System.out.println(ch);
        System.out.println(c);
        System.out.println(d);
    }
}

运行结果
在这里插入图片描述

整型变量

int整形

public class test{
    public static void main(String[] args) {
        int a = 10;
        a = 100;
        System.out.println(a);
        //int 数据的范围
        //-2147483648 - 2147483647
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);
}

在这里插入图片描述
这里打印出了int类型所能存储数据的范围，我们在初始化时候不能超过其范围
int 类型占4个字节
变量在使⽤之前必须要赋初值，否则编译报错
int的包装类型为Integer

short和long类型

public class test{
    public static void main(String[] args) {
        long a = 10l;//我们同长在后面加上l，
        //long类型
        System.out.println(a);
        //-9223372036854775808 - 9223372036854775807
        System.out.println(Long.MIN_VALUE);
        System.out.println(Long.MAX_VALUE);
        short b = 20;
        //short类型
        System.out.println(b);
        //-32768 - 32767
        System.out.println(Short.MIN_VALUE);
        System.out.println(Short.MAX_VALUE);

    }
}

在这里插入图片描述

短整型short 占2个字节，长整型long占8个字节
short范围-32768~32767  long范围 -2^63~(2^63)-1
short包装类型为Short  long包装类型为Long
我们在创建long类型变量时候通常需要在变量后加上l或者L

浮点型变量

单精度浮点型和双精度浮点型

public class test {
    public static void main(String[] args) {
        //浮点型数据
        //浮点型默认是double类型
        double d = 1.2;
        //创建float类型时候，必须在数据后面加上f
        float c = 1.4f;
        //float a = 1.2;这个是错误的
        System.out.println(d);
        System.out.println(c);
        System.out.println(Float.MIN_VALUE);
        System.out.println(Float.MAX_VALUE);
    }
}

运行结果如下
在这里插入图片描述
这里float 类型的数据后面没有加f，直接报错了
在这里插入图片描述

double占8个字节，float占4个字节
浮点数与整数在内存中的存储⽅式不同，不能单纯使⽤的形式来计算
double的包装类型为Double，float的包装类型为Float
我们创建浮点型数据是默认为double的，如果需要创建float类型数据，需要在后面加上f
我们一般优先使用double，因为float对应的范围精度较小

字符型变量

字节型和字符型

public class test {
    public static void main(String[] args) {
        byte a =3;
        System.out.println(a);
        System.out.println(Byte.MIN_VALUE);
        System.out.println(Byte.MAX_VALUE);
       //字符类型
        char c1='C';
        char c2='L';
        System.out.println(c1);
        System.out.println(c2);
        //这里的字符是占两个字节
        char c3 = '三';
        //我们知道汉字是占两个字节，我们使用char来存储汉字并没有出错
        //并且还是可以打印的
        //所以char是占两个字符
        System.out.println(c3);
        }
}

我们使用了一个汉字在存储时候占2个字节，所以这里没有报错，可以知道char在Java中占2个字节
在这里插入图片描述

byte在任何系统下都占1个字节,char在任何系统下都占2个字节
byte的范围是：-128~127，char的范围为：0 ~ 65535
byte的包装类型为Byte，char的包装类型为Character

布尔型变量

我们生活中有真假的存在，Java中也存在这种数据类型就是boolean类型

public class test {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        //boolean c = 1;//这会直接报错
        System.out.println(a);
        System.out.println(b);
    }
}

运行结果如下
在这里插入图片描述

boolean类型只有true表示真 和 false表示假 这两种结果
不存在1为真 ，0 为假的情况，因为int和boolean两种类型不能相互转化

就像下面这个代码是错误的
int和boolean不能进行转化
在这里插入图片描述

4.类型转化和提升

类型转化

自动类型转化
自动类型转化就是在编译器编译代码时候会自动处理，两个不同类型的数进行计算会自动将小范围向大范围转化，不会自动向小范围转化。

public class test {
    public static void main(String[] args) {
        int a = 10;
        long b = 20;
        b = a;
        //nt-->long，数据范围由⼩到⼤，隐式转换
        //a = b;//错误的，不可以long - int 转换
        //只能小转化为大
        System.out.println(b);
        }
}

这里我们在进行赋值的时候 int 转化为了 long 进行赋值
但是我们不可以long 向 int 类型转化，大范围不可以自动转化为小范围
就像下面是编译的时候会出错
在这里插入图片描述
强制类型转化
自动类型转化不可以小范围转化为大范围，而强制类型转化，可以将大范围转化为小范围

public class test {
    public static void main(String[] args) {
        int a = 10;
        long b = 100L;
        b = a; // int-->long，数据范围由⼩到⼤，自动类型转化
        a = (int)b; // long-->int, 数据范围由⼤到⼩，需要强制类型转化，否则编译失败
        float f = 3.14F;
        double d = 5.21;
        d = f; // float-->double，数据范围由⼩到⼤，自动类型转化
        f = (float)d; // double-->float, 数据范围由⼤到⼩，需要强制类型转化，否则编译失败
        byte b1 = 100; // 100默认为int，没有超过byte范围，自动类型转化
        byte b2 = (byte)257; // 257默认为int，超过byte范围，需要显⽰转换，否则报错
        }
}

自动类型转化在进行赋值的时候，可将小范围的数赋值给大范围的
强制类型转化通常用于，将大范围转化为小范围，但这可能会有数据的丢失
强制类型转化不一定成功，两个毫不相干的两个数不能相互转化

类型提升

int 和 long 之间的提升

public class test {
    public static void main(String[] args) {
        int a = 10;
        long b = 20;
        //int e=c+d;//这样是错误的
        //在进行运算的时候，会转化为类型较大的那一个
        long e = c+d;
        System.out.println(e);
        }
}

在这里插入图片描述
这里可以用long类型的数据来接收，这两个整数的相加，但是不可以用int 类型的数据来接收，除非强制类型转化
不同类型的数据混合运算,范围⼩的会提升成范围⼤的

byte的提升

public class test {
    public static void main(String[] args) {
        byte a = 1;
        byte b = 2;
        //byte c =a+b;//错误
        int d = a + b;
        byte c = (byte)(a+b);//但不可以超过范围
        System.out.println(c);
        System.out.println(d);
        }
}

在这里插入图片描述
这里的byte的运算不可以简单认为这两个字节运算结果还是byte字节，这两个数在进行运算的时候，会先将a和b转化为int类型在进行运算。
因为我们的计算机在存储时候，是4个字节存储的，所以低于4个字节的像short和byte低于4个字节的类型,会先提升成int,再参与计算。

三 运算符

1.算数运算符

基本的四种运算符：加减乘除取模（+ - * / %)

public class test {
    public static void main(String[] args) {
        int a = 20;
        int b = 10;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);
        System.out.println(a%b);
    }
}

在这里插入图片描述
这里我们知道这里的所有都是二元操作符，都是必须需要两个操作数
这里我们的int / int的结果还是int类型

/ 和 %运算符只有操作数中有浮点数结果才会是浮点数，否则结果就只能是整数，可能会导致数据的丢失
但我们的%运算符通常使用整数

public class test {
    public static void main(String[] args) {
        int a = 3;
        int b = 2;
        double c = 2.0;
        System.out.println(a/b);
        System.out.println(a/c);
        System.out.println(a%b);
        System.out.println(a%c);
        }
}

在这里插入图片描述
做除法和取模时，右操作数不能为0
如果右操作数为0的话，编译器会报错
在这里插入图片描述
增量运算符+= -= *= /= %=

public class test {
    public static void main(String[] args) {
        int a = 3;
        a += 3;//相当于a=a+3;
        System.out.println(a);//输出6
        a -= 3;
        System.out.println(a);//输出3
        a *= 3;
        System.out.println(a);//输出9
        a /= 3;
        System.out.println(a);//输出3
        a %= 3;
        System.out.println(a);//输出0
        }
}

在这里插入图片描述
这里的 a+=3;相当于a=a+3;其他的操作符同理
那这两种写法有什么区别呢

public class test {
    public static void main(String[] args) {
        int b = 3;
        double c = 2.3;
        b+=c;
        System.out.println(b);
        //b=b+c;//编译器会报错
         }
}

我们使用两种类型进行计算，发现并没有报错，但是数据有所丢失
输出结果如下
在这里插入图片描述
就像换成b = b+c的话，编译器会报错
在这里插入图片描述
增量运算符在计算的时候，可以不进⾏强制类型转换，使用这种运算符可以不强制类型转化就可以运算，但是结果可能会有所丢失

⾃增/⾃减运算符 ++ –

public class test {
    public static void main(String[] args) {
        int a = 3;
        a++;//4
        System.out.println(a++);//4
        System.out.println(a);//5
        ++a;//6
        System.out.println(++a);//7
        }
}

在这里插入图片描述
我们有前置++，-- 和后置++,–
这两种有所区别前置++先将数值赋给它，在进行++，后置++是先++操作，在进行赋值
就像这里的输出a++的话，先输出a的值在进行++,输出++a的话，是先将a的值加1在进行输出

2.关系操作符

关系运算符主要有六个: == != < > <= >= ,返回的结果只有true和false两种类型

public class test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        // 在Java中 == 表⽰相等
        System.out.println(a == b); // false
        System.out.println(a != b); // true
        System.out.println(a < b); // true
        System.out.println(a > b); // false
        System.out.println(a <= b); // true
        System.out.println(a >= b); // false
        }
}

在这里插入图片描述
我们要注意=是赋值运算符，==才是判断两边是否相等的
如果我们需要判断一个数 3<a<5，在Java中如何表示呢

3.逻辑运算符：&&，||，！

逻辑与&&

表达式1&&表达式2
表达式1表达式2运行结果
真真真
真假假
假真假
假假假

语法规则：表达式1&&表达式2，左右表达式必须是boolean类型的结果。返回只有true和false两种类型
两个表达式都为真，结果才是真，只要有⼀个是假，结果就是假。
逻辑或||

表达式1 || 表达式2
表达式1表达式2运行结果
真真真
真假真
假真真
假假假

表达式中只要有一个为真，结果就是真。
逻辑非！

!表达式
表达式结果
真假
假真

表达式为真，结果为假
表达式为假，结果为真

下面我们代码来演示一下

public class test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        System.out.println(a<=10&&b==20);//都为真才为真
        System.out.println(a>10||b<20);//一个为真就为真
        System.out.println(!true);//!true就为false
        System.out.println(a!=10&&b==20);
        System.out.println(a!=10||b==20);
    }
}

运行结果如下
在这里插入图片描述

逻辑与&&两边都为真才为真
逻辑或||两边都为假才为假
逻辑非！真变假，假变真

短路问题
我们上面的&&和||都有短路问题
我们来分析下面的代码

public class test {
    public static void main(String[] args) {
        System.out.println(10>20&&10/0==0);
        System.out.println(10<20||10/0==0);
    }
}

我们看上面的代码，肯定有人说这个代码错误，上面刚说过 / 的右操作符不可以为0，除数不可以为0，实则不然，这个代码是可以正常运行的。
运行结果如下
在这里插入图片描述
我们要注意：

逻辑与&&在运算的时候，如果左边表达式为假，右边的表达式不会进行计算
逻辑非||在运算的时候，如果左边表达式为真，右边的表达式不会进行运算
就像上面的10>20为假，并且是逻辑与&&运算符，那右边不计算
10<20为真，并且是逻辑或||运算符，那右边不计算

&和|
存在&与|这两个操作符，如果他们返回值为boolean类型，也就是只有true和false两种结果的话，它们可以像逻辑&&和逻辑||参与逻辑运算

public class test {
    public static void main(String[] args) {
        System.out.println(10>20&&10/0==0);
        System.out.println(10<20||10/0==0);
        System.out.println(10>20&10/0==0);//运算出错
        System.out.println(10<20|10/0==0);//运算出错
    }
}

在这里插入图片描述
&和|并不会出现短路问题，两边的表达式都会计算，不论左边为真还是为假，通通都要计算

4.条件操作符(三目操作符）

 表达式1 ? 表达式2 : 表达式3
 如果表达式1为真，返回表达式2,反之返回表达式3

public class test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int max = a>b? a:b;
        System.out.println(max);
    }
}

输出结果如下
在这里插入图片描述
但我们这里要注意表达2和表达式3必须是相同类型，否则程序会报错，如果是自动类型转化的话不会报错

public class test {
    public static void main(String[] args) {
        int a = 10;
        double b = 20.0;
        //int max = a>b?a:b;//这里程序是错误的
        double max = a>b?a:b;
        System.out.println(max);
    }
}

输出结果如下
在这里插入图片描述
这里如果我们可以发生小范围转化为大范围的话，这样的自动类型转化是不会报错的，但是如过这里使用int类型来接收的话，程序是错误的。
在这里插入图片描述
所以我们在使用表达式的时候都要注意其类型是否相符

四 分支语句

Java中存在if，swith用于分支语句，while ，for，do-while用于循环

1. if语句

if(布尔表达式）{
    表达式1；
}else{
    表达式2；
}
这里的话如果布尔表达式为真(true)，执行表达式1，反之则执行表达式2

例如这里小明，如果小明这次考试考了90分及以上就奖励他，如果没有没奖励

public class test {
    public static void main(String[] args) {
        int score = 90;
        if(score>=90){
            System.out.println("奖励");
        }else{
            System.out.println("没奖励");
        }
    }
}

输出结果如下
在这里插入图片描述
嵌套if - else（if和else相匹配）

if(布尔表达式1){
 // 语句1 
}else if(布尔表达式2){
 // 语句2 
}else{
表达式1成⽴，执⾏语句1，否则表达式2成⽴，执⾏语句2，否则执⾏语句3

我们可以多层嵌套，例如我们给学生成绩分等级
• 分数在[90,100]之间的，为优秀
• 分数在[80,90)之前的，为良好
• 分数在[70,80)之间的，为中等
• 分数在[60, 70)之间的，为及格
• 分数在[ 0, 60)之间的，为不及格
• 其他的分数为错误数据

public class test {
    public static void main(String[] args) {
        int score = 90;
        if (score >= 90 && score <= 100) {
            System.out.println("优秀");
        } else if (score >= 80 && score < 90) {
            System.out.println("良好");
        } else if (score >= 70 && score < 80) {
            System.out.println("中等");
        } else if (score >= 60 && score < 70) {
            System.out.println("及格");
        } else if (score >= 0 && score < 60) {
            System.out.println("不及格");
        } else {
            System.out.println("数据错误");
        }
    }
}

在这里插入图片描述
例题：闰年判断
口诀：四年一闰，百年不闰，四百年再闰
1.世纪年能被400整除的是闰年。(如2000年是闰年，1900年不是闰年)
2.普通年能被4整除；且不能被100整除的为闰年。（如2004年就是闰年，1901年不是闰年）

//闰年判断
public class test {
    public static void main(String[] args) {
        int year = 2000;
        if (year % 100 == 0) {
            // 判定世纪闰年
            if (year % 400 == 0) {
                System.out.println("是闰年");
            } else {
                System.out.println("不是闰年");
            }
        } else {
            // 普通闰年
            if (year % 4 == 0) {
                System.out.println("是闰年");
            } else {
                System.out.println("不是闰年");
            }
        }
    }
}

在这里插入图片描述
上面代码较长，我们可以使用逻辑与&&与逻辑或||进行简化
我们已经知道就两种情况是闰年，我们直接放入

public class test {
    public static void main(String[] args) {
        int year = 2000;
        if((year%4==0&&year%100!=0)||(year%400==0)){
            System.out.println("是闰年");
        }else {
            System.out.println("是闰年");
        }
    }
}

if和else语句后面必须加上大括号吗？

public class test {
    public static void main(String[] args) {
        int x = 10;
        int y = 20;
        if (x == 10)
            if (y == 10)
                System.out.println("aaa");
        else
                System.out.println("bbb");
    }
}

在这里插入图片描述
我们可以看到，这里的else是与第二个if对齐的，因为这里我们满足第一个条件x=10，但是第二个条件不满足，但是打印了bbb，如果和第一个对齐的结合的话就不会打印了，else是和最接近的if匹配
如果我们不写大括号的话，这里只能写一条语句，并且我们的逻辑关系也不清楚
不建议这么写，最好加上⼤括号

2. switch语句

switch(表达式){
    case 常量值1:
      语句1;
      [break;]
    case 常量值2:
       语句2;
       [break;]
 ...
    default:
   内容都不满⾜时执⾏语句;
    [break;]
}

1.我们是先算出表达式的值
2.在进行和case的值比较，一旦有符合的语句就执行，知道遇到break结束
3.如果没有满足的就会执行default语句下面的内容
例题：我们输出星期几

public class test {
    public static void main(String[] args) {
        int day = 1;
        switch (day){
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期日");
                break;
            default :
                System.out.println("输入错误");
                break;
        }
    }
}

在这里插入图片描述
我们要注意这里的case语句中不可以出现两个相同的数值
并且这里case后面的类型可以为常量值是基本类型：byte、char、short、int
引⽤类型：String常量串、枚举类型
但是不可以使用long ，float和double类型

使用了double类型报错了在这里插入图片描述
我们这里的break虽然可以省略，但是我们一般不会省略，因为这样可能会出多分支选择的情况

public class test {
   public static void main(String[] args) {
       int  day = 1;
       switch (day){
           case 1:
               System.out.println("星期一");
           case 2:
               System.out.println("星期二");
           case 3:
               System.out.println("星期三");
               break;
           case 4:
               System.out.println("星期四");
               break;
           case 5:
               System.out.println("星期五");
               break;
           case 6:
               System.out.println("星期六");
               break;
           case 7:
               System.out.println("星期日");
               break;
           default :
               System.out.println("输入错误");
               break;
       }
   }
}

这里如果我们省略了break的话，我们先找到语句，找到对应语句后，直到遇到break才截止，在没遇到break之前的语句都会执行，这样可能会导致结果输出错误
在这里插入图片描述

五 循环语句

循环语句，就是一直重复做一件相同的事情，直到遇到截止未知2

1. while循环

基本语法格式

while(循环条件) {
 循环语句;
}

这里的循环条件为true,则执⾏循环语句;否则结束循环
使用时要注意这里如果不加大括号的化和if语句一样只能放一条语句
所以我们在使用的时候，建议不要省略大括号
例题：打印1~ 10之间的数

public class test {
    public static void main(String[] args) {
        int num = 1;//初始化
        while(num<=10){//判断
            System.out.println(num);
            num++;//调整
        }
    }
}

在这里插入图片描述
运行结果如下
在这里插入图片描述
例题：计算1 ~ 100的和

public class test {
    public static void main(String[] args) {
        int num = 1;
        int sum = 0;
        while(num<=100){
            sum+=num;
            num++;
        }
        System.out.println(sum);
    }
}

运行结果如下
在这里插入图片描述

2. for循环

for(表达式1;布尔表达式2;表达式3){
     表达式4;
 }

表达式1:⽤于初始化循环变量初始值设置，在循环最开始时执⾏，且只执⾏⼀次
表达式2:循环条件，满则循环继续，否则循环结束
表达式3:循环变量的调整

例题：输出1~10的数

 public class test {
     public static void main(String[] args) {
         for (int i = 1; i <= 10; i++) {
             System.out.println(i);
         }
     }
 }

运行结果如下
在这里插入图片描述
在这里插入图片描述
使用时要注意这里如果不加大括号的化和if语句一样只能放一条语句
所以我们在使用的时候，建议不要省略大括号。
我们要注意括号内的之间要用分号分开（；）,不可以使用其他符号隔开

3.do while 循环

do{
  循环语句;
}while(循环条件);

与while循环不同，这里是先执行循环语句，然后执行判断条件
例题 ：打印1 ~ 10

public class test {
    public static void main(String[] args) {
        int num = 1;
        do {
            System.out.println(num);
            num++;
        }while (num<=10);
    }
}

运行结果如下
在这里插入图片描述
在这里插入图片描述
do while 循环最后的分号不要忘记
由于do while循环这种先执行循环条件，在进行判断这种特性，我们只有在特定的情况下才会使用do while循环，我们大多数使用的是while和for循环

4.continue与break语句

break是跳出整个循环，结束循环，而continue是结束本次循环在while和for循环中有所差异，下面是一些例子

while循环下的break和continue

public class test {
    public static void main(String[] args) {
        int num = 1;//初始化
        while(num<=10){//判断
            if(num==3){
                break;
                //continue;
            }
            System.out.println(num);
            num++;
           
        }
    }
}

break跳出整个循环，循环直接截止，这里num的值3时候，跳出循环
)
换成continue 的话，只会跳出后面语句，并不会退出循环，当num==3的时候，这里不进行打印和num++操作，但这里并不跳出出循环，一直进行判断，判断条件一直为真，在判断中num的数值一直为3，并没有逐渐接近循环截止条件，导致一直进行判断，导致死循环
在这里插入图片描述
for循环下的continue和break

 public class test {
     public static void main(String[] args) {
         for (int i = 1; i <= 10; i++) {
             if(i==3){
                 break;
                 //continue;
             }
             System.out.println(i);
         }
     }
}

break这里和while循环效果一样，直接退出循环
在这里插入图片描述
continue，但是这里的结果和while循环中有所不同
这里当i的值为3的时候，跳出下面打印语句，继续执行后面的判断和++操作，
这样3后面的数还是正常打印，这里除了3没有打印其他数全部都打印了
在这里插入图片描述
到这里就结束，希望这对大家有所帮助，欲知后事如何，请听下回分解。

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
【C++笔记】C++11的深度剖析(二)
1.6部署到CentOS「深入浅出ASP.NET Core系列」
A016基于SSM实现的学生宿舍管理系统
C++ 模板初阶
mock的使用
svn迁移出的项目中文乱码解决
Python+大数据-SQL 进阶-窗口函数
springboot~用正则表达式提取bearer token
[源码解析] TensorFlow 分布式之 ParameterServerStrategy V1
python爬虫技术简介-Python网络爬虫功能的基本写法介绍
;