• 编译 .java 为 class 文件：javac Welcome.java
  • 执行：java Welcome

数据类型和运算符

注释

  1. //单行注释
  2. /*
  3. 多行注释
  4.     */
  5. /**
  6.  *文档注释
  7.  */
  1. 在类的方法中使用单行注释
  2. 在类中使用文档注释

标识符

标识符规则

  1. 标识符必须是以字母、下划线、美元符号开头。
  2. 标识符其他部分可以是字母、下划线、美元符、数字的任意组合。
  3. Java标识符大小写敏感，且长度无限制。
  4. 标识符不可以是Java关键字。

标识符使用规范

  1. 表示类名的标识符：每个单词的手写字母大写.Man,GoodMan
  2. 表示方法和变量的标识符，第一个的单词小写，从第二个单词开始首字母大写。（也就是驼峰法命名）。

Java中的关键字/保留字

abstract assert boolean break byte case
catch char class const continue default
do double else extends final finally
float for goto if implements import
instanceof int interface long native new
null package private protected public return
short static strictfp super switch sychronized
this throw throws transient try void
volatile while

变量

变量的本质

  1. 变量的本质上就是代表一个“可操作的存储空间”，空间的位置是确定的，到那时里面放置什么值不确定。
  2. 我们可以通过变量名来访问“对应的存储空间”，从而操作这个“存储空间”存储的值。

变量的分类

类型 声明位置 从属于 声明周期
局部变量 方法或语句块内部 方法/语句块 从声明位置开始，直到方法或语句块执行完毕，局部变量消失。
成员变量（实例变量） 类内部，方法外部 对象 对象创建，成员变量也跟着创建，对象消失，成员变量也跟着消失。
静态变量（类变量） 类内部，static修饰 类 类被加载，静态变量就有效；类被卸载，静态变量消失。

常量

  1. 常量通常是指一个固定的值。
  2. 在Java中，主要是利用 final 来定义一个常量。常量一旦被初始化后不能在更改其值。
  3. 常量声明格式 final type varname = value;

变量和常量命名规范

  1. 多有变量、方法、类名：见名知意
  2. 类成员变量：首字母小写和驼峰法原则：monthSalary
  3. 局部变量：首字母小写和驼峰原则
  4. 常量：大写字母和下划线：MAX_VALUE
  5. 类名：首字母大写和驼峰原则
  6. 方法名：首字母小写和驼峰原则：run()

基本数据类型

  • Java的数据类型可分为两大类：基本数据类型（primitive data type）和引用数据类型（reference data type）。
  • 数值值 - byte、short、int、long、float、double
  • 字符型 - char
  • 布尔型 - boolean

image.png

整形变量/常量

类型 占用存储空间 表数范围
byte 1字节 -2^7 ~ 2^7-1（-128 ~ 127）
short 2字节 -2^15 ~ 2^15 - 1（3万）
int 4字节 -2^31 ~ 2^31 - 1（21亿）
long 8字节 -2^63 ~ 2^63 - 1
  1. 十进制整数：99，-500
  2. 八进制整数，要求以0开头：015
  3. 十六进制数，要求以0x或0X开头：0x15
  4. 二进制数，要求以0b或0B开头：0b01110011
  5. long 型常量声明时必须加L ，不然会别编译为int，还会报错： long b = 5555555555555555555555L;

浮点型变量/常量

类型 占用存储空间 表数范围
float 4字节 -3.403E38 ~ 3.403E38
double 8字节 -1.798E308 ~ 1.798E308
  1. 带小数的数据在Java中称为浮点数。浮点数可分为 float 类型和 double 类型。
  2. float 类型又被称为单精度类型，尾数可以精确到 7 位有效数字，在很多情况下， float 类型的精度很难满足需求。
  3. double 类型的数值的精度约是 float 类型的两倍，又被称作双精度类型，绝大多数部分的应用程序都采用 double 类型，
  4. 浮点数常量的默认类型也是 double。
  5. float 类型的数值有一个后缀 f 或者 F ，没有后缀 f/F的浮点数被默认为 double 类型。
  6. 浮点数 float/double 的数据不适合在不允许舍入误差的领域。
  7. BigDecimal 类不产生舍入误差，实现了任意精度的浮点运算。 BigDecimal bd = BigDecimal.valueOf(1.0); 加减乘除使用的相关方法。
  8. BigInteger 实现了任意精度的整数运算。

Java浮点类型常量有两种表示形式
  • 十进制数形式：3.14，314.0，0.314
  • 科学记数形式：314e2，314E2，314E-2

字符型变量/常量

  1. 字符型在Java中占2个字节。
  2. 在Java职工使用单引号来表示字符常量：’A’
  3. char 类型用来表示在 Unicode 编码表中的字符。

  4. 转义字符 | 转义符 | 含义 | Unicode值 | | —- | —- | —- | | \b | 退格(backspace) | \u0008 | | \n | 换行 | \u000a | | \r | 回车 | \u000d | | \t | 制表符(tab) | \u0009 | | \“ | 双引号 | \u0022 | | \‘ | 单引号 | \u0027 | | \\ | 反斜杠 | \u005c |

  5. String的底层实现就是字符序列。

boolean 类型

  1. boolean 类型有两个常量值： true/false
  2. boolean 在内存中占一位（不是一个字节）。
  3. 不可以用0/1表示true/false

运算符

image.png

算数运算符

  • 二元运算符：+，-，*，/，%
  • 二元运算符顾名思义就是需要两个操作数才能完成运算的运算符
  • 一元运算符：++，—

整数运算规则
  1. 如果两个操作数有一个位 long ，则结果也为long。
  2. 没有long时，结果位int。即使操作数全部为short，byte，结果也是int。

浮点数运算规则
  1. 如果两个操作数有一个为 double ，则结果为 double。
  2. 只有两个数都是 float ，则结果才会为float

取模运算规则
  1. 操作数可以为浮点数，一般使用整数，结果是余数。
  2. 余数的符号和左边的操作数相同：7%3=1，-7%3=-1，7%-3=1。

赋值及其扩展赋值运算符

  1. +=,-=,*=,/=,%=
  2. 这些扩展运算符都是压缩了运算。

关系运算符

image.png

  1. = 是赋值运算符
  2. ==,!= 是所有（基本和引用）数据类型都可以使用；但是在使用 == 的情况下一般都使用 equals
  3. >,>=,<,<= 仅针对数值类型（byte/short/int/long，float/double，以及char）

逻辑运算符

image.png

  1. 逻辑运算的操作数和运算结果都是boolean值。
  2. 短路与和短路或采用短路的方式。从左到右计算，如果只通过运算操作符左边的操作数就能够确定该逻辑表达式，则不会继续计算操作符右边的操作数，提高效率。

位运算

image.png

  1. & 和 | 即使逻辑运算符，也是位运算符。如果两侧的操作数都是boolean类型，就作为逻辑运算符。如果两侧的操作数是整数类型，就是位运算符。
  2. ^ 不是数学的乘方，而是 位的异或 操作。
  3. & 按位与：可以实现清零的功能。

字符串连接符(+)

+ 运算符两侧的操作数中只要有一个是字符串（String）类型，系统会自动将另一个操作数转为字符串然后再进行连接。

条件运算符

x ? y : z;

算数运算符优先级

image.png

  1. 一般使用小括号来组织。
  2. 逻辑非>逻辑与>逻辑或

类型转换

自动类型转换

  1. 自动类型转换指的是容量小的数据类型可以自动转换为容量大的数据类型。
  2. 当整数转为浮点数的时候，会出现精度损失。
  3. 可以将整形常量直接赋值给byte,short,char等类型。不需要进行强制类型转换，只要不超过其数范围即可。

强制类型转换

  1. 强制类型转换，又被称为造型，用于显式的转换一个数值的类型。
  2. 将一种类型强制转换成另一种类型，而又超出了目标类型的范围，就会被截断为一个完全不同的值。
  3. 不能在布尔类型 和任何数值类型之间做强制类型转换。

强制类型转换时常见的错误和问题
  1. 操作较大的数时，要留意是否溢出。
  2. L/l 的使用，可能和 1 造成混乱。需要注意。

控制语句

所有的布尔表达式中不能使用 0/1 进行判断处理

选择结构

if单选择结构

  1. if (布尔表达式) {
  2.     语句块
  3. }

if-else双选择结构

  1. if(布尔表达式){
  2.     语句块1
  3. }else{
  4.     语句块2
  5. }

if-else if-else多选择结构

  1. if(布尔表达式1) {
  2.     语句块1;
  3. } else if(布尔表达式2) {
  4.     语句块2;
  5. }……
  6. else if(布尔表达式n){
  7.     语句块n;
  8. } else {
  9.     语句块n+1;
  10. }

switch 多选择结构

  1. switch (表达式) {
  2. case 值1: 
  3.     语句序列1;
  4.     [break];
  5. case 值2:
  6.      语句序列2;
  7. [break];
  8.      … … …      … …
  9. [default:
  10.      默认语句;]
  11. }
  • 这儿的表达式就是填入一个变量，然后与下面的值对比。
  • default 语句可以有，也可以舍去。

循环结构

  • 循环结构分为两大类：一类是当型，一类是直到型。
  • 当型：当布尔表达式条件为 true 时，反复执行某语句，当布尔表达式的值为 false 时才停止循环。比如：while/for 循环。
  • 直到型：先执行某语句，再判断布尔表达式，如果为 true，再执行某语句，如此反复直到布尔表达式条件为 false 时才停止。比如：do-while 循环。

while循环

  1. while (布尔表达式) {
  2.     循环体；
  3. }

do-while循环

  1. do {
  3. } while (布尔表达式);
  • do-while 循环的结尾必须有 ;
  • while 与 do-while 的区别：do-while 总是保证循环体至少被执行一次。

for循环

  1. for (初始表达式; 布尔表达式; 迭代因子) {
  2.     循环体;
  3. }
  • A. 初始化部分设置循环变量的初值
  • B. 条件判断部分为任意布尔表达式
  • C. 迭代因子控制循环变量的增减
  • for循环在执行条件判定后，先执行的循环体部分，再执行步进。

嵌套循环

  1. break
    • 用于强制退出，不执行循环剩余的语句
  2. continue
    • 终止本次循环
    • continue用在while，do-while中，continue 语句立刻跳到循环首部，越过了当前循环的其余部分。
    • continue用在for循环中，跳到for循环的迭代因子部分。
  3. 可以在 break/continue 加标签，这样就可以实现多层跳转。
    1. outer: for (int i = 101; i < 150; i++) {
    2.          for (int j = 2; j < i / 2; j++) {
    3.              if (i % j == 0){
    4.                  continue outer;
    5.              }
    6.          }
    7.          System.out.print(i + "  ");
    8.      }

数组

数组的定义

  1. 数组是相同类型数据的有序集合。
  2. 数组的长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
  3. 其元素必须是相同的类型，不允许出现混合类型。
  4. 数组类型可以是任何数据类型，包括基本类型和引用类型。
  5. 注意：
    1. 数组变量属于引用类型，数组可以看成是对象，每个数组中的每个元素相当于该对象的成员变量。
    2. 数组本身就是对象，Java中对象是堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。

数组的声明

type[] arr_name;
  1. 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM 才会分配空间，这时候才与长度有关。
  2. 声明一个数组的时候并没有数组被真正的创建。
  3. 构造一个数组，必须指定数组的长度。

数组的初始化

静态初始化

int[] a = {1,4,7};
User[] b = {        
    new User(1001,"zs"),        
    new User(1002,"zed")
};

动态初始化

int[] a1 = new int[2];//动态初始化数组，先分配空间；
a1[0]=1;//给数组元素赋值；
a1[1]=2;//给数组元素赋值；

默认初始化

int[] c = new int[3]; // 默认给数组赋值，赋值的规则和成员变量默认赋值规则一致。

数组的遍历

  1. 数组元素下边的合法区间：[0,length-1]
  2. 遍历数组时可以读取或修改元素的值。
  3. fori 遍历：可以修改、读取数组元素的值。
  4. for-each 遍历：只可以读取元素的值。

数组的拷贝

System类里也包含了一个 static void arraycopy(object src，int srcpos，object dest， int destpos，int length) 方法，该方法可以将 src 数组里的元素值赋给 dest 数组的元素，其中 srcpos 指定从 src 数组的第几个元素开始赋值， length 参数指定将 src 数组的多少个元素赋给 dest 数组的元素。

java.util.Arrays类

  1. Arrays类中包含了常用的数组操作，方便我们使用。
  2. Arrays类包含了：排序、查找、填充、打印内容等常见操作
  3. 排序: Arrays.sort(a)

  4. 数组引用类型的排序

    class Man implements Comparable {
 int age;
 int id;
 String name;

 public Man(int age, String name) {
     super();
     this.age = age;
     this.name = name;
 }

 public String toString() {
     return this.name;
 }

 public int compareTo(Object o) {
     Man man = (Man) o;
     if (this.age < man.age) {
         return -1;
     }
     if (this.age > man.age) {
         return 1;
     }
     return 0;
 }
}
    • 主要就是实现了Comparable中的compareTo。
    • 在compareTo中实现了引用类型的排序。
  5. 数组的填充：Arrays.fill(a,2,4,100); 将2-4索引的元素替换为100；
  6. 二分查找: Arrays.binarySearch(数组名,查找的元素) 。

多维数组

image.png

  1. 多维数组可以看成数组为元素的数组。

    int[][] a = new int[3][];
// a[0] = {1,2,5}; //错误，没有声明类型就初始化
a[0] = new int[] { 1, 2 };
a[1] = new int[] { 2, 2 };
a[2] = new int[] { 2, 2, 3, 4 };

  2. 多为数组在内存中的存储就是这样的（上图）。

  3. 我们在开发中一般不使用数组，我们使用容器（collection）。

数组存储表格数据


  1. Object[] a1 = {1001,"高淇",18,"讲师","2006-2-14"};
Object[] a2 = {1002,"高小七",19,"助教","2007-10-10"};
Object[] a3 = {1003,"高小琴",20,"班主任","2008-5-5"};
Object[][]  emps = new Object[3][];
emps[0] = a1;
emps[1] = a2;
emps[2] = a3;

  2. 此处的数据本质不是Object对象。java编译器会自动把基本数据类型“自动装箱”成包装类对象。