从零打造知识体系-IT-Java基础-02基本数据类型与算法

于 2021-03-06 22:34:19 发布
阅读量207 收藏
点赞数
分类专栏： # IT知识体系-Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aiowang/article/details/114460730
版权

简介：术道并行，从零打造IT知识体系，图文视频同步更新。
本文学习章节：Java基础-02Java基础数据类型、基本算法
本文学习内容: Java基本数据类型（八大基础数据结构、引用类型）；Java基本算法（Java运算符：算术运算符、位移运算、关系运算、逻辑运算、三目条件运算符、赋值运环等；Java循环语句；Java条件语句；Java条件分支语句）
本文视频地址：待更新

当前知识体系图谱

绿色：已学习内容。蓝色：本次学习内容

在这里插入图片描述

1 Java的数据类型

Java数据类型（type） 包括：基本类型（primitive types）和引用类型（reference types）

Java是一种强类型语言，必须为每个变量声明其类型。在Java中，一共有8种基本类型，其中4种整型，2种浮点类型，1种表示Unicode编码的字符单元的字符类型char，1种用于表示真假值得boolean类型。

1.1 基本类型（primitive types）

1.1.1 基本类型简介

基本类型 包括：boolean类型 和 数值类型（numeric types）
数值类型（numeric types）又分为整型（integer types）和 浮点型（floating-point type）
整型有5种：byte、short、int、long、char(char本质上是一种特殊的int)。浮点类型有float 和 double

8中类型表示范围如下：

  • byte：8位，最大存储数据量是255，存放的数据范围是-128~127之间。
  • short：16位，最大存储数据量是65536，数据范围是-32768~32767之间。
  • int：32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。
  • long：64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。
  • float：32位，数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F。
  • double：64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加。
  • boolean：1位，只有true和false两个取值。
  • char：16位，存储Unicode码，用单引号赋值。

1.1.2 基本类型的封装器类

Java每个基本类型都对应着封装类

  • byte：Byte
  • short：Short
  • int：Integer
  • long：Long
  • float：Float
  • double：Double
  • boolean：Boolean
  • char：Character

1.1.3 基本类型与其封装类类型比较

  • 原始数据类型在传递参数时都是按值传递，封装类是对象，都是按引用传递
  • 封装类实际是对象的引用，当new一个封装类时，实际上是生成一个指针指向此对象；而基本类型则是直接存储数据值
  • Java基本类型存储在栈中
  • Integer的默认值是null，int的默认值是0，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况，返回数据库字段值是null的话，实体类中用int类型接收的话会报错。int是基本数据类型，其声明的是变量，而null则是对象。所以建议用integer
  • Integer对于-128到127之间的数，会进行缓存，Integer i = 127时，会将127进行缓存，下次再写Integer j = 127时，就会直接从缓存中取，就不会new了
  • int 和 Integer在进行比较的时候，Integer会进行拆箱，转为int值与int进行比较。其它数值类型也是一样。
  • Integer与Integer比较的时候，由于直接赋值的时候会进行自动的装箱，那么这里就需要注意两个问题，一个是-128<= x<=127的整数，将会直接缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是从缓存中获取已经创建好的Integer对象。二：当大于这个范围的时候，直接new Integer来创建Integer对象。
  • new Integer(1) 和Integer a = 1不同，前者会创建对象，存储在堆中，而后者因为在-128到127的范围内，不会创建新的对象，而是从IntegerCache中获取的。那么Integer a = 128, 大于该范围的话才会直接通过new Integer（128）创建对象，进行装箱
  • Java语言中，默认声明的小数是double类型的，因此对float类型的变量进行初始化时需要进行类型转换
  • 基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型
  • 两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
  • 基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较。

1.1.4 数据类型转换

byte <（short=char）< int < long < float < double
如果从小转换到大，可以自动完成，而从大到小，必须强制转换。short和char两种相同类型也必须强制转换。

1.2 引用类型（reference types）

引用类型（reference types）包括类（class）、接口（interface）、数组（array）、空（null）

引用类型记住一点，传递参数时是引用传递，以后会继续学习。

2 Java基本算法（参考菜鸟教程）

  1. Java 运算符 - 算术运算符、关系运算符、位运算符、逻辑运算符、赋值运算符、其他运算符
  1. Java 循环结构 - for, while 及 do…while
  2. Java 条件语句 - if…else
  3. Java switch case 语句

Java的语法主要包含运算符、循环结构、条件语句、分支选择switch语句。接下来我们通过代码一个一个认识这些语法。

2.1 Java运算符

2.1.1 算术运算符

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。

运算符：

  • 加法（+）：
    相加运算符两侧的值：A + B
  • 减法（-）：
    左操作数减去右操作数：A - B
  • 乘法（*）：
    相乘操作符两侧的值：A * B
  • 除法（/）：
    左操作数除以右操作数：A / B
  • 取余（％）：
    左操作数除以右操作数的余数 ：A ％ B
  • 自增（++）：
    操作数的值增加1 ：B++ 或 ++BB
  • 自增（–）：
    操作数的值增加1 ：B-- 或 --BB

示例代码：

public class ArithmeticOperation {

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;
        System.out.println("a + b = " + (a + b) );
        System.out.println("a - b = " + (a - b) );
        System.out.println("a * b = " + (a * b) );
        System.out.println("b / a = " + (b / a) );
        System.out.println("b % a = " + (b % a) );
        System.out.println("c % a = " + (c % a) );
        System.out.println("a++   = " +  (a++) );
        System.out.println("a--   = " +  (a--) );
        // 查看 d++ 与 ++d 的不同
        System.out.println("d++   = " +  (d++) );
        System.out.println("++d   = " +  (++d) );
    }
}

运算结果：

a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++   = 10
a--   = 11
d++   = 25
++d   = 27

2.1.2 关系运算符

关系运算符，用于2个操作数的比较，其结果要么为真，要么为假。

运算符：

  • 是否相等（==）：
    检查如果两个操作数的值是否相等，如果相等则条件为真。
  • 是否不相等（!=）：
    检查如果两个操作数的值是否相等，如果值不相等则条件为真。
  • 是否大于（>）：
    检查左操作数的值是否大于右操作数的值，如果是那么条件为真。
  • 是否小于（<）：
    检查左操作数的值是否小于右操作数的值，如果是那么条件为真。
  • 是否大于等于（>=）：
    检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。
  • 是否小于等于（<=）：
    检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。

示例代码：

RelationalOperation {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("a == b = " + (a == b) );
        System.out.println("a != b = " + (a != b) );
        System.out.println("a > b = " + (a > b) );
        System.out.println("a < b = " + (a < b) );
        System.out.println("b >= a = " + (b >= a) );
        System.out.println("b <= a = " + (b <= a) );
    }
}

运算结果：

a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

2.1.3 位运算符

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。
位运算符首先转化为二进制，再按照对应位进行位运算规则计算，由于直接操作位移，效率极高。

运算符:

  • 与（＆）：
    如果相对应位都是1，则结果为1，否则为0
  • 或（|）：
    如果相对应位都是 0，则结果为 0，否则为 1
  • 异或（^）：
    如果相对应位值相同，则结果为0，否则为1
  • 非（〜）：
    按位取反运算符翻转操作数的每一位，即0变成1，1变成0。
  • 左移（<<）：
    将运算符左边的对象向左移动运算符右边指定的位数（在低位补0）
  • "有符号"右移（>>）：
    将运算符左边的对象向右移动运算符右边指定的位数。使用符号扩展机制，也就是说，如果值为正，则在高位补0，如果值为负，则在高位补1。
  • "无符号"右移（>>>）：
    将运算符左边的对象向右移动运算符右边指定的位数。采用0扩展机制，也就是说，无论值的正负，都在高位补0。

示例代码:

public class BitOperation {
    public static void main(String[] args) {
        int a = 60; /* 60 = 0011 1100 */
        int b = 13; /* 13 = 0000 1101 */
        int c = 0;
        c = a & b;       /* 12 = 0000 1100 */
        System.out.println("a & b = " + c );

        c = a | b;       /* 61 = 0011 1101 */
        System.out.println("a | b = " + c );

        c = a ^ b;       /* 49 = 0011 0001 */
        System.out.println("a ^ b = " + c );

        c = ~a;          /*-61 = 1100 0011 */
        System.out.println("~a = " + c );

        c = a << 2;     /* 240 = 1111 0000 */
        System.out.println("a << 2 = " + c );

        c = a >> 2;     /* 15 = 1111 */
        System.out.println("a >> 2  = " + c );

        c = a >>> 2;     /* 15 = 0000 1111 */
        System.out.println("a >>> 2 = " + c );
    }
}

运算结果：

a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2  = 15
a >>> 2 = 15

2.1.4 逻辑运算符

顾名思义，进行2个操作数的逻辑上的判断。

运算符:

  • 与（&&）：
    称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。
  • 或（||）：
    称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。
  • 非（！）：
    称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。

示例代码:

public class LogicOperation {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        System.out.println("a && b = " + (a&&b));
        System.out.println("a || b = " + (a||b) );
        System.out.println("!(a && b) = " + !(a && b));
    }
}

运算结果：

a && b = false
a || b = true
!(a && b) = true

2.1.5 赋值运算符

将操作数进行制定的运行后，进行赋值覆盖。

运算符:

  • 赋值（=）：
    简单的赋值运算符，将右操作数的值赋给左侧操作数：C = A + B将把A + B得到的值赋给C
  • 加和赋值（+ =）：
    加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数：C + = A等价于C = C + A
  • 减和赋值（- =）：
    减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数：C - = A等价于C = C - A
  • 乘和赋值（* =）：
    乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数：C * = A等价于C = C * A
  • 除和赋值（/ =）：
    除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数：C / = A，C 与 A 同类型时等价于 C = C / A
  • 取模和赋值（（％）=）：
    取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数：C％= A等价于C = C％A
  • 左移位赋值（<< =）：
    左移位赋值运算符：C << = 2等价于C = C << 2
  • 右移位赋值（>> =）：
    右移位赋值运算符：C >> = 2等价于C = C >> 2
  • 按位与赋值（＆=）：
    按位与赋值运算符：C＆= 2等价于C = C＆2
  • 按位异或赋值（^ =）：
    按位异或赋值操作符：C ^ = 2等价于C = C ^ 2
  • 按位或赋值（| =）：
    按位或赋值操作符：C | = 2等价于C = C | 2

示例代码:

public class AssignmentOperators {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 0;
        c = a + b;
        System.out.println("c = a + b = " + c );
        c += a ;
        System.out.println("c += a  = " + c );
        c -= a ;
        System.out.println("c -= a = " + c );
        c *= a ;
        System.out.println("c *= a = " + c );
        a = 10;
        c = 15;
        c /= a ;
        System.out.println("c /= a = " + c );
        a = 10;
        c = 15;
        c %= a ;
        System.out.println("c %= a  = " + c );
        c <<= 2 ;
        System.out.println("c <<= 2 = " + c );
        c >>= 2 ;
        System.out.println("c >>= 2 = " + c );
        c >>= 2 ;
        System.out.println("c >>= 2 = " + c );
        c &= a ;
        System.out.println("c &= a  = " + c );
        c ^= a ;
        System.out.println("c ^= a   = " + c );
        c |= a ;
        System.out.println("c |= a   = " + c );
    }
}

运算结果：

c = a + b = 30
c += a  = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a  = 5
c <<= 2 = 20
c >>= 2 = 5
c >>= 2 = 1
c &= a  = 0
c ^= a   = 10
c |= a   = 10

2.1.6 三目条件运算符

三目条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
variable x = (expression) ? value if true : value if false

运算符：

  • 三目条件运算（?:）：
    根据A的结果，若为真则返回B，若为假则返回C： A?B:C

示例代码：

public class ConditionalOperator {
    public static void main(String[] args){
        int a , b;
        a = 10;
        // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
        b = (a == 1) ? 20 : 30;
        System.out.println( "Value of b is : " +  b );

        // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
        b = (a == 10) ? 20 : 30;
        System.out.println( "Value of b is : " + b );
    }
}

运算结果

Value of b is : 30
Value of b is : 20

2.1.7 instanceof运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
( Object reference variable ) instanceof (class/interface type)

运算符：

  • 类型判断运算（instanceof）：
    判断A类型是否是B类型、B类型的实现、B类型的子类。

示例代码：

public class InstanceofOperation {

    public static void main(String[] args){
        String name = "James";
        boolean result1 = name instanceof String; // 由于 name 是 String 类型，所以返回真
        System.out.println( result1);

        Vehicle a = new Car();
        boolean result2 =  a instanceof Car;
        System.out.println( result2);

        Bar bar = new Bar();
        boolean result3 =  bar instanceof Foo;
        System.out.println( result3);
    }
}

interface Foo{}

class Bar implements Foo{

}

class Vehicle {}

class Car extends Vehicle {

}

运算结果：

true
true
true

2.2 Java运算符优先级

当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。

在这里插入图片描述

优先级记忆方法：单目乘除为关系，逻辑三目后赋值。

在这里插入图片描述

实际开发中，应以括号辅助优先级管理。

2.3 Java循环结构

顺序结构的程序语句只能被执行一次。如果您想要同样的操作执行多次,，就需要使用循环结构。
Java中有三种主要的循环结构：

  • while 循环
  • do…while 循环
  • for 循环

2.3.1 while 循环

语法结构：

while( 布尔表达式 )  {
	//循环内容
}

只要布尔表达式为 true，循环就会一直执行下去。

代码示例：

public class WhileLoop {
    public static void main(String args[]) {
        int x = 10;
        while( x < 20 ) {
            System.out.print("value of x : " + x );
            x++;
            System.out.print("\n");
        }
    }
}

运行结果：

value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19

2.3.2 do…while 循环

语法结构：

do {
       //代码语句,至少执行一次
}while(布尔表达式);

do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

代码示例：

public class DoWhileLoop {
    public static void main(String args[]){
        int x = 10;

        do{
            System.out.print("value of x : " + x );
            x++;
            System.out.print("\n");
        }while( x < 20 );
    }
}

运行结果：

value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19

2.3.3 for 循环

语法结构：

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

说明：

  • 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
  • 然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
  • 执行一次循环后，更新循环控制变量。
  • 再次检测布尔表达式。循环执行上面的过程。

代码示例：

public class ForLoop {
    public static void main(String args[]) {

        for(int x = 10; x < 20; x = x+1) {
            System.out.print("value of x : " + x );
            System.out.print("\n");
        }
    }
}

运行结果：

value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19

2.3.4 增强for 循环

语法结构：

for(声明语句 : 表达式){
   //代码句子
}

说明：
**声明语句：**声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
**表达式：**表达式是要访问的数组名，或者是返回值为数组的方法。

代码示例：

public class ForPlusLoop {
    public static void main(String args[]){
        int [] numbers = {10, 20, 30, 40, 50};

        for(int x : numbers ){
            System.out.print( x );
            System.out.print(",");
        }

        System.out.print("\n");
        String [] names ={"James", "Larry", "Tom", "Lacy"};
        for( String name : names ) {
            System.out.print( name );
            System.out.print(",");
        }


    }
}

运行结果：

10,20,30,40,50,
James,Larry,Tom,Lacy,

2.3.5 break 关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
break 跳出最里层的循环，并且继续执行该循环下面的语句。

语法结构：

break;

代码示例：

public class BreakKeyWord {
    public static void main(String args[]) {
        int [] numbers = {10, 20, 30, 40, 50};

        for(int x : numbers ) {
            // x 等于 30 时跳出循环
            if( x == 30 ) {
                break;
            }
            System.out.print( x );
            System.out.print("\n");
        }
    }
}

运行结果：

10
20

2.3.5 continue 关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

语法结构：

continue;

代码示例：

public class ContinueKeyWord {
    public static void main(String args[]) {
        int [] numbers = {10, 20, 30, 40, 50};

        for(int x : numbers ) {
            if( x == 30 ) {
                continue;
            }
            System.out.print( x );
            System.out.print("\n");
        }
    }
}

运行结果：

10
20
40
50

2.4 条件语句

包括if、if…else、if…else if…else语句
** if语句 ** : 一个 if 语句包含一个布尔表达式和一条或多条语句。如果布尔表达式的值为 true，则执行 if 语句中的代码块，否则执行 if 语句块后面的代码。
** if…else语句 ** :if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，else 语句块会被执行。
** if…else if…else语句** ：if 语句后面可以跟 else if…else 语句，这种语句可以检测到多种可能的情况。 if 语句至多有 1 个 else 语句，else 语句在所有的 else if 语句之后。if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。 一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。
** 嵌套的 if…else 语句** ：使用嵌套的 if…else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if 语句。

语法结构：

/* if语句 */
if(布尔表达式){
   //如果布尔表达式为true将执行的语句
}
/* if...else语句 */
if(布尔表达式){
   //如果布尔表达式的值为true
}else{
   //如果布尔表达式的值为false
}
/* if...else if...else语句 */
if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
   //如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
   //如果布尔表达式 3的值为true执行代码
}else {
   //如果以上布尔表达式都不为true执行代码
}
/* 嵌套的 if…else 语句 */
if(布尔表达式 1){
   如果布尔表达式 1的值为true执行代码
   if(布尔表达式 2){
      如果布尔表达式 2的值为true执行代码
   }
}

代码示例：

public class Ifelse {
    public static void main(String args[]){
        int x = 10;

        if( x < 20 ){
            System.out.print("这是 if 语句");
        }
    }
    //执行结果:
    //这是 if 语句

    public static void main2(String args[]){
        int x = 30;

        if( x < 20 ){
            System.out.print("这是 if 语句");
        }else{
            System.out.print("这是 else 语句");
        }
    }
    //执行结果:
    //这是 else 语句


    public static void main3(String args[]){
        int x = 30;

        if( x == 10 ){
            System.out.print("Value of X is 10");
        }else if( x == 20 ){
            System.out.print("Value of X is 20");
        }else if( x == 30 ){
            System.out.print("Value of X is 30");
        }else{
            System.out.print("这是 else 语句");
        }
    }
    //执行结果:
    //Value of X is 30


    public static void main4(String args[]){
        int x = 30;
        int y = 10;

        if( x == 30 ){
            if( y == 10 ){
                System.out.print("X = 30 and Y = 10");
            }
        }
    }
    //执行结果:
    //X = 30 and Y = 10
}

2.5 switch case 语句

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

  • switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
  • switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
  • case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
  • 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
  • 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
  • switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

语法结构：

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。

代码示例：

public class SwitchCase {
    public static void main(String args[]){
        //char grade = args[0].charAt(0);
        char grade = 'C';

        switch(grade)
        {
            case 'A' :
                System.out.println("优秀");
                break;
            case 'B' :
            case 'C' :
                System.out.println("良好");
                break;
            case 'D' :
                System.out.println("及格");
                break;
            case 'F' :
                System.out.println("你需要再努力努力");
                break;
            default :
                System.out.println("未知等级");
        }
        System.out.println("你的等级是 " + grade);
    }
}

执行结果：

良好
你的等级是 C

3 总结

3.1 Java数据类型

  • Java的数据类型分为基本数据类型和引用数据类型。Java的基本类型（位数，封装类）有：byte（8，Byte）、short（16、Short）、int（32、Integer）、long（64、Long）、float（32、Float）、double（32、Double）、boolean（1、Boolean）、char（16、Character）；引用数据类型有：类、接口、数组、null。

3.2 Java运算符

  • Java的运算符有：算术运算、位移运算、关系运算、逻辑运算、三目条件运算符、赋值运算等。
  • 自增自减运算符：当符号在前面，则先进行自增或者自减运算，再进行表达式运算。当变量在前面，则先进行表达式运算，再进行自增或者自减运算。故a=1，a++后，a仍未1；++a后，a为2.
  • 短路逻辑运算符：当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。
  • instanceof运算符：A instanceof B，判断A类型是否是B类型、B类型的实现、B类型的子类。
  • Java运算符优先级无需记忆，实际操作过程肯定应该以括号来辅助。

3.3 循环、条件、switch case

  • 循环语句有：for、while、do…while; do…while至少执行一次
  • 条件语句：if else
  • 条件分支语句：switch case
  • 循环语句关键字：break跳出当前循环；continue跳出本次循环

参考文档：
菜鸟教程：https://www.runoob.com/java/java-tutorial.html
java运算符优先级记忆口诀 https://www.cnblogs.com/gavin-yao/p/10595835.html

子薰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值