java基础学习（一）

java基础学习（一）

一、注释
二、标识符
三、常量和常量值
四、变量
五、数据类型
六、算数运算符
七、直接量
八、流程控制语句

自我学习记录，想要全面学习请访问原作者网站，链接地址http://c.biancheng.net/java/10/

一、注释

  • 单行注释：//

  • 多行注释：/* */

  • 文档注释：/** */

二、标识符

  1. 关键字：特殊的标识符，对编译器有特殊的意义，共51个
    • 数据类型：boolean、int、long、short、byte、float、double、char、class、interface。
    • 流程控制：if、else、do、while、for、switch、case、default、break、continue、return、try、catch、finally。
    • 修饰符：public、protected、private、final、void、static、strict、abstract、transient、synchronized、volatile、native。
    • 动作：package、import、throw、throws、extends、implements、this、supper、instanceof、new。
    • 保留字：true、false、null、goto、const。
  2. 标识符组成
    • 标识符开头为：字母（A~Z 和 a~z）、美元符号（$）、下划线（_）、人民币符号（¥）
    • 标识符后面为：数字（09）和字母（AZ 和 a~z）、美元符号（$）、下划线（_）、人民币符号（¥）以及 Unicode 字符集中符号大于 0xC0 的所有符号组合构成（各符号之间没有空格）
    • 区分大小写
  3. 标识符用途
    • 用来命名常量、变量、类和类的对象等
  4. 关键字不能用于自定义标识符

三、常量和常量值

  1. 常量：程序运行过程中保持不变的量，是形式化的

  2. 常量值：常量的具体数值

  3. 种类：

    • 整形：
      • 整型：int，32位，4字节
      • 长整型：long，64位，8字节，表示时要加L或1
      • 十进制数形式：如 54、-67、0。
      • 八进制数形式：Java 中的八进制常数的表示以 0 开头，如 0125 表示十进制数 85，-013 表示十进制数 -11。
      • 十六进制数形式：Java 中的十六进制常数的表示以 0x 或 0X 开头，如 0x100 表示十进制数 256，-0x16 表示十进制数 -22。
    • 实型：
      • 单精度型：float，32位，表示时后面加F或f，最多表示6或7位十进制有效数字
      • 双精度型：double，64位，最多表示15或16位十进制有效数字
      • 十进制数形式：由数字和小数点组成，且必须有小数点，如 12.34、-98.0。
      • 科学记数法形式：如 1.75e5 或 32&E3，其中 e 或 E 之前必须有数字，且 e 或 E 之后的数字必须为整数。
    • 布尔型：
      • boolean： false（假）和 true（真）
    • 字符型和字符串：
      • 字符型：char，单引号表示
      • 字符串：string，双引号表示

  4. 常量定义：

    1. public class HelloWorld {
    // 静态常量
    public static final double PI = 3.14;
    // 声明成员常量
    final int y = 10;

    public static void main(String[] args) {
        // 声明局部常量
        final double x = 3.3;
    }
}
      • 静态常量可以使用类名访问
      • 常量不可修改
      • 语法：final dataType variableName = value
      • 常量名定义要用大写
      • final 关键字不仅可以用来修饰基本数据类型的常量，还可以用来修饰对象的引用或者方法

四、变量

  1. 变量：变量的值在程序运行期间可以被修改

  2. 语法：

    DataType identifier;

    或者

    DataType identifier=value;

  3. 注意：

    • 变量是类或者结构中的字段，如果没有显式地初始化，默认状态下创建变量并默认初始值为 0。
    • 方法中的变量必须显式地初始化，否则在使用该变量时就会出错。

五、数据类型

  1. 基本数据类型：

    类型名称 关键字 占用内存 取值范围
    字节型 byte 1 字节 -128~127
    短整型 short 2 字节 -32768~32767
    整型 int 4 字节 -2147483648~2147483647
    长整型 long 8 字节 -9223372036854775808L~9223372036854775807L
    单精度浮点型 float 4 字节 +/-3.4E+38F（6~7 个有效位）
    双精度浮点型 double 8 字节 +/-1.8E+308 (15 个有效位）
    字符型 char 2 字节 ISO 单一字符集
    布尔型 boolean 1 字节 true 或 false

  2. 引用数据类型：

  3. 数据类型转换会有以下问题：

    • byte类型在表达式运算时会自动转换为int类型、
    • char 自动转换成 int、long、float 和 double，但 byte 和 short 不能自动转换为 char，而且 char 也不能自动转换为 byte 或 short
    • 数值型数据的转换：byte→short→int→long→float→double，不会丢失精度，反向会丢失精度
    • 强制类型转换的语法：(type)variableName
    • 因为二进制精度的问题，十进制的0.9，在float时，它是0.89999998，在double时，它是0.90000000000000002，所以浮点数运算时会出现误差

六、算数运算符

  1. 一元运算符

    运 算 符 名 称 说 明 例 子
    - 取反符号 取反运算 b=-a
    ++ 自加一 先取值再加一，或先加一再取值 a++ 或 ++a
    -- 自减一 先取值再减一，或先减一再取值 a-- 或 --a

  2. 二元运算符

    运 算 符 名 称 说 明 例 子
    + 加 求 a 加 b 的和，还可用于 String 类型，进行字符串连接操作 a + b
    - 减 求 a 减 b 的差 a - b
    * 乘 求 a 乘以 b 的积 a * b
    / 除 求 a 除以 b 的商 a / b
    % 取余 求 a 除以 b 的余数 a % b

  3. 算术赋值运算符

    运 算 符 名 称 例 子
    += 加赋值 a += b、a += b+3
    -= 减赋值 a -= b
    *= 乘赋值 a *= b
    /= 除赋值 a /= b
    %= 取余赋值 a %= b

  4. 逻辑运算符

    运算符 用法 含义 说明 实例 结果
    && a&&b 短路与 ab 全为 true 时，计算结果为 true，否则为 false。 2>1&&3<4 true
    || a||b 短路或 ab 全为 false 时，计算结果为 false，否则为 true。 2<1||3>4 false
    ! !a 逻辑非 a 为 true 时，值为 false，a 为 false 时，值为 true !(2>4) true
    | a|b 逻辑或 ab 全为 false 时，计算结果为 false，否则为 true 1>2|3>5 false
    & a&b 逻辑与 ab 全为 true 时，计算结果为 true，否则为 false 1<2&3<5 true

    注意：

    • && 与 & 区别：如果 a 为 false，则不计算 b（因为不论 b 为何值，结果都为 false）

    • || 与 | 区别：如果 a 为 true，则不计算 b（因为不论 b 为何值，结果都为 true）

    • 逻辑运算符的优先级为：！运算级别最高，&& 运算高于 || 运算。！运算符的优先级高于算术运算符，而 && 和 || 运算则低于关系运算符。结合方向是：逻辑非（单目运算符）具有右结合性，逻辑与和逻辑或（双目运算符）具有左结合性。

  5. 关系运算符

    运算符 含义 说明 实例 结果
    > 大于运算符 只支持左右两边操作数是数值类型。如果前面变量的值大于后面变量的值， 则返回 true。 2>3 false
    >= 大于或等于运算符 只支持左右两边操作数是数值类型。如果前面变量的值大于等于后面变量的值， 则返回 true。 4>=2 true
    < 小于运算符 只支持左右两边操作数是数值类型。如果前面变量的值小于后面变量的值，则返回 true。 2<3 true
    <= 小于或等于运算符 只支持左右两边操作数是数值类型。如果前面变量的值小于等于后面变量的值， 则返回 true。 4<=2 false
    == 相等运算符 如果进行比较的两个操作数都是数值类型，无论它们的数据类型是否相同，只要它们的值相等，也都将返回 true。 如果两个操作数都是引用类型，只有当两个引用变量的类型具有父子关系时才可以比较，只要两个引用指向的不是同一个对象就会返回 true。 Java 也支持两个 boolean 类型的值进行比较。 44 97'a' 5.05 truefalse true true true false
    != 不相等运算符 如果进行比较的两个操作数都是数值类型，无论它们的数据类型是否相同，只要它们的值不相等，也都将返回 true。 如果两个操作数都是引用类型，只有当两个引用变量的类型具有父子关系时才可以比较，只要两个引用指向的不是同一个对象就会返回 true。 4!=2 true
    • 注意点：关系运算符的优先级为：>、<、>=、<= 具有相同的优先级，并且高于具有相同优先级的 !=、==。关系运算符的优先级高于赋值运算符而低于算术运算符，结合方向是自左向右。

  6. 位逻辑运算符

    运算符 含义 实例 结果
    & 按位进行与运算（AND） 4 & 5 4
    | 按位进行或运算（OR） 4 | 5 5
    ^ 按位进行异或运算（XOR） 4 ^ 5 1
    ~ 按位进行取反运算（NOT） ~ 4 -5

    注意：&（与）、|（或）、~（非）和 ^（异或）。除了 ~（即位取反）为单目运算符外，其余都为双目运算符

  7. 位移运算符

    运算符 含义 实例 结果
    » 右移位运算符 8»1 4
    « 左移位运算符 9«2 36

    注意：左移表示乘2，右移表示除2

  8. 复合位赋值运算符

    运算符 含义 实例 结果
    &= 按位与赋值 num1 &= num2 等价于 num 1=num 1 & num2
    |= 按位或赋值 num1 |= num2 等价于 num 1=num 1 | num2
    ^= 按位异或赋值 num1 ^= num2 等价于 num 1=num 1 ^ num2
    -= 按位取反赋值 num1 ~= num2 等价于 num 1=num 1 ~ num2
    «= 按位左移赋值 num1 «= num2 等价于 num 1=num 1 « num2
    »= 按位右移赋值 num1 »= num2 等价于 num 1=num 1 » num2

  9. 三目运算符

    语法：result = ? :

    注意：条件运算符优先级大于赋值运算符

七、直接量

关于字符串直接量有一点需要指出，当程序第一次使用某个字符串直接量时，Java 会使用常量池（constant pool）来缓存该字符串直接量，如果程序后面的部分需要用到该字符串直接量时，Java 会直接使用常量池（constantpool）中的字符串直接量。

提示：

  • 由于 String 类是一个典型的不可变类，因此 String 对象创建出来的就不可能改变，因此无需担心共享 String 对象会导致混乱。
  • 常量池（constant pool）指的是在编译期被确定，并被保存在已编译的 .class 文件中的一些数据，它包括关于类、方法、接口中的常量，也包括字符串直接量。

看如下程序：

String s0 = "hello";String s1 = "hello";String s2 = "he" + "llo";System.out.println(s0 == s1);System.out.println(s0 == s2);

运行结果为：

true
true

Java 会确保每个字符串常量只有一个，不会产生多个副本。例子中的 s0 和 s1 中的“hello”都是字符串常量，它们在编译期就被确定了，所以 s0 = s1 返回 true。而“he”和“llo”也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它本身也是字符串常量，s2 同样在编译期就被解析为一个字符串常量，所以 s2 也是常量池中“hello”的引用。因此，程序输出 s0 == s1 返回 true，s1 == s2 也返回 true。

八、流程控制语句

  1. if语句和switch语句的区别：

    • switch语句比if语句效率高，因为：当编译一个 switch 语句时，Java 编译器将检查每个 case 常量并且创造一个“跳转表”，这个表将用来在表达式值的基础上选择执行路径。因此，如果你需要在一组值中做出选择，switch 语句将比与之等效的 if-else 语句快得多。说人话就是switch语句只需要值判断，不需要判断类型了，因为case都是同类型的。
    • 多分支常用switch，但if更常用，视具体情况。

  2. switch语句中：

    • 表达式支持：
      • byte，short，int，char类型
      • Java7 增强了 switch 语句的功能，允许 switch 语句的控制表达式是 java.lang.String 类型的变量或表达式。只能是 java.lang.String 类型，不能是 StringBuffer 或 StringBuilder 这两种字符串的类型。
    • case支持：
      • 类型为 char、byte、 short 或 int 的常量表达式。
      • 枚举常量。
      • 从 Java SE 7 开始， case 标签还可以是字符串字面量。

  3. 循环语句：

    1. do {
    语句块;
}while(条件表达式);

    2. while(条件表达式) {
    语句块;
}

    3. 区别：do-while不管对错都会执行一次循环体，while只有对时执行循环

  4. for、do-while和while的区别：

    • 名称 概念 适用场景 特点
      for 根据循环次数限制做多少次重复操作 适合循环次数是已知的操作 初始化的条件可以使用局部变量和外部变量使用局部变量时，控制执行在 for 结束后会自动释放，提高内存使用效率。且变量在 for 循环结束后，不能被访问。先判断，再执行
      while 当满足什么条件的时候，才做某种操作 适合循环次数是未知的操作 初始化的条件只能使用外部变量，且变量在 while 循环结束后可以访问先判断，再执行
      do-while 先执行一次，在判断是否满足条件 适合至少执行一次的循环操作 在先需要执行一次的情况下，代码更加简洁。先执行一次，再判断

  5. foreach 循环语句：

    • foreach 循环语句是 Java 1.5 的新特征之一，在遍历数组、集合方面，foreach 为开发者提供了极大的方便。foreach 循环语句是 for 语句的特殊简化版本，主要用于执行遍历功能的循环。

      foreach 循环语句的语法格式如下：

      for(类型 变量名:集合) {
    语句块;
}

  6. return语句：

    • return 语句的一般语法格式如下：

      return 与方法相同类型的变量;

  7. 使用 break 语句实现 goto 的功能（break 带标签）

    • 标签 break 语句的通用格式如下：

      break label;

    • 下面是使用带标签的break 语句的示例。

      public class GotoDemo {
    public static void main(String[] args) {
        label: for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 8; j++) {
                System.out.println(j);
                if (j % 2 != 0) {
                    break label;
                }
            }
        }
    }
}

      以上程序的执行结果为：

      0
1

      这里的 label 是标签的名称，可以为 Java 语言中任意合法的标识符。标签语句必须和循环匹配使用，使用时书写在对应的循环语句的上面，标签语句以冒号结束。如果需要中断标签语句对应的循环，可以采用 break 后面跟标签名的方式。

      如在上面代码中，当 j 为 1 时，“j%2!=0”条件表达式成立，则 label 标签所代表的最外层循环终止。

      注意：通常紧跟 break 之后的标签，必须在 break 所在循环的外层循环之前定义才有意义。

  8. continue 语句:

    • continue 语句是跳过循环体中剩余的语句而强制执行下一次循环，其作用为结束本次循环，即跳过循环体中下面尚未执行的语句，接着进行下一次是否执行循环的判定。

      continue 语句类似于 break 语句，但它只能出现在循环体中。它与 break 语句的区别在于：continue 并不是中断循环语句，而是中止当前迭代的循环，进入下一次的迭代。简单来讲，continue 是忽略循环语句的当次循环。

      注意：continue 语句只能用在 while 语句、for 语句或者 foreach 语句的循环体之中，在这之外的任何地方使用它都会引起语法错误。

      在循环体中使用 continue 语句有两种方式可以带有标签，也可以不带标签。语法格式如下：

      continue //不带标签
      continue label //带标签，label是标签名

    • 下面看一个示例，代码如下：

      int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
for (int i = 0; i < numbers.length; i++) {    
if (i == 3) {        
continue;    
}    
System.out.println("Count is: " + i);
}

      在上述程序代码中，当条件 i==3 的时候执行 continue 语句，continue 语句会终止本次循环，循环体中 continue 之后的语句将不再执行，接着进行下次循环，所以输出结果中没有 3。程序运行结果如下：

      Count is: 0
      Count is: 1
      Count is: 2
      Count is: 4
      Count is: 5
      Count is: 6
      Count is: 7
      Count is: 8
      Count is: 9

带标签的 continue 语句示例代码如下：

     public static void main(String[] args) {    
    label1: for (int x = 0; x < 5; x++) {      
             for (int y = 5; y > 0; y--) {       
                 if (y == x) {       
                     continue label1;      
                 }         
                 System.out.println(x+","+y);     
             }   
         }    
         System.out.println("Game Over!");}

 默认情况下，continue 只会跳出最近的内循环（代码第 3 行的 for 循环），如果要跳出代码第 2 行的外循环，可以为外循环添加一个标签 label1，然后在第 5 行的 continue 语句后面指定这个标签 label1，这样当条件满足执行 continue 语句时，程序就会跳转出外循环。
 
 程序运行结果如下：
 
 0,5
 0,4

0,3
0,2
0,1
1,5
1,4
1,3
1,2
2,5
2,4
2,3
3,5
3,4
4,5
Game Over!

 由于跳过了 x == y，因此下面的内容没有输出。
 
 1,1
 2,2
 3,3
 4,4

接下来看Java基础学习（二）

posted @ 2021-04-03 14:12  那木  阅读(97)  评论(0)    收藏  举报