[JavaSE]第二章 基本语法

[JavaSE]第二章 基本语法,第1张

[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

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-12-16
下一篇 2022-12-16

发表评论

登录后才能评论

评论列表(0条)

保存