一、注释
在java中，有3种标记注释的方式。
1.1 单行注释
//单行注释内容
1.2 多行注释
/*
多行注释内容
多行注释内容
多行注释内容
多行注释内容
*/
1.3 文档注释
/**
* 类注释
*
* @author vivfeng
*/
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
二、关键字
2.1 总览
|
访问控制 |
private |
protected |
public |
||||||
|
类,方法和变量修饰符 |
abstract |
class |
extends |
final |
implements |
interface |
native |
new |
static |
|
strictfp |
synchronized |
transient |
volatile |
||||||
|
程序控制 |
break |
continue |
return |
do |
while |
if |
else |
for |
instanceof |
|
switch |
case |
default |
|||||||
|
错误处理 |
try |
catch |
throw |
throws |
|||||
|
包相关 |
import |
package |
|||||||
|
基本类型 |
boolean |
byte |
char |
double |
float |
int |
long |
short |
null |
|
true |
false |
||||||||
|
变量引用 |
super |
this |
void |
||||||
|
保留字 |
goto |
const |
| 关键字 | 含义 |
| abstract | 表明类或者成员方法具有抽象属性 |
| assert | 用来进行程序调试 |
| boolean | 基本数据类型之一，布尔类型 |
| break | 提前跳出一个块 |
| byte | 基本数据类型之一，字节类型 |
| case | 用在switch语句之中，表示其中的一个分支 |
| catch | 用在异常处理中，用来捕捉异常 |
| char | 基本数据类型之一，字符类型 |
| class | 类 |
| const | 保留关键字，没有具体含义 |
| continue | 回到一个块的开始处 |
| default | 默认，例如，用在switch语句中，表明一个默认的分支 |
| do | 用在do-while循环结构中 |
| double | 基本数据类型之一，双精度浮点数类型 |
| else | 用在条件语句中，表明当条件不成立时的分支 |
| enum | 枚举 |
| extends | 表明一个类型是另一个类型的子类型，这里常见的类型有类和接口 |
| final | 用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变 |
| finally | 用于处理异常情况，用来声明一个基本肯定会被执行到的语句块 |
| float | 基本数据类型之一，单精度浮点数类型 |
| for | 一种循环结构的引导词 |
| goto | 保留关键字，没有具体含义 |
| if | 条件语句的引导词 |
| implements | 表明一个类实现了给定的接口 |
| import | 表明要访问指定的类或包 |
| instanceof | 用来测试一个对象是否是指定类型的实例对象 |
| int | 基本数据类型之一，整数类型 |
| interface | 接口 |
| long | 基本数据类型之一，长整数类型 |
| native | 用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的 |
| new | 用来创建新实例对象 |
| package | 包 |
| private | 一种访问控制方式：私用模式 |
| protected | 一种访问控制方式：保护模式 |
| public | 一种访问控制方式：共用模式 |
| return | 从成员方法中返回数据 |
| short | 基本数据类型之一,短整数类型 |
| static | 表明具有静态属性 |
| strictfp | 用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范 |
| super | 表明当前对象的父类型的引用或者父类型的构造方法 |
| switch | 分支语句结构的引导词 |
| synchronized | 表明一段代码需要同步执行 |
| this | 指向当前实例对象的引用 |
| throw | 抛出一个异常 |
| throws | 声明在当前定义的成员方法中所有需要抛出的异常 |
| transient | 声明不用序列化的成员域 |
| try | 尝试一个可能抛出异常的程序块 |
| void | 声明当前成员方法没有返回值 |
| volatile |
表明两个或者多个变量必须同步地发生变化 |
| while |
用在循环结构中 |
三、常量与变量
3.1 常量
在 Java中，利用关键字 final指示常量。例如：
final int A = 1;
关键字 final 表示这个变量只能被赋值一次。一旦被赋值之后，就不能够再更改了。习惯上, 常量名使用全大写。
3.2 变量
在 Java中，每个变量都有一个类型。在声明变量时，变量的类型位于变量名之前。例如：
int a;
long b;
String s;
变量名必须是一个以字母开头并由字母或数字构成的序列。另外，不能使用 Java 保留字作为变量名。
四、运算符
4.1 算术运算符
| 运算符 | 描述 | 例子 |
|---|---|---|
| + | 加法：相加运算符两侧的值 | A + B 等于 30 |
| - | 减法：左操作数减去右操作数 | A – B 等于 -10 |
| * | 乘法：相乘操作符两侧的值 | A * B等于200 |
| / | 除法：左操作数除以右操作数 | B / A等于2 |
| ％ | 取余：左操作数除以右操作数的余数 | B%A等于0 |
| ++ | 自增：操作数的值增加1 | B++ 或 ++B 等于 21 |
| -- | 自减：操作数的值减少1 | B-- 或 --B 等于 19 |
4.2 关系运算符
| 运算符 | 描述 | 例子 |
|---|---|---|
| == | 检查如果两个操作数的值是否相等，如果相等则条件为真。 | （A == B）为假。 |
| != | 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 | (A != B) 为真。 |
|检查左操作数的值是否大于右操作数的值，如果是那么条件为真。| （A > B）为假。
< |检查左操作数的值是否小于右操作数的值，如果是那么条件为真。| （A <B）为真。
= |检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 |（A >= B）为假。
<= |检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 |（A <= B）为真。
4.3 位运算符
| 运算符 | 描述 | 例子 |
|---|---|---|
| ＆ | 如果相对应位都是1，则结果为1，否则为0 | （A＆B）得到12，即 0000 1100 |
| | | 如果相对应位都是0，则结果为0，否则为1 | （A | B）得到61，即 0011 1101 |
| ^ | 如果相对应位值相同，则结果为0，否则为1 | （A ^ B）得到49，即 0011 0001 |
| 〜 | 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 | （〜A）得到-61，即 1100 0011 |
| << | 按位左移运算符。左操作数按位左移右操作数指定的位数。 | （A << 2）得到240，即 1111 0000 |
|按位右移运算符。左操作数按位右移右操作数指定的位数。 |（A >> 2）得到15，即 0000 1111
|按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 |（A>>>2）得到15，即 0000 1111
4.4 逻辑运算符
| 运算符 | 描述 | 例子 |
|---|---|---|
| && | 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。 | （A && B）为假。 |
| || | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。 | （A || B）为真。 |
| ！ | 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。 | !(A && B) 为真。 |
4.4 赋值运算符
| 运算符 | 描述 | 例子 |
|---|---|---|
| = | 赋值运算符，将右操作数的值赋给左侧操作数 | C = A + B将把A + B得到的值赋给C |
| += | 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 | C += A等价于C = C + A |
| -= | 减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 | C -= A等价于C = C - A |
| *= | 乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 | C *= A等价于C = C * A |
| /= | 除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 | C /= A等价于C = C / A |
| %= | 取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 | C %= A等价于C = C％A |
| <<= | 左移位赋值运算符 | C <<= 2等价于C = C << 2 |
= |右移位赋值运算符| C >>= 2等价于C = C >> 2
＆= |按位与赋值运算符| C＆= 2等价于C = C＆2
^= |按位异或赋值操作符| C ^= 2等价于C = C ^ 2
|= |按位或赋值操作符| C |= 2等价于C = C | 2
4.5 条件运算符（?:）
条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
int a = 1;
int b = 2;
boolean f = a >= b ? true : false;//f为false
五、数据类型
5.1 基本数据类型
/* byte
* 存储需求：1字节
* 取值范围：-128 ~ 127
* 默认值：0
* */
byte num1 = 100;
/* short
* 存储需求：2字节
* 取值范围：-32,768 ~ 32,767
* 默认值：0
* */
short num2 = 10000;
/* int
* 存储需求：4字节
* 取值范围：-2,147,483,648 ~ 2,147,483,647
* 默认值：0
* */
int num3 = 1_000_000_000;
/* long
* 存储需求：8字节
* 取值范围：-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807
* 默认值：0L
* */
long num4 = 1_000_000_000_000_000_000L;
/* float
* 存储需求：4字节
* 有效位数：6 ~ 7位
* 默认值：0.0F
* */
float num5 = 1.1F;
/* double
* 存储需求：8字节
* 有效位数：15位
* 默认值：0.0D
* */
double num6 = 2.0D;
/* boolean
* 存储需求：JVM规范中，boolean变量作为int处理，也就是4字节
* 取值范围：只有两个取值，即 true 和 false
* 默认值：false
* */
boolean k = true;
/* char
* 存储需求：2字节
* 取值范围：0~65535
* */
char c = 'a';
5.2 引用数据类型
/*
* 在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。
* 这些变量在声明时被指定为一个特定的类型，比如 String 等。
* 变量一旦声明后，类型就不能被改变了。
* 对象、数组都是引用数据类型。
* 所有引用类型的默认值都是 null。
*/
String string = null;
string = new String("aaaaa");
六、大数值
如果基本的整数和浮点数精度不能够满足需求，那么可以使用java.math包中的两个很有用的类：Biglnteger和 BigDecimaL，这两个类可以处理包含任意长度数字序列的数值。
BigInteger类实现了任意精度的整数运算，BigDecimal类实现了任意精度的浮点数运算。
//使用静态的 valueOf方法可以将普通的数值转换为大数值
BigInteger bigA = BigInteger.valueOf(5L);
BigInteger bigB = BigInteger.valueOf(10L);
BigInteger bigC = null;
//加
bigC = bigA.add(bigB);
//减
bigC = bigA.subtract(bigB);
//乘
bigC = bigA.multiply(bigB);
//除
bigC = bigA.divide(bigB);
//取余
bigC = bigA.mod(bigB);
七、数组
数组是一种数据结构，用来存储同一类型值的集合。通过一个整型下标可以访问数组中的每一个值。在声明数组变量时， 需要指出数组类型 （数据元素类型紧跟 [] ) 和数组变量的名字。一旦创建了数组，就不能再改变它的大小。
7.1 一维数组
//静态初始化
//静态初始化的同时就为数组元素分配空间并赋值
int[] array1 = {1, 2, 3, 4};
//动态初始化
int[] array2 = new int[4];
array2[0] = 1;
array2[1] = 2;
array2[2] = 3;
array2[3] = 4;
7.2 二维数组
//静态初始化
int[][] array3 = {{1, 2}, {2, 3}, {4, 5}};
//动态初始化
int[][] array4 = new int[2][3];
array4[0][0] = 12;
array4[0][1] = 34;
array4[0][2] = 93;
array4[1][0] = 12;
array4[1][1] = 34;
array4[1][2] = 93;
7.3 遍历数组
//for循环
for (int i = 0; i < array1.length; i++) {
System.out.println(array1[i]);
}
//for each循环
for (int i : array1) {
System.out.println(i);
}
八、控制流程
8.1 条件分支
int n = 19;
if (n < 10) {
System.out.println(n + " < 10");
} else if (n < 50) {
System.out.println("10 < " + n + " < 50");
} else {
System.out.println("50 < " + n);
}
8.2 开关分支
int n = 1;
switch (n) {
case 1:
System.out.println("n = 1");
break;
case 2:
System.out.println("n = 2");
break;
case 3:
System.out.println("n = 3");
break;
default:
System.out.println("n未知");
break;
}
8.3 循环
Integer[] integers = new Integer[5];
integers[0] = 0;
integers[1] = 1;
integers[2] = 2;
integers[3] = 3;
integers[4] = 4;
//for循环
for (int i = 0; i < integers.length; i++) {
System.out.println(integers[i]);
}
//for each循环
for (Integer integer : integers) {
System.out.println(integer);
}
//while循环
int j = 0;
while (j < integers.length) {
System.out.println(integers[j]);
j++;
}
//do while循环
int m = 0;
do {
System.out.println(integers[m]);
m++;
} while (m < integers.length);