Java基础学习笔记-第1章

一、知识储备

1. 比特 (bit)和字节 (byte)

• 一个0或者一个1存储为一个比特(bit)，是计算机中最小的存储单位
• 字节 (byte) 是计算机中最基础的存储单元，每个字节由8个比特 (bit) 构成

2. 内存 (RAM)

• 内存由一个有序的字节序列组成，用于存储程序及程序需要的数据
• 一个程序和它的数据在被CPU执行前必须移植到计算机的内存中
• 每个字节都有一个唯一的地址，使用这个地址来确定字节的位置，便于存储和获取数据
• 一个计算机具有的RAM越多，它的运行速度越快，但是此规律是有限的
• 内存是带电存储的，一旦断电数据就会丢失，而且容量有限，所以长时间存储程序或数据需要使用硬盘
• 内存的两个作用
  1. 保存从硬盘读取的数据，提供给CPU使用
  2. 保存CPU的一些临时执行结果，以便CPU下次使用或保存到硬盘

3. 操作系统

• 操作系统是运行在计算机上的最重要的程序，它可以管理和控制计算机的活动

4. 注释

// 这是单行注释

/*
这是多行注释
这是多行注释
这是多行注释
*/

/**
 * @ClassName TODOr
 * @Description TODO
 * @Authjor TODO
 * @Date TODO
 * @Version TODO
 * 这是文档注释
 * 文档注释的内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档
 */

 二、基本语法-变量与运算符

1. 关键字

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

2. 保留字

• 定义：现有Java版本尚未使用，但以后版本可能会作为关键字使用，如goto和const

3. 标识符

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

  • /*
    pers：独立完成，公开，版权主要属于个人
    模板：包名为pers.个人名.项目名.模块名*.*.*
    */
    
    /*
    priv：独立完成，非公开，版权属于个人
    模板：包名为priv.个人名.项目名.模块名*.*.*
    */
    
    /*
    indi：多人完成，版权属于发起者
    模板：包名为indi.发起者名.项目名.模块名*.*.*
    */
    
    /*
    team：由团队发起，版权属于团队所有
    模板：包名为team.团队名.项目名.模块名*.*.*
    */
    
    /*
    com：由公司发起，版权由项目发起的公司所有
    模板：包名为com.公司名.项目名.模块名*.*.*
    */

4. 变量

• 定义：内存中的一个存储区域，该区域的数据可以是在同一类型范围内不断变化
• 特点：变量是程序中最基本的存储单元，包含变量类型、变量名和存储的值
• 作用：用于在内存中保存数据
• 使用变量时注意
  1. Java中每个变量必须先声明，后使用
  2. 使用变量名来访问这块区域的数据
  3. 变量的作用域是其定义所在的一对{ }内
  4. 变量只有在其作用域内才有效
  5. 同一个作用域内，不能定义重名的变量

5. 变量的类型

• 按数据类型
  • 对于每一种数据都定义了明确的具体数据类型 (强类型语言)，在内存中分配了不同大小的内存空间
  • 声明long型变量时，需要以'l'或'L'结尾
  • 浮点类型中，float为单精度，占用4字节的存储空间，尾数可以精确到7位有效数字
  • 浮点类型中，double为双精度，占用8字节的存储空间，精度是float的两倍
  • Java的浮点型常量默认为double型，其中，声明float型常量，需要以'f'或'F'结尾
  • 定义浮点型变量时，通常使用double型，若需要定义float型变量，需要以'f'或'F'结尾
  • 定义char型变量时，通常使用一对' '

•  按声明位置
  • 在方法体外，类体内，声明的变量称为成员变量
  • 在方法体内，声明的变量称为局部变量
  • 注意：同：二者都有生命周期  异：局部变量除形参外，需要显式初始化

 

6. 基本数据类型之间的运算规则

• 前提：只讨论7种基本数据类型变量间的运算，不包含boolean类型
• 自动类型提升
  • 当容量小的数据类型变量与容量大的数据类型变量做运算时，结果自动提升为容量大的数据类型
  • 此时的容量大小指的是，表示数的范围的大小
  • byte、char、short --> int --> long --> float --> double
  • 特别地，当byte、char、short这3种类型的变量做运算时，结果均为int型
• 强制类型转换
  • 自动类型提升运算的逆运算
  • 需要使用强转符：( )
  • 可能会导致精度损失

  • class CastTest {
        public static void main(String[] args) {
            //强制类型转换示例1，且有精度损失
            double a = 12.9;
            int b = (int)a; //强制类型转换为截断操作
            System.out.println(b); //输出为12
    
            //强制类型转换示例2，且没有精度损失
            long c = 123;
            short d = (short)c;
    
            //强制类型转换示例3，且有精度损失
            int e = 128;
            byte f = (byte)e;
            System.out.println(f); //输出为-128
        }
    }

7. 字符串类型String

• String属于引用数据类型，不属于基本数据类型
• 声明String型变量时，使用一对" "
• String型变量可以和8种基本数据类型做运算，且运算只能做连接运算，使用+，运算结果仍然是String类型

8. 进制

• 所有数字在计算机底层都以二进制形式存在
• 对于整数，有4种表示方式
  • 二进制 (binary)：0, 1，满2进1，以0b或0B开头
  • 十进制 (decimal)：0-9，满10进1
  • 八进制 (octal)：0-7，满8进1，以数字0开头
  • 十六进制 (hex)：0-9及A-F，满16进1，以0x或0X开头，此处的A-F不区分大小写

二进制	八进制	十进制	十六进制
0	0	0	0
1	1	1	1
10	2	2	2
11	3	3	3
100	4	4	4
101	5	5	5
110	6	6	6
111	7	7	7
1000	10	8	8
1001	11	9	9
1010	12	10	A
1011	13	11	B
1100	14	12	C
1101	15	13	D
1110	16	14	E
1111	17	15	F
10000	20	16	10
10001	21	17	11

9. 运算符

• 算术运算符
  • +(正) -(负) + - * / % (前)++ (后)++ (前)-- (后)-- +(连接)

  • class ArithmeticOperatorTest {
        public static void main(String[] args) {
            //(前)++：先自增1，后运算
            //(后)++：先运算，后自增1
            int a1 = 10;
            int b1 = ++a1;
            System.out.println(a1); //输出11
            System.out.println(b1); //输出11
            
            int a2 = 10;
            int b2 = a2++;
            System.out.println(a2); //输出11
            System.out.println(b2); //输出10
    
            //(前)++和(后)++中自增1不会改变变量本身的数据类型
        }
    }

• 赋值运算符
• 比较运算符 (关系运算符)
• 逻辑运算符
  • 区别逻辑与 (&) 和短路与 (&&)
    • 相同点1：&和&&的运算结果相同
    • 相同点2：当符号左边是true时，二者都会执行符号右边的运算
    • 不同点：当符号左边时false时，& 会继续执行符号右边的运算，而&&则不会
    • 开发中推荐使用短路与 (&&)，逻辑或 (|) 和短路或 (||) 同理
• 位运算符 (很少用)
• 三元运算符
  • 格式：(条件表达式)?表达式1: 表达式2;
  • 若条件表示为true，则执行表达式1；若条件表示为false，则执行表达式2
  • 凡是可以使用三元运算符的地方，都可以改写为if-else

三、基本语法-程序流程控制

1. 3种基本的流程结构

• 顺序结构
  • 程序从上到下逐行地执行，中间没有任何判断和跳转
• 分支结构
  • 根据条件，选择性地执行某段代码
  • 有if...else和switch...case这2种分支语句
• 循环结构
  • 根据循环条件，重复性地执行某段代码
  • 有while、do...while和for这3种循环语句
  • JDK1.5提供了foreach循环语句，方便遍历集合和数组元素

2. 使用Scanner从键盘获取数据

/*
如何从键盘获取不同类型的变量：需要使用Scanner类

具体实现步骤：
1. 导包：import java.util.Scanner;
2. Scanner的实例化：Scanner scan = new Scanner(System.in);
3. 调用Scanner类的相关方法 (next() / nextXxx())，来获取指定类型的变量
*/

import java.util.Scanner;

class ScannerTest {
    public static void main(String[] args) {
        //Scanner的实例化
        Scanner scan = new Scanner(System.in);
        //调用Scanner类的相关方法，来获取int类型的变量
        int num = scan.nextInt();
        System.out.println(num);

        //调用Scanner类的相关方法，来获取double类型的变量
        double a = scan.nextDouble();
        //调用Scanner类的相关方法，来获取String类型的变量
        String b = scan.next();
    }
}

3. if-else结构

//if语句的3种格式

//第1种
if(条件表达式) {
    执行代码块;
}

//第2种
if(条件表达式) {
    执行代码块1;
}
else {
    执行代码块2;
}

//第3种
if(条件表达式1) {
    执行代码块1;
}
else if(条件表达式2) {
    执行代码块2;
}
else {
    执行代码块3;
}

4. switch-case结构

//switch-case结构
switch(表达式) {
    case 常量1:
        执行语句1;
        //break;
    case 常量2:
        执行语句2;
        //break;
    ... ...
    case 常量n:
        执行语句n;
        //break;
    default: //前n个case都不匹配，则执行default，default结构是可选的，且位置是灵活的
        执行语句n+1;
        //break;
}

• 根据switch表达式中的值，依次匹配各个case中的常量，一旦匹配成功，则送入相应的case结构中，调用其执行语句
• 当调用完执行语句后，则将仍然继续向下执行其他case结构中的执行语句，且不需要进行判断，直到遇到break关键字或此switch-case结构末尾结束为止
• switch结构中的表达式，只能是如下的6种数据类型之一：byte、short、char、int、枚举类型和String类型
• case结构中的case之后只能声明常量，不能声明范围
• 凡是可以使用switch-case的结构，都可以转换为if-else结构，反之不成立

5. 循环结构

• for循环

  • //for循环的结构
    for(初始化条件;循环条件;迭代条件) {
        循环体; 
    }

• while循环

  • //while循环的结构
    初始化条件
    while(循环条件) {
        循环体;
        迭代条件;
    }

  • 写while循环时，注意不要丢掉迭代条件，一旦丢了就可能会导致死循环
• do-while循环

  • //do-while循环的结构
    初始化条件
    do {
        循环体;
        迭代条件;
    }while(循环条件);

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

  • 不要丢掉while( )后的分号;

6. break和continue关键字

关键字	使用的范围	循环中使用的作用 (不同点)	相同点
break	switch-case结构 循环结构	结束当前循环	关键字后面不能声明执行语句
continue	循环结构	结束当次循环	关键字后面不能声明执行语句

• break和continue关键字默认跳出包裹此关键字最近的一层循环

• for(int i = 1; i <= 4; i++) {
      for(int j = 1; j <=10; j++) {
          if(j % 4 == 0) {
              break; //默认跳出包裹此关键字最近的一层循环
              //continue;
          }
          //break输出123123123123
          //continue输出123567910123567910123567910123567910
          System.out.print(j);
      }
  }

7. 带标签的break和continue关键字

label: for(int i = 1; j <= 4; i++) {
    for(int j = 1; j <=10; j++) {
        if(j % 4 == 0) {
            break label; //结束指定标识的一层循环结构
            //continue label; //结束指定标识的一层循环结构的当次循环
        }
        //break输出123
        //continue输出123123123123
        System.out.print(j);
    }
}