java基础语法（精简版）

文章目录

目录

文章目录

        一、运算符

        1、算数运算符

        2、赋值运算符

        3、关系运算符（比较运算符）

        4、逻辑运算符

        5、三元运算符

        6、字符的“+”操作

        7、字符串的+操作

二、流程控制语句

        1、顺序结构

        2、分支结构

        1.if语句

        2.switch语句

三、循环

1、for循环

2、while循环

3、do while循环

4、死循环

        1、for死循环：

        2、while死循环：

        3、do...while死循环：

四、Random随机数

总结

---

---

一、运算符

1、算数运算符

        首先知道运算符和表达式：

                ·运算符：对常量或者进行操作的符号。

                ·表达式：用运算符把常量或者变量连接起来符合java语法的式子。

例如：

int a = 10;
int b = 20;
int c = a + b;

这里，“ + ”号是运算符，a + b 是表达式。由于“ + ”是算术运算符，所以表达式是算数表达式。

这样的算术运算符总共包括： +，-，*，/，%（取余)

下面举几个例子：

1.整数相除

System.out.println(10/2);//结果是5
System.out.println(10/3);
System.out.println(10/3.0);//结果是3.3333333335
System.out.println(10.0/3);//结果是3.3333333335

 第1、3、4调代码的结果没有问题，但是第2条代码的结果为什么不是小数呢？

因为两个整数相除，得到的结果也是整数类型。

总结： 整数相除，结果只能得到整数，如果想要得到带有小数的结果，必须加入小数（浮点类型）的运算。

2.取模运算符（取余运算）

System.out.println(5%2);

 结果为1。

注意一点：“/”运算取结果的商，而“%”运算取结果的余数。整数操作只能得到整数，要想得到整数，必须有浮点数参与运算。

2、赋值运算符

赋值运算符包括两种：

一种是基本赋值运算符：=（也就是等号）

例如：int a = 10;        将10赋值给变量a。

其余几种是扩展运算符，就是以下几种：
+=：加后赋值，a += b,将a + b的值赋给a

-=：减后赋值，a -= b,将a - b的值赋给a

*=：乘后赋值，a *= b,将a * b的值赋给a

/=:   除后赋值，a /= b,将a 除以b的商赋给a

%=:取余后赋值，a %= b,将a 除以 b的余数赋给a

注意：扩展的赋值运算符隐含了强转类型转换。

3、关系运算符（比较运算符）

关系运算符包含一下几个：
1.“==”：  例：a == b,判断a和b的值是否相等，成立为true，反之为false

2.“!=”：   例：a != b,判断a和b的值是否不相等，成立为true，反之为false

3.“>”：    例：a > b,判断a是否大于b,成立为true，反之为false

4.“>=”：  例：a >= b,判断a是否大于等于b,成立为true，反之为false

5.“<”：    例：a < b,判断a是否小于b,成立为true，反之为false

6.“<=”：  例：a <= b,判断a是否小于等于b,成立为true，反之为false

注意:关系运算符的结果是boolean类型的，要么是true，要么是false。不要把“==”和“=”混淆。

4、逻辑运算符

首先，我们要知道逻辑运算符的作用：用于整合多个比较表达式的条件。

我们可以用数学中的例子来理解：在数学中，可以写成 1

        ·分解：x>1和x<10

        ·合并：x>1 & x<10

在代码中实现：

public calss Test{
    public static void main(String[] args){
        int a = 5;
        System.out.println(x>1 & x<10);
    }
}

可以理解为两个表达式最终的结果，x>1为true，x<10为true，结果为true。

总结以下：
1.    &（与）：遇发false则false，只有两边都为true时才为true。

2.    |（或）：遇发true则true，只有两边都为false时才为false。

3.    !(非)：     取反

4.    ^(异或)：相同为false，不同为true。

5、三元运算符

三元运算符的格式为： 关系表达式 ？表达式1：表达式2；

如何执行的：首先计算关系表达式的值，

                      如果为true，结果为表达式1的值，

                      反之，如果为false，结果为表达式2的值。

再看一段代码：

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

 可以看到，a是不大于b的，所以表达式的值为false，结果为b的值，再将b的值赋值给max，最后打印max的值为20.

也可以看作是求两个数的最大值或者最小值。

6、字符的“+”操作

        先看一段代码：

public calss Test{
    public static void main(String[] args){
        int a = 1;
        char b = 'a';
        System.out.println(a + b);
    }
}

那么int类型的a和字符类型的‘a’是如何相加的呢？

我们前面说到，当（byte，char，int）在一起运算时，都会提升为int之后，再进行运算。

但是，char类型如何提升为int数值的呢？

这里就要用到一套计算机中字节到字节的一套对应关系，名为ASCII表。如图：

 经过查表可知，字符‘a’真正存储的字节表示是数值97，经过+1得到结果就是98。

7、字符串的+操作

先看一段代码，

System.out.println("apple" + 678);
System.out.println("apple" + true);

 结果为：apple678和appletrue。因为这个 + 是【字符串连接符】，而不是算数运算。

可以理解为无论字符串后跟什么，直接粘后面。

但是再看一段代码：

System.out.println(4 + 5 + "apple" + 1);

 这段代码的结果是不是“45apple1”呢？答案不是的。

这是因为运算过程是从左往右进行运算，先是4 + 5之后，遇到了字符串，所以结果为“9apple1”

二、流程控制语句

1、顺序结构

顺序结构语句是java程序，默认的执行流程，按照代码的先后顺序依次执行。        

2、分支结构

1.if语句

if语句分为三种格式：

        1.第一种格式：

if(关系表达式){

        语句体;

}

执行流程：
首先计算关系表达式的值

如果为true，就执行语句体

如果为false，就不执行语句体

继续执行后面的内容

        2.第二种格式：

if(关系表达式){

        语句体1;

}else{

        语句体2;

}

执行流程：
首先计算关系表达式的值

如果为true，就执行语句体1

如果为false，就执行语句体2

最后再继续执行后面的语句内容

*可以理解为，如果...,否则...

        3.第三种格式：
if(判断条件1){

        语句体1;

}else if(判断条件2){

        语句体2;

}

...

else{

        语句体n+1;

}

*可以理解为，如果...，再如果...，再再如果...，最后...

执行流程：
首先计算判断条件1的值

如果为true，就执行语句体1，如果为false，就计算判断条件2的值

如果判断条件2的值为true，就执行语句体2，反之，就再判断条件3

...

如果判断条件中没有为true的，就执行语句体n+1,也就是else里的代码。

例如：

public class Text{
    public static void main(String[] args){
        int a = -1;
        if(a >= 90 && a <= 100){
            System.out.println("优秀")
        }else if(a >= 80 && a <= 89){
            System.out.println("良好")
        }else if(a >= 70 && a <= 79){
            System.out.println("中等")
        }else if(a >= 60 && a <= 69){
            System.out.println("及格")
        }else if(a >= 0 && a <= 59){
            System.out.println("继续加油！")
        }else{
            System.out.println("请输入有效成绩！")
        }
    }
}

2.switch语句

switch语句的格式和说明：

格式：
switch(表达式){

        case 值1 ：

                语句体1；

                break；

        case 值2 ：

                语句体2；

                break；

        ...

        default :

                语句体n + 1;

                break;

}

代码说明：

表达式：将要被匹配的值，取值为byte，char，short，int，JDK5以后可以是枚举，JDK7以后可以是String。

case：被匹配的值，和表达式比较的值。

break：表示中断、结束的意思，用来结束switch语句。

default：表示所有情况都不匹配时，执行这里的内容。

执行流程:

1. 首先计算表达式的值
2. 依次和case后面的值进行比较，如果有相对应的值，就会执行相应的语句体，执行过程中，遇到break就会结束，终止switch
3. 如果所有的case对应的值与表达式的值都不匹配，就会执行default里面的语句体，然后程序结束掉。

这里举一个例子:
 

public class Test{
    public static void main(String[] args){
        int week = 2;
        
        switch(){
            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("请输入正确的日期！");
        }
    }
}

通过修改week的值，可以打印不同的星期。

但是当case中缺少break的时候，后续的case就不会有匹配效果，内部代码都会执行，直到遇到break，或者将整体的switch语句执行完毕，才会结束。即case的穿透现象：

例如：

public class Test{
    public static void main(String[] args){
        int week = 1;
        
        switch(){
            case 1 :
                System.out.println("星期一");
                
            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("请输入正确的日期！");
        }
    }
}

运行的结果为：
星期一

星期二

还可以用case穿透来举另一个例子：

例如：

public class Test{
    public static void main(String[] args){
        int week = 2;
        
        switch(){
            case 1 :
            case 2 :    
            case 3 :    
            case 4 :    
            case 5 :
                System.out.println("工作日");
                break;
            case 6 :
            case 7 :
                System.out.println("休息");
                break;
            default:
                System.out.println("请输入正确的日期！");
        }
    }
}

这里week为1,2,3,4,5的时候打印的是工作日，当为6,7的时候打印的是休息。

还要注意一点，case的对应值只能是常量，不能是变量。

三、循环

循环分为三种：

1、for循环

格式：
for(初始化语句；条件判断语句；条件控制语句){

        循环体语句；

}

执行流程：

1. 执行初始化语句
2. 执行条件判断语句，看执行的结果是true还是false。如果是true，继续执行；如果是false，就循环结束。
3. 执行循环体语句
4. 执行条件控制语句
5. 回到2继续判断

2、while循环

格式：
初始化语句；

while(条件判断语句){

        循环体语句；

        条件控制语句；

}

执行流程：

1. 执行初始化语句；
2. 执行条件判断语句，看结果是否为true还是false。如果为true，继续执行；如果为false，循环结束。
3. 执行循环体语句
4. 执行条件控制语句
5. 回到第2步继续

例子：
 

public class Test{
    public static void main(String[] args){
        int i = 1;
        while(i <= 50){
        System.out.println("好好学习！");
        i++;
        }
    }
}

这里循环执行了50次。

3、do while循环

格式：

初始化语句；

do{

        循环体语句；

        条件控制语句；

}while(条件判断语句);

执行流程：

1. 执行初始化语句
2. 执行循环体语句
3. 执行条件控制语句
4. 执行条件判断语句，看结果是true还是false。如果是true，继续执行；如果是false，循环结束。
5. 回到第2步继续

注意的是：do...while循环不同于while循环，do...while循环是先执行循环体，后进行条件控制语句，最后执行条件判断语句。

例子：

public class Test{
    public static void main(String[] args){
        int i = 1;
        do{
            System.out.println("好好学习！");
            i++;
        }while(i <= 10);
    }
}

结果会打印10次”好好学习“。

但是下面一段代码会打印几次呢?还是不打印呢？

public class Test{
    public static void main(String[] args){
        int i = 11;
        do{
            System.out.println("好好学习！");
            i++;
        }while(i <= 10);
    }
}

答案是只会打印一次”好好学习“，原因如下：

无论判断条件是否满足，都会至少执行一次循环体。因为在执行循环体的时候，还没有执行到判断条件。

do...while一般用的比较少，但是要知道。

4、死循环

死循环就是无线循环。

下面直接看代码

1、for死循环：

public class Test{
    public static void main(String[] args){
        for(;;){
            System.out.println("好好学习");
        }
    }
}

2、while死循环：

public class Test{
    public static void main(String[] args){
        while(true){
           System.out.println(好好学习);
        }
    }
}

3、do...while死循环：

public class Test{
    public static void main(String[] args){
        do{
            System.out.println("好好学习！");
        }while(true);
    }
}

注意：在死循环之后的语句是无法执行的。

四、Random随机数

作用：用于产生一个随机数。

如何使用：

1、导包

导入 import java.util.Random包

2.创建对象

Random r = new Random();其中r是变量名，可以改变，其他的不能变。

3.获取随机数

int number = r.nextInt(10);获取【0,10)之间随机数。

例子：

import java.util.Random;

public class Test{
    public static void main(String[] args){
        Random r = new Random();
        int number = r.nextInt(10);
        System.out.println(number);
}

结果会产生一个从【0,10)之间随机数。包括0，但不包括10。

---

总结

以上就是比较基本的java语法，希望大家喜欢。下一章为java中基础语法的数组介绍。

大家喜欢的话给我一个免费的关注吧。