[JavaSE]第二章基本语法_随笔

[JavaSE]第二章基本语法 2.1 Java 基本语法 2.1.1 注释

Java 中的注释有三种类型，具体如下：

单行注释

int age = 18;//这是一个单行注释

多行注释
```
int age = 18;
```
文档注释
生成文档注释命令
- javadoc -d 目录名 -author -version Java文件名.java -encoding UTF-8 -charset UTF-8

2.1.2 标识符

标识符
- Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
- 技巧：凡是自己可以起名字的地方都叫标识符
定义合法标识符规则
- 由 26 个英文字母大小写，0-9，_ 或 $ 组成
- 数字不可以开头
- 不可以使用关键字和保留字，但能包含
- Java 中严格区分大小写，长度无限制
- 标识符不能包含空格
命名规范
- 包名：多单词组成时所有的字母都小写 xxxyyyyzzz
- 类名、接口名：多单词组成时，所有单词的首字母大写 XxxYyyZzz
- 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词的首字母大写 xxxYyyZzz
- 常量名：所有字母都大写。多单词时每个单词都用下划线连接 XXX_YYY_ZZZ
- 命名的时候尽量见名知意

2.1.3 关键字

关键字的定义和特点：
- 定义：被 Java 语言赋予了特殊含义，用做专门用途的字符串
- 特点：关键字中所有的字母都为小写

用于定义关键数据类型的关键字classinterfaceenumbyteshortintfloatlongdoublecharbooleanvoid 用于定义流程控制的关键字ifelseswitchcasedefaultwhiledoforbreakcontinuereturn 用于定义访问权限修饰符的关键字privateprotectedpublic 用于定义类，函数，变量修饰符的关键字abstractfinalstaticsynchronized 用于定义类与类之间关系的关键字extendsimplements 用于定义建立实例及引用实例，判断实例的关键字newthissuperinstanceof 用于异常处理的关键字trycatchfinallythrowthrows 用于包的关键字packageimport 其他修饰符关键字nativestrictfptransientvolatileassert 用于定义数据类型值的字面值truefalsenull

保留字
- 定义：现有 Java 版本尚未使用
- goto、const

2.1.4 常量

常量就是在程序中固定不变的值，是不能改变的数据。

2.2 变量 2.2.1 变量的定义

变量的概念
- 内存中的一个存储区域
- 该区域的数据可以在同一类型范围内不断变化
- 变量是程序中最基本的储存单元。包含变量类型、变量名和存储的值
变量的作用
- 用于在内存中保存数据
使用变量注意
- Java 中每个变量必须先声明，后使用
- 使用变量名来访问这块区域的数据
- 变量的作用域：其定义所在的一对 {} 内
- 变量只有在其作用域内才有效
- 同一作用域内，不能定义重名的变量
在方法体外，类体内声明的变量称为成员变量
在方法体内部声明的变量称为局部变量

2.2.2 变量的数据类型

类型占用存储空间表数范围byte1 字节 = 8bit 位-128 ~ 127short2 字节-215 ~ 215 -1int4 字节-231 ~ 231 -1 (约21亿)long8 字节-263 ~ 263 -1单精度 float4 字节-3.403E38 ~ 3.403E38双精度 double8 字节-1.798E308 ~ 1.798E308

Java 的整型常量默认为 int 型，声明 long 型常量须后加 l 或者 L
Java 程序中变量通常声明为 int 型，除非不足以表示较大的数才使用 long
Java 的浮点型常量默认为 double 型**，**声明 float 型常量，须后加 f 或者 F
转义字符
转义字符说明b退格符n换行符r回车符t制表符"双引号'单引号\反斜线
boolean 类型数据只允许取值 true 和 false，无 null

2.2.3 变量的类型转换

在程序中，当把一种数据类型的值赋给另一种数据类型的变量时，需要进行数据类型转换。根据转换方式的不同，数据类型转换可分为两种：自动类型转换和强制类型转换。

自动类型转换
- 当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型
- byte short char --> int --> long --> float --> double
- 特别的：当 byte、char、short 三种类型的变量做运算时，结果为 int 型

强制类型转换

需要使用强转符：()
强制类型转换可能导致精度损失

例：

byte b1 = 10;
int i1 = 126;
byte b2 = (byte) (b1 + i1);

char c1 = 'a';
short s2 = 10;
short s3 = (short) (s2 + c1);

注意
- 整型常量，默认为 int 型
- 浮点型常量，默认为 double 型

2.2.4 变量的作用域

public static void main(String[] args) {
    int x = 12; //变量 x
    {
        int y = 20;
    }
    y = x; //将 x 的值赋给 y，但 y 出了它的作用域
}

2.3 运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等

分类：

算数运算符（Arithmetic operator）
赋值运算符（Assignment Operators）
比较运算符（Comparison operator）
逻辑运算符（Logical operator）
位运算符（Bitwise Operators）
三元运算符（Ternary operator）

2.3.1 算数运算符运算符运算范例结果+正号+33-负号b = 4; -b-4+加5+510-减5 - 41*乘5 * 210/除5 / 22%取模（取余）5 / 21++自增（前）：先相加后赋值
自增（后）：先赋值后相加a = 2; b = ++a;
a = 2; b = a++;a = 3; b = 3;
a = 3; b = 2;–自减（前）：先相减后赋值
自减（后）：先赋值后相减a = 2; b = --a;
a = 2; b = a–;a = 1; b = 1;
a = 1; b = 2;+字符串连接“Hell” + “o”“Hello”

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

        int num1 = 14;
        int num2 = 6;
        int num3 = 5;
        int num4 = -10;
        int num5 = -7;

        //除号：/
        int result1 = num1 / num2;
        System.out.println(result1);  //2

        double result2 = (double) num1 / num2;
        System.out.println(result2);  //2.3333333333333335

        //去余：%
        int result3 = num1 % num3;
        System.out.println(result3);  //4

        double result4 = num4 % num3;
        System.out.println(result4);  //0.0

        double result5 = num4 % num5;
        System.out.println(result5);  //-3.0


        //后 ++：先赋值后相加
        int a1 = 10;
        int a2 = a1++;
        System.out.println("a1 = " + a1 + "t" + "a2 = " + a2);

        //前 ++：先相加后赋值
        int a3 = 10;
        int a4 = ++a3;
        System.out.println("a3 = " + a3 + "t" + "a4 = " + a4);
    }
}

public class ArithmeticExercise {

    public static void main(String[] args) {
        int number = 157;

        int singleDigit = number % 10;
        System.out.println("个位数是：" + singleDigit);
        int tenDigits = number / 10 % 10;
        System.out.println("十位数是：" + tenDigits);
        int hundreds = number / 100;
        System.out.println("百位数是：" + hundreds);
    }
}

2.3.2 赋值运算符

public class AssignmentTest {

    public static void main(String[] args) {

        int number1 = 10;
        int number2;
        int number3 = 4;

        number2 = number1;
        System.out.println(number2);

        int result1 = number1-=number3;
        System.out.println(result1); //6

        number1 = 10;
        number3 = 4;
        number1 += number3;
        System.out.println(number1); //14

    }
}

2.3.3 比较运算符

比较运算符的结果是 boolean 类型

运算符运算范例结果==相等于4 == 3false!=不等于4 != 3true<小于4 < 3false>大于4 > 3true<=小于等于4 <= 3false>=大于等于4 >= 3trueinstanceof检查是否是类的对象“hello” instanceof Stringtrue

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

        int i = 10;
        int j = 12;

        System.out.println(i == j); //false
        System.out.println(i <= j); //true
    }
}

2.3.4 逻辑运算符

区分 & 与 &&
- 相同点：
  - & 和 && 的运算结果相同
  - 当符号左边是 true 时，二者都会执行符号右边的运算
- 不同点：
  - 当符号左边是 false 时，& 会继续执行符号右边的运算，&& 则不再执行符号右边的运算
区分 | 和 ||
- 相同点：
  - | 和 || 的运算结果相同
  - 当符号左边是 false 时，二者都会执行符号右边的运算
- 不同点：
  - 当符号左边是 true 时，| 会继续执行符号右边的运算，|| 则不再执行符号右边的运算

aba&ba&&ba|ba||b!aa^btruetruetruetruetruetruefalsefalsetruefalsefalsefalsetruetruefalsetruefalseturefalsefalsetruetruetruetruefalsefalsefalsefalsefalsefalsetruefalse

public class LogicalTest {

    public static void main(String[] args) {
        //& 和 && 的区别
        boolean b1 = true;
        b1 = false;
        int num1 = 10;
        if (b1 & (num1++ > 0)) {
            System.out.println("true");
        } else {
            System.out.println("false");
        }
        System.out.println("num1 = " + num1); //num1 = 11

        boolean b2 = true;
        b2 = false;
        int num2 = 10;
        if (b2 && (num2++ > 0)) {
            System.out.println("true");
        } else {
            System.out.println("false");
        }
        System.out.println("num2 = " + num2); //num2 = 10

        // | 和 || 的区别
        boolean b3 = true;
        int num3 = 10;
        if (b3 | (num3++ > 0)) {
            System.out.println("true");
        } else {
            System.out.println(false);
        }
        System.out.println("num3 = " + num3); //num3 = 11

        boolean b4 = true;
        int num4 = 10;
        if (b4 || (num4++ > 0)) {
            System.out.println("true");
        } else {
            System.out.println(false);
        }
        System.out.println("num4 = " + num4); //num4 = 10

    }
}

2.3.5 位运算符

位运算是直接对整数的二进制进行的运算

运算符运算范例细节<<左移3 << 2 = 12 --> 3 * 2 * 2 = 12空位补0，被移除的高位丢弃，空缺位补0。>>右移3 >> 1 = 1 --> 3/2=1被移位的二进制最高位是0，右移后，空缺位补0；
最高位是1，空缺位补1。>>>无符号右移3 >>> 1 = 1 --> 3/2=1被移位二进制最高位无论是0或者是1，空缺位都用0补。&与运算6 & 3 = 2二进制位进行&运算，只有1&1时结果是1，否则是0;|或运算6 | 3 = 7二进制位进行 | 运算，只有0 | 0时结果时0，否则是1^异或运算6 ^ 3 = 5相同二进制位进行 ^ 运算，结果是0；1^1=0 , 0^0=0
不相同二进制位 ^ 运算结果是1。1^0=1 , 0^1=1~取反运算~6 = -7正数取反，各二进制码按补码各位取反
负数取反，各二进制码按补码各位取反

public class BitwiseTest {
    public static void main(String[] args) {
        int i = 21;

        System.out.println("i << 2 = " + (i << 2));
        System.out.println("i << 3 = " + (i << 3));
        System.out.println("i >> 1 = " + (i >> 1));

        int m = 12;
        int n = 5;
        System.out.println("m & n = " + (m & n));
        System.out.println("m | n = " + (m | n));
        System.out.println("m ^ n = " + (m ^ n));

        //练习：交换两个变量的值
        int num1 = 10;
        int num2 = 20;

        //方式一：定义临时变量的方式
        int temp = num1;
        num1 = num2;
        num2 = temp;
        System.out.println(num1 + "t" + num2);

        //方式二：好处：不用定义临时变量
        //弊端：相加 *** 作可能超出存储范围；有局限性：只能适用于基本数据类型
        num1 += num2;
        num2 = num1 - num2;
        num1 = num1 - num2;
        System.out.println(num1 + "t" + num2);

        //方式三：使用位运算符
        //有局限性：只能适用于基本数据类型
        num1 = num1 ^ num2;
        num2 = num1 ^ num2;
        num1 = num1 ^ num2;
        System.out.println(num1 + "t" + num2);

    }
}

2.3.6 三元运算符

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

        //获取两个整数的较大值
        int m = 0;
        int n = 1;
        int x = 2;

        int max = Math.max(m, n);
        int max2 = m > n ? m: n;
        System.out.println(max2);

        String maxStr = m > n ? "m大" : n == m ? "m和n相等": "n大";
        System.out.println(maxStr);

        String str = m == 0 ? "老板":m == 1 ? "经理":"员工";
        System.out.println(str);

        //获取三个数中的最大值
        int n1 = 12;
        int n2 = 11;
        int n3 = 13;

        int maxN = ((n1 > n2 ? n1 : n2) > n3 ? n2 : (n3 > n1 ? n3 : n1));
        System.out.println(maxN);

        int maxN2 = n1 > n2 ? n1 : n2;
        int maxN3 = maxN2 > n3 ? maxN2 : n3;
        System.out.println(maxN3);

    }
}

2.4 选择结构语句 2.4.1 if 条件语句

if 条件语句指的是如果满足某种条件，就执行改分支下的语句

public class IfTest {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.print("请输入年龄：");
        String myAge = in.next();

        int age = Integer.parseInt(myAge);
        if (age <= 18) {
            System.out.println("禁止进入");
        }

        if (age >= 18) {
            System.out.println("你已成年");
        } else {
            System.out.println("未成年");
        }

        if (age < 0) {
            System.out.println("非法");
        } else if (age < 18) {
            System.out.println("青少年");
        } else if (age < 35) {
            System.out.println("青壮年");
        } else if (age < 60) {
            System.out.println("中年");
        } else {
            System.out.println("老年");
        }
        in.close();
    }
}

2.4.2 switch 条件语句

根据 switch 表达式中的值，依次匹配各个 case 中的常量。一旦匹配成功，则进入相应 case 结构中，调用其执行语句。当调用完执行语句以后，则仍然继续向下执行其他 case 结构中的执行语句，直道遇到 break 关键字或此 switch-case 结构末尾为止
break，可以使用在 switch-case 中，表示一旦执行到此关键字，就跳出
switch 结构中的表达式，只能是如下的 6种数据类型之一：byte、short、char、int、枚举类型（JDK5.0）、String 类型（JDK7.0）
case 之后只能声明常量。不能声明范围。
break 关键字是可选的
default：当其他 case 都不满足时则会执行

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

        int number = 2;

        switch (number) {

            case 0:
                System.out.println("zero");
                break;
            case 1:
                System.out.println("one");
                break;
            case 2:
                System.out.println("two");
                break;
            case 3:
                System.out.println("three");
                break;
            default:
                System.out.println("other");
        }
    }
}

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

        int score = 78;

        
        switch (score / 10) {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("不及格");
                break;
            case 6:
            case 7:
            case 8:
            case 9:
            case 10:
                System.out.println("及格");
                break;
        }

        //优解
        switch (score / 60) {
            case 0:
                System.out.println("不及格");
            case 1:
                System.out.println("及格");
        }
    }
}

2.5 循环结构语句 2.5.1 while 循环语句

while 循环结构的四个要素
- 初始化条件
- 循环条件
- 循环体
- 迭代条件

while 循环的结构

初始化条件
while(循环条件){
    循环体
    迭代条件
}
//先判断，后执行

**注意：**写 while 循环千万不要丢失了迭代条件，一旦丢失，将会导致死循环

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

        //遍历 100 以内的所有偶数
        int i = 1;
        while (i < 101) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
            i++;
        }
    }
}

2.5.2 do…while 循环语句

do-while 循环的四个要素
- 初始化条件
- 循环条件 --> 是boolean类型
- 循环体
- 迭代条件

do-while 的结构

初始化条件
do {
    循环体
    迭代条件
} while(循环条件);
//先执行，后判断条件

do-while 循环至少会执行一次循环体

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

        //打印 100 以内的偶数和
        int i = 1;
        int sum = 0;
        int count = 0;

        do {
            if (i % 2 == 0) {
                sum += i;
                count++;
            }
            i++;
        } while (i<101);

        System.out.println("总和为：" + sum);
        System.out.println("个数为：" + count);
    }
}

2.5.3 for 循环语句

语法格式

for(初始化条件;循环条件;迭代条件){
    循环体
}

使用 for 循环遍历 100 以内的偶数

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

        for (int i = 0; i < 5; i++) {
            System.out.println("Hello World!");
        }

        //例题：遍历 100 以内的偶数，输出所有偶数的和
        int sum = 0;
        int count = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                sum += i;
                count ++;
                System.out.println(i);
            }
        }
        System.out.println("总和为：" + sum);
        System.out.println("偶数的个数为：" + count);
    }
}

使用 for 循环请求最大公约数和最小公倍数

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

        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入数值1：");
        int m = scanner.nextInt();
        System.out.print("请输入数值2：");
        int n = scanner.nextInt();

        //获取两个数中的较小值
        int minNum = m >= n ? n: m;
        for (int i = minNum; i > 0; i--) {
            if (m % i == 0 && n % i == 0) {
                System.out.println(String.format("%d 和 %d 的最大公约数是：%d", m,n,i));
                break;
            }
        }

        int maxNum = m >= n ? m: n;
        for (int i = maxNum; i <= m * n; i++) {
            if (i % m == 0 && i % n == 0) {
                System.out.println(String.format("%d 和 %d 的最小公倍数是：%d", m,n,i));
                break;
            }
        }
    }
}

2.5.4 循环嵌套

使用 for 循环打印九九乘法表

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

        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + i * j + "t");
            }
            System.out.println();
        }
    }
}

使用 for 循环打印质数

public class PrimeNumberTest {

    public static void main(String[] args) {
        int count = 0; //记录素数的个数
        boolean isPrime = true;

        for (int i = 2; i < 10001; i++) {
            //优化二：对本身质数的自然数是有效的
            for (int j = 2; j < Math.sqrt(i); j++) {

                if (i % j == 0) {
                    isPrime = false;
                    break; //优化一：只对本身非质数的自然数是有效的
                }
            }
            if (isPrime) {
                count++;
//                System.out.println(i);
            }
            isPrime = true;
        }
        System.out.println("个数：" + count);
    }
}

public static void main(String[] args) {
        int count = 0; //记录素数的个数

        label:for (int i = 2; i < 10001; i++) {

            for (int j = 2; j < Math.sqrt(i); j++) {

                if (i % j == 0) {
                    continue label;
                }
            }
            //能执行到此步骤的，都是质数
            count++;
        }
        System.out.println("个数：" + count);
}

2.5.6 跳转关键字（break、continue）

break：结束当前循环
continue：结束本次循环
break 只能用于 switch 语句和循环语句中
continue 只能用于循环语句中
break、continue 之后不能有其他的语句，因为程序永远不会执行其后的语句

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

//        for (int i = 1; i < 11; i++) {
//
//            if (i % 4 == 0) {
                break; //123
//                continue; //123567910
//            }
//            System.out.println(i);
//        }

        lable:for (int i = 1; i <= 4; i++) {
            for (int j = 1; j <= 10; j++) {
                if (j % 4 == 0) {
//                    break; //默认跳出包裹此关键字最近的一层循环
//                    continue;
                    break lable; //结束指定标识层级的循环结构
                }
                System.out.println(i + "t" + j);
            }
        }
    }
}

衡量一个功能代码的优劣：

1.正确性（正确的实现功能）

2.可读性（让人看得懂）

3.健壮性（经得住考验）

4.高效率与低存储：时间复杂度与空间复杂度（衡量算法的好坏）

束当前循环

continue：结束本次循环
break 只能用于 switch 语句和循环语句中
continue 只能用于循环语句中
break、continue 之后不能有其他的语句，因为程序永远不会执行其后的语句

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

//        for (int i = 1; i < 11; i++) {
//
//            if (i % 4 == 0) {
                break; //123
//                continue; //123567910
//            }
//            System.out.println(i);
//        }

        lable:for (int i = 1; i <= 4; i++) {
            for (int j = 1; j <= 10; j++) {
                if (j % 4 == 0) {
//                    break; //默认跳出包裹此关键字最近的一层循环
//                    continue;
                    break lable; //结束指定标识层级的循环结构
                }
                System.out.println(i + "t" + j);
            }
        }
    }
}

衡量一个功能代码的优劣：

1.正确性（正确的实现功能）

2.可读性（让人看得懂）

3.健壮性（经得住考验）

4.高效率与低存储：时间复杂度与空间复杂度（衡量算法的好坏）

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/zaji/5672971.html

[JavaSE]第二章基本语法

发表评论

评论列表（0条）

[JavaSE]第二章 基本语法

发表评论

评论列表（0条）

[JavaSE]第二章基本语法