javajavase
尚硅谷宋红康第2章_Java基本语法(上)：变量与运算符.pdf

关键字和保留字

用于定义数据类型的关键字
class interface enum byte short
int long float double char
boolean void
用于定义流程控制的关键字
if else switch case default
while do for break continue
return
用于定义访问权限的关键字
public protected private
用于定义函数、变量、变量修饰符的关键字
abstract final static synchronized
用于定义类与类关系的关键字
extends implements
建立、引用、判断实例引用的关键字
new this super instanceof
用于处理异常的关键字
try catch finally throw throws
用于包的关键字
package import
其他修饰符关键字
native strictfp transient volatile assert

特点：组成关键字的字母全部小写
goto和const作为保留字存在
true false null不能被用于标志符名

标识符

就是给类，接口，方法，变量等起名字的字符序列
组成规则

  • 英文大小写字母（各种文字，但不要用）、数字、$和_
  • 不能以数字开头
  • 不能是java中的关键字
  • 大小写敏感，长度无限制
  • 不能使用空格

常见的命名规范(见名知意)

  • 包
    • 单级包小写：cess，com
    • 多级包小写，并用.隔开：com.cess，com.baidu （习惯域名反写）
  • 类或者接口
    • 一个单词：首字母大写：Student，Demo
    • 多个单词：每个单词首字母大写：HelloWorld，StudentName
  • 方法或者变量
    • 一个单词：首字母小写：name，main
    • 多个单词：从第二个单词开始，每个单词首字母大写：studentAge，showAllNames()
  • 常量
    • 全部大写：PI
    • 多个单词：用_隔开：STUDENT_MAX_AGE

常量

在程序执行的过程中，其值不发生改变的量
分类

  • 字面值常量
    • 整数常量 12、34，默认int型，加L是long
    • 小数常量 12.345，默认是double，加F是float
    • 布尔常量 true、false
    • 字符常量 ‘a’、’A’、’0’ 错误的：’ab’
    • 字符串常量 “hello”
    • 空常量 null
  • 符号常量
    • final关键字修饰

变量

概念

  • 代码一块内存空间，使用变量名来访问和使用这块内存空间
  • 用于保存数据

变量的三要素

  • 数据类型
  • 变量名
  • 值

特点

  • 里面的内容可以更改

  • 一个变量只能存一个值

    1. //方式一
    2.   数据类型 变量名 = 初始化值;
    3. //方式二
    4.   数据类型 变量名;
    5.   变量名 = 初始化值;
    6. //其中初始化值可以是(常量值，变量值，表达式)

    注意事项

  • 先声明后使用

  • 初始化值：局部变量没有初始化值不能直接使用，只要在使用前给值就行，推荐定义的时候就给值。一行建议只定义一个变量
  • 作用域： 变量定义在哪一级大括号中，哪个大括号的范围就是这个变量的作用域。相同的作用域中不能定义两个同名变量

分类1

  • 基本数据类型：
    • 整数类型：byte、short、int、long
    • 浮点类型：float、double
    • 字符型：char
    • 布尔型：boolean
  • 引用数据类型
    • 类（class）
    • 接口（interface）
    • 数组（array）

分类2

  • 局部变量：方法或语句块内， 必须要初始化
  • 成员变量
    • 实例变量：方法外部类内部，如果没有初始化会默认初始化
    • 静态变量：方法外部类内部用static修饰，从属于类，生命周期伴随类始终

基本数据类型间转换

boolean类型不参与转换

自动类型转换

默认转换

  • 存储容量小的值或变量赋值给存储容量大的，或者存储容量小的与存储容量大的进行混合运算，出现存储容量小的会自动转成存储容量大的类型

字段转换.png

  • byte short char ——> int ——> long ——>float ——>double
    • byte short char之间（包括俩同类型）不相互转换，直接转成int类型参与运算
    • 可以将整型常量直接赋值给byte、 short、 char等类型变量，而不需要进行强制类型转换，只要不超出其表数范围即可 ```java byte a = 3, b = 4, c; c = a + b; c = 3 + 4;

哪句编译失败，为什么？ c = a + b;编译失败，变量相加首先看类型，最终把结果赋值也会考虑类型问题 常量相加首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是才报错

  2.    - float、double类型的存储方式不一样，因此8个字节的long可以转成float而不会溢出
  3.    - float和double 存储是分为：符号位，指数部分，尾数部分
  4. <a name="4x2fB"></a>
  5. ### 强制类型转换
  6. ```java
  7. 目标数据类型 变量名 = (目标数据类型)(被转换的数据);
  • 把存储容量大的常量值/变量/表达式的值赋值给存储容量小的变量时
  • 可能会有精度的损失，一般不建议这样使用 ```java byte b = 130; //而130不在此范围内，所以报错 byte b = (byte)130; //我们可以使用强制类型转换 System.out.println(b); //结果是多少呢?

分析过程： 我们要想知道结果是什么就应该知道是如何进行计算的,而我们又知道计算机中数据的运算都是补码进行的。 而要得到补码，首先要计算出数据的二进制。 获取130这个数据的二进制。 00000000 00000000 00000000 10000010这是130的原码，也是反码，还是补码 做截取操作，截成byte类型的了 10000010 这个结果是补码 已知补码求原码 符号位 数值位 补码： 1 0000010 反码： 1 0000001 原码： 1 1111110

  1. ```java
  2. int money = 1000000000;     //10亿
  3. int years = 20;
  4. int total = money * years;    //返回的total是负数，超过了int的范围
  5. System.out.println("total=" + total); //-1474836480
  7. long total1 = money * years;
  8. //返回的total仍然是负数。默认是int，因此结果会转成int值，再转成long。但是已经发生了数据丢失
  9. //因为低32位最高位是1，所以高32位全部补1
  10. System.out.println("total1="+total1); //-1474836480
  12. long total2 = money * ((long)years);
  13. //返回的total2正确:先将一个因子变成long，整个表达式发生提升。全部用long来计算
  14. System.out.println("total2="+total2); //20000000000

进制

常见进制

  • 二进制 由0，1组成。以0b开头
  • 八进制 由0，1，…7组成。以0开头
  • 十进制 由0，1，…9组成。整数默认是十进制
  • 十六进制 由0，1，…9，a，b，c，d，e，f(大小写均可)组成。以0x开头

所有数字在计算机底层都以二进制形式存在

  • Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位
  • 当是long类型时，二进制默认占64位，第64位是符号位

二进制的整数有如下三种形式

  • 原码：直接将一个数值换成二进制数。最高位是符号位
  • 负数的反码：是对原码按位取反，只是最高位(符号位)确定为1
  • 负数的补码：其反码加1

计算机以二进制补码的形式保存所有的整数

  • 正数的原码、反码、补码都相同
  • 负数的补码是其二进制取反+1

运算符

就是对常量和变量进行操作的符号

算术运算符

+ - * / % ++ —

  • +和-
    • 正负号
    • 两边都没有字符串类型的时候 是数字的加减法运算
    • 当其中某一边有字符串类型的时候 + 链接字符
  • /和%的区别
    • 数据做除法操作的时候，/取得是商，%取得是余数，余数符号与被除数相同
  • ++和—的用法
    • 自增或者自减，自增不会改变数据类型
    • 单独使用，a++与++a效果一样
    • 参与操作使用，放在操作数的前面：先自增或者自减，再参与操作 ```java int a = 10; int b = a++; //10

int x = 4; int y = (x++) + (++x) + (x*10); //x = 6 y = 4+6+60

byte aa = 127; aa++; //自加不改变数据类型，编译不报错。aa = -128

  1. <a name="1rwCb"></a>
  2. ### 赋值运算符
  3. **=    +=    -=    *=    /=    %=**
  5. - =叫做赋值运算符，也是最基本的赋值运算符
  7. int x = 10; 把10赋值给int类型的变量x
  9. - 扩展赋值运算符的特点：**隐含了自动强制转换**
  11. short s = 1;<br />s += 1; **不会改变数据类型**，等价于 s = (s的数据类型)(s + 1);
  12. <a name="DonAl"></a>
  13. ### 关系运算符
  14. **==    !=    >    >=    <    <=    instanceof**
  16. - 无论运算符两端简单还是复杂最终结果是boolean类型
  17. - 不要把==写成了=
  18. <a name="f8Q96"></a>
  19. ### 逻辑运算符
  20. **&    |    !    ^    &&    ||**
  22. - 逻辑运算符一般用于连接boolean类型的表达式或者值
  23.    - 表达式
  25. 就是用运算符把常量或者变量连接起来的符合java语法的式子<br />算术表达式：a + b<br />比较表达式：a == b
  27. - 规则
  28.    - &    有false则false
  29.    - |    有true则true
  30.    - !    非true则false，非false则true。偶数个不改变本身
  31.    - ^    相同则false，不同则true。举例：情侣关系。男男,男女,女男,女女
  32.    - &&    结果和&是一样的，只不过有短路效果。左边是false，右边不执行
  33.    - ||    结果和|是一样的，只不过有短路效果。左边是true，右边不执行
  34.    - 开发中常用的逻辑运算符：&&，||，!
  35. <a name="L1TpJ"></a>
  36. ### 位运算符
  38. - 规则
  39.    - &    1 & 1结果才为1，其他都是0
  40.    - |    0 | 0结果采为0，否则都是1
  41.    - ^    1 ^ 0 或 0 ^ 1是1，其他都是0
  42.    - ~    ~1就是0，~0就是1
  43.    - <<    左移左边最高位丢弃，右边补齐0
  44.    - >>    右移。最高位是0，左边补齐0；最高为是1，左边补齐1
  45.    - >>>无符号右移。无论最高位是0还是1，左边补齐0
  46. - 注意：二进制的补码运算
  47. ```java
  48. 3的二进制
  49.     00000000 00000000 00000000 00000011
  50. 4的二进制
  51.     00000000 00000000 00000000 00000100
  52. &位与运算：有0则0
  53.     00000000 00000000 00000000 00000011
  54.    &00000000 00000000 00000000 00000100
  55.     -----------------------------------
  56.     00000000 00000000 00000000 00000000    结果是0
  57. |位或运算：有1则1
  58.     00000000 00000000 00000000 00000011
  59.    |00000000 00000000 00000000 00000100
  60.     -----------------------------------
  61.     00000000 00000000 00000000 00000111    结果是7
  62. ^位异或运算：相同则0，不同则1
  63.     00000000 00000000 00000000 00000011
  64.    &00000000 00000000 00000000 00000100
  65.     -----------------------------------
  66.     00000000 00000000 00000000 00000111    结果是7
  67. ~按位取反运算：0变1，1变0
  68.     00000000 00000000 00000000 00000011
  69.    ~11111111 11111111 11111111 11111100(补码)
  70. 求源码
  71.     11111111 11111111 11111111 11111011(反码)
  72.     10000000 00000000 00000000 00000100    结果是-4

  • ^的特殊用法：一个数据针对另一个数据位异或两次，该数不变

    1. int a = 10;
    2. int b = 20;
    3. System.out.println(a^b^b);//10
    4. System.out.println(a^b^a);//20
    1. 实现两个变量的交换
    2. 位异或运算：只能用于数值型
    3.   a = a ^ b;
    4.   b = a ^ b;
    5.   a = a ^ b;
    6. 变量相加：只能用于数值型，且容易益处
    7.   a = a + b;
    8.   b = a - b;
    9.   a = a - b;
    10. 最高效的2乘8运算
    11.   2<<3

  • 注意：以上所有运算符都是针对基本数据类型，特殊的：

      • 可以用于字符串的拼接
    • == 可以用于引用数据类型的“地址”的比较
    • = 可以用于引用数据类型变量的赋值

      三元运算符

      1. 比较表达式? 表达式1: 表达式2;

  • 执行流程

    • 首先计算比较表达式的值，看是true还是false
    • 如果是true，表达式1就是结果
    • 如果是false，表达式2就是结果

  • 表达式1跟表达式2需要一致(注意自动转型)，三元运算符可以嵌套

    运算符的优先级

  • 赋值<三目<逻辑<关系<算术<单目<( )

  • 大家不需要去刻意的记这些优先级，表达式里面优先使用小括号来组织！！逻辑与、逻辑或、逻辑非的优先级一定要熟悉！(逻辑非>逻辑与>逻辑或)如：a||b&&c的运算结果是：a||(b&&c)，而不是(a||b)&&c

Scanner

实际开发中，数据是变化的，为了提高程序的灵活性，加入键盘录入数据

  1. improt java.util.Scanner;
  2. Scanner sc = new Scanner(System.in);
  3. int x = sc.nextInt();
  4. String y = sc.nextLine();