Note2: 注释、标识符、关键字 / 数据类型 / 类型转换 / 变量常量 / 运算符 / 包机制、JavaDoc / 2023-1-12
Java基础语法2
1.注释、标识符、关键字
1.注释Comments
注释并不会被执行，是给我们写代码的人看的。
书写注释是个非常好的习惯，平时就要注意规范
-
单行注释 //（Ctrl+/）
只能注释一行文字 -
多行注释 /* */（Ctrl+Shift+/）
可以注释一段文字 -
文档注释 /** */（/**+Enter）
使用文档注释时，需要在开始的 /** 之后，第一行或几行是关于类、变量和方法的主要描述。
之后，可以包含一个或多个何种各样的@ 标签。每一个@标签必须在一个新行的开始或者在一行的开始紧跟星号(*)。
多个相同类型的标签应该放成一组。
public class HelloJava {
/**
* @param args
* @author Ljh
* 文档注释给某个类或方法解释说明
*/
public static void main(String[] args) {
//这是一个单行注释
System.out.println("Hello Java!");
/* 多行注释
_(\_/)
,((((^`\
(((( (6 \
,((((( , \
,,,_ ,((((( /"._ ,`,
((((\\ ,... ,(((( / `-.-'
))) ;' `"'"'""(((( (
((( / ((( \
)) | |
(( | . ' |
)) \ _ ' `t ,.')
( | y;- -,-""'"-.\ \/
) / ./ ) / `\ \
|./ ( ( / /'
|| \\ //'|
|| \\ _//'||
|| )) |_/ ||
\_\ |_/ ||
`'" \_\
*/
}
}可以搜索有趣的代码注释
2.标识符
Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
关于 Java 标识符，有以下几点需要注意：
- 所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
- 首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
- 不能使用关键字作为变量名或方法名。
- 标识符是大小写敏感的
- 合法标识符举例：age、$salary、_value、_1_value
- 非法标识符举例：123abc、-salary 、#abc
- 可以使用中文命名，但不建议用，也不要用拼音，Low
public class TAG {
public static void main(String[] args) {
String A_ = "首大写字母开头";
String a_ = "首小写字母开头";
String _A= "下划线开头";
String $_ = "美元符号开头";
// 不允许数字或非法符号开头
// 非法符号：除了 _ $ 以外的任何符号
// String 1_ = "数字开头"; X
// String #_ = "非法符号开头"; X
String _1Aa$ = "首字母之后可任意组合";
// 不允许出现非法符号
// String _# = "出现非法符号"; X
}
}3.关键字
下面列出了 Java 关键字。这些保留字不能用于常量、变量、和任何标识符的名称。
| 类别 | 关键字 | 说明 |
|---|---|---|
| 访问控制 | private | 私有的 |
| 访问控制 | protected | 受保护的 |
| 访问控制 | public | 公共的 |
| 访问控制 | default | 默认 |
| 类、方法和变量修饰符 | abstract | 声明抽象 |
| 类、方法和变量修饰符 | class | 类 |
| 类、方法和变量修饰符 | extends | 扩充,继承 |
| 类、方法和变量修饰符 | final | 最终值,不可改变的 |
| 类、方法和变量修饰符 | implements | 实现（接口） |
| 类、方法和变量修饰符 | interface | 接口 |
| 类、方法和变量修饰符 | native | 本地，原生方法（非 Java 实现） |
| 类、方法和变量修饰符 | new | 新,创建 |
| 类、方法和变量修饰符 | static | 静态 |
| 类、方法和变量修饰符 | strictfp | 严格,精准 |
| 类、方法和变量修饰符 | synchronized | 线程,同步 |
| 类、方法和变量修饰符 | transient | 短暂 |
| 类、方法和变量修饰符 | volatile | 易失 |
| 程序控制语句 | break | 跳出循环 |
| 程序控制语句 | case | 定义一个值以供 switch 选择 |
| 程序控制语句 | continue | 继续 |
| 程序控制语句 | default | 默认 |
| 程序控制语句 | do | 运行 |
| 程序控制语句 | else | 否则 |
| 程序控制语句 | for | 循环 |
| 程序控制语句 | if | 如果 |
| 程序控制语句 | instanceof | 实例 |
| 程序控制语句 | return | 返回 |
| 程序控制语句 | switch | 根据值选择执行 |
| 程序控制语句 | while | 循环 |
| 错误处理 | assert | 断言表达式是否为真 |
| 错误处理 | catch | 捕捉异常 |
| 错误处理 | finally | 有没有异常都执行 |
| 错误处理 | throw | 抛出一个异常对象 |
| 错误处理 | throws | 声明一个异常可能被抛出 |
| 错误处理 | try | 捕获异常 |
| 包相关 | import | 引入 |
| 包相关 | package | 包 |
| 基本类型 | boolean | 布尔型 |
| 基本类型 | byte | 字节型 |
| 基本类型 | char | 字符型 |
| 基本类型 | double | 双精度浮点 |
| 基本类型 | float | 单精度浮点 |
| 基本类型 | int | 整型 |
| 基本类型 | long | 长整型 |
| 基本类型 | short | 短整型 |
| 变量引用 | super | 父类,超类 |
| 变量引用 | this | 本类 |
| 变量引用 | void | 无返回值 |
| 保留关键字 | goto | 是关键字，但不能使用 |
| 保留关键字 | const | 是关键字，但不能使用 |
| 保留关键字 | null | 空 |
2.数据类型
强类型语言
要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。
一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了。
举个例子：如果你定义了一个整型变量 a，那么程序根本不可能将 a 当作字符串类型处理。强类型定义语言是类型安全的语言。
弱类型语言
它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。
所以Java是强类型语言，所有变量都必须先定义后才能使用。
Java的数据类型分为两大类
基本类型（primitive type）
Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
byte：
- byte 数据类型是8位、有符号的，以二进制补码表示的整数；
- 最小值是 -128（-2^7）；
- 最大值是 127（2^7-1）；
- 默认值是 0；
- byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
- 例子：byte a = 100，byte b = -50。
short：
- short 数据类型是 16 位、有符号的以二进制补码表示的整数
- 最小值是 -32768（-2^15）；
- 最大值是 32767（2^15 - 1）；
- Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
- 默认值是 0；
- 例子：short s = 1000，short r = -20000。
int：
- int 数据类型是32位、有符号的以二进制补码表示的整数；
- 最小值是 -2,147,483,648（-2^31）；
- 最大值是 2,147,483,647（2^31 - 1）；
- 一般地整型变量默认为 int 类型；
- 默认值是 0 ；
- 例子：int a = 100000, int b = -200000。
long：
- long 数据类型是 64 位、有符号的以二进制补码表示的整数；
- 最小值是 -9,223,372,036,854,775,808（-2^63）；
- 最大值是 9,223,372,036,854,775,807（2^63 -1）；
- 这种类型主要使用在需要比较大整数的系统上；
- 默认值是
0L； - 例子： long a = 100000L，Long b = -200000L。
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。
float：
- float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
- float 在储存大型浮点数组的时候可节省内存空间；
- 默认值是
0.0f； - 浮点数不能用来表示精确的值，如货币；
- 例子：float f1 = 234.5f。
double：
- double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
- 浮点数的默认类型为double类型；
- double类型同样不能表示精确的值，如货币；
- 默认值是
0.0d；可省略 - 例子：double d1 = 123.4。
boolean：
- boolean数据类型表示一位的信息；
- 只有两个取值：true 和 false；
- 这种类型只作为一种标志来记录 true/false 情况；
- 默认值是 false；
- 例子：boolean one = true。
char：
- char类型是一个单一的 16 位 Unicode 字符；
- 最小值是 \u0000（即为0）；
- 最大值是 \uffff（即为65,535）；
- char 数据类型可以储存任何字符；
- 例子：char letter = 'A';
/**
* 介绍8大基本数据类型
*/
public class PrimaryType {
public static void main(String[] args) {
// 八大基本数据类型
// 整数
byte byte_num = 127; // 8位1字节 2^8=256 范围:-2^7 ~ 2^7 -1 (-128 ~ 127)
short short_num = 32767; // 2字节 范围：+-三万多
int int_num = 123456; // 最常用。 4字节，范围：正负21亿多
long long_num = 99999999999999L; //8字节！ 当超过int范围时需要在数字后面加L
// 浮点数
float float_num = 0.1F; // 4字节，后面必须加F
double double_num = 0.1; // 8字节，结尾的d 可加可不加
//字符
char ch = '1'; // 单一的 16 位 Unicode 字符
String str = "123456"; // 字符串不是基本数据类型，而是一个类
//布尔类型
boolean flag = true;
boolean flag2 = false;
}
}基本数据类型扩展
/**
* 数据类型面试题
*/
public class PrimaryTypeExt {
public static void main(String[] args) {
/* 二进制是Binary，简写为B
八进制是Octal，简写为O
十进制为Decimal，简写为D
十六进制为Hexadecimal，简写为H
*/
//整数扩展 进制： 2 8 10 16
int bin_num = 0b10; // 二进制 0b 开头
int oct_num = 010; // 八进制0开头
int dec_num = 10; // 十进制正常写
int hex_num = 0x10; // 十六进制 0x 开头
System.out.println(bin_num);//默认打印10进制
System.out.println(oct_num);
System.out.println(dec_num);
System.out.println(hex_num);
System.out.println("----------------");
//浮点数 精度有丢失
// 所以银行业务不用float，用BigDecimal
// 最好完全避免使用浮点数进行比较！！！
float num1 = 4.0f;
float num2 = 3.6f;
System.out.println(num1 - num2); //0.4000001
//如何解释出现4.0-3.6 =0.40000001
// 答：二进制的小数无法精确的表示10进制小数，
// 计算机在计算4.0 -3.6 时，先将两数转成2进制形式
// 用二进制计算后再将结果转成十进制，这期间出现了误差。
System.out.println("--------字符串扩展--------");
//字符串扩展
char ch = 'A'; // 底层原理 是 '\u0041' 十进制的65 -> 十六进制41
char ch2 = '国';
System.out.println((int) ch);
System.out.println((int) ch2);
System.out.println('\u0041');//Unicode编码
// 所有的字符本质还是数字
System.out.println("--------转义字符\\--------");
// 转义字符
System.out.println("换行\ntab\t键");
System.out.println("--------布尔扩展--------");
// 布尔使用
boolean flag = true;
if (flag == true)
System.out.println("新手用法");
if (flag)
System.out.println("老手用法");
// 代码要精简易读
}
}
引用类型（reference type）
除了八大基本数据类型之外其他都是引用类型
如 类，接口，数组等
-
在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。
这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
-
对象、数组都是引用数据类型。
-
所有引用类型的默认值都是null。
-
一个引用变量可以用来引用任何与之兼容的类型。
浮点储存模型
二进制的科学计数法来保存浮点数，
例如：5.5，其二进制数为101.1，则用二进制的科学计数法可以表示为 1.011 * 2^2，这样小数点的位置就是固定的。
任何一个浮点数可以表示为下面的形式（国际标准IEEE 754）：
(-1)^S * M * 2^E
(-1)^S表示符号位，当S=0时，为正；当S=1时，为负
M表示有效数字，M>=1且M<2
2^E表示指数位上面的例子中，S=0，M=1.011，E=2。
所以当存储浮点数时，只需要将上述三个数字保存起来，就可以了。
对于但精度浮点数，其存储模型为：
3.类型转换
整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。
转换从低级到高级。
低 --------------------------------------> 高
byte,short,char—> int —> long—> float —> double
数据类型转换必须满足如下规则：
-
不能对boolean类型进行类型转换。
-
不能把对象类型转换成不相关类的对象。
-
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
-
转换过程中可能导致溢出或损失精度，例如：
int i =128; byte b = (byte)i;因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。
-
浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：
(int)23.7 == 23; (int)-45.89f == -45
自动类型转换(低到高)
必须满足转换前的数据类型的位数要低于转换后的数据类型，
例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，
同样float数据类型的位数为32，可以自动转换为64位的double类型。
强制类型转换（高到底）
- 条件是转换的数据类型必须是兼容的。
- 格式：(type)value type是要强制类型转换后的数据类型
隐含强制类型转换
- 整数的默认类型是 int。
- 浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或者 f。
public class TypeConversion {
public static void main(String[] args) {
int i = 128;
byte b = (byte)i; //byte类型的范围是-128 ~ 127 ，强转128溢出。
//强制转换 （类型）变量名 高——低
System.out.println("#########################");
int u = 128;
double n = u;
//自动转换 低——高
System.out.println(i);
System.out.println(b);
System.out.println(u);
System.out.println(n);
/*
注意：
1、不能对布尔值进行转换
2、不能把对象类型转换为不相干的类型
3、在把高容量转换到低容量的时候，强制转换
4、转换的时候可能存在内存溢出，或者精度问题！
*/
System.out.println("#################");
System.out.println((int)23.7);//23 去掉小数，不是四舍五入哦
System.out.println((int) -45.89f);// -45
System.out.println("#################");
char c = 'a';
int d = c + 1;
System.out.println(d);
System.out.println((char)d);
//操作比较大的数的时候，注意溢出问题
//JDK7新特性，数字之间可以用下划线分割
int money = 10_0000_0000;
int years = 20;
int total = money*years; //-1474836480, 计算的时候溢出了
long total2 = money*years; //默认是int，转换之前已经存在问题了
long total3 = money*((long)years); //先把一个数转换为long
System.out.println(total);
System.out.println(total2);
System.out.println(total3);
}
}4.变量、常量
变量
变量本质上就是代表一个"可操作的存储空间"，空间位置是确定的，但是里面放置什么值不确定。我们可以通过变量名来访问"对应的存储空间"，从而操纵这个"存储空间"存储的值。
变量作为程序中最基本的存储单元，其要素包括 变量名，变量类型 和 作用域。变量在使用前必须对其声明，只有变量声明义后，才能为其分配相应长度的存储空间。
变量的命名规范
-
所有变量，方法，类名：见名知意
-
类成员变量：首字母小写和驼峰原则：monthSalary
-
局部变量：首字母小写和驼峰原则
-
常量：大写字母和下划线 MAX_VALUE
-
类名：首字母大写和驼峰原则：Man，GoodMan
-
方法名：首字母小写和驼峰原则 run(),runRun()
在Java语言中，所有的变量在使用前必须声明。声明变量的基本格式如下：
type varName[ = value][, varName[= value] ...];
格式说明：type为Java数据类型。varName是变量名。可以使用逗号隔开来声明多个同类型变量(不建议)。
作用域：
- 类变量：独立于方法之外的变量，用 static 修饰。
- 实例变量：独立于方法之外的变量，不过没有 static 修饰。
- 局部变量：类的方法中的变量。
类变量（静态变量）
- 类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
- 无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
- 静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
- 静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
- 静态变量在第一次被访问时创建，在程序结束时销毁。
- 与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
- 默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
- 静态变量可以通过：ClassName.VariableName的方式访问。
- 类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。
实例变量
- 实例变量声明在一个类中，但在方法、构造方法和语句块之外；
- 当一个对象被实例化之后，每个实例变量的值就跟着确定；
- 实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
- 实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
- 实例变量可以声明在使用前或者使用后；
- 访问修饰符可以修饰实例变量；
- 实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
- 实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
- 实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
局部变量
- 局部变量声明在方法、构造方法或者语句块中；
- 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
- 访问修饰符不能用于局部变量；
- 局部变量只在声明它的方法、构造方法或者语句块中可见；
- 局部变量是在栈上分配的。
- 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
常量Constant：初始化initialize后不能再改变值！不会变动的值。
常量在程序运行时是不能被修改的。
在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：
final double PI = 3.1415927;虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。
字面量可以赋给任何内置类型的变量。例如：
byte a = 68;
char a = 'A'byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。
当使用常量的时候，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制, 例如：
int decimal = 100;
int octal = 0144;
int hexa = 0x64;和其他语言一样，Java的字符串常量也是包含在两个引号之间的字符序列。下面是字符串型字面量的例子：
"Hello World"
"two\nlines"
"\"This is in quotes\""字符串常量和字符常量都可以包含任何Unicode字符。例如：
char a = '\u0001';
String a = "\u0001";转义符
Java语言支持一些特殊的转义字符序列。
| 符号 | 字符含义 |
|---|---|
| \ddd | 八进制字符 (ddd) |
| \uxxxx | 16进制Unicode字符 (xxxx) |
| \' | 单引号字符 |
| \" | 双引号字符 |
| \\ | 双斜杠字符 |
| \r | 回车 (0x0d) |
| \n | 换行 (0x0a) |
| \b | 退格 (0x08) |
| \t | 制表符 |
| \s | 字符串 |
| \0 | 空字符 (0x20) |
| \f | 换页符(0x0c) |
修饰符不区分先后顺序
static final double PI = 3.1415927;
final static double PI = 3.1415927;两个结果都可以
5.运算符
-
算术运算符 +，-，*，/，%，++，--
-
赋值运算符=
-
关系运算符>，<，>=，<=，==，!= instanceof
-
逻辑运算符&&，||，！
-
位运算符&，|，^，~，>>，<<，>>>（了解）
-
条件运算符？：
-
扩展赋值运算符 +=，-=，*=，/=
优先级
| 优先级 | 运算符 | 结合性 |
|---|---|---|
| 1 | ()、[]、{} | 从左向右 |
| 2 | !、+正、-负、~、++、-- | 从右向左 |
| 3 | *、/、% | 从左向右 |
| 4 | +加、-减 | 从左向右 |
| 5 | «、»、>>> | 从左向右 |
| 6 | <、<=、>、>=、instanceof | 从左向右 |
| 7 | ==、!= | 从左向右 |
| 8 | & | 从左向右 |
| 9 | ^ | 从左向右 |
| 10 | | | 从左向右 |
| 11 | && | 从左向右 |
| 12 | || | 从左向右 |
| 13 | ?: | 从右向左 |
| 14 | =、+=、-=、*=、/=、&=、|=、^=、~=、«=、»=、>>>= | 从右向左 |
Java语言分隔符
分号（;）：语句的分割，表示一个代码语句结束；
花括号（{}）：表示一个代码块，是一个整体，花括号要成对使用；在面向对象的理念中，代码块通常表示一个或者多个业务逻辑；
方括号（[]）：通常是定义数组和访问数组元素时使用；
圆括号（()）：使用很广泛，如数据类型转换、数据运算、方法的定义和使用等；
圆点（.）：类和对象访问它的成员时使用，如：Arrays.sort()；
空格（ ）：把一整个代码语句语句分割成几段，空格的使用次数不限，和英语中单词之间要使用空格是一样的。
注意：以上分隔符都必须都是半角下的英文符号；.要注意区分空格和空白，空格对应的是键盘上的空格键的输入，在Java中，空格是可以作为一个有效字符使用的，而空白相对于空格来说要宽泛得多，也可以说空白是由大量的空字符组成的；
package opertor;
public class operatorTest {
public static void main(String[] args) {
//二元运算符
//ctrl + D ：赋值当前行到下一行
int a = 10;
int b = 20;
int c = 25;
int d = 25;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/(double)b);
System.out.println("######################################");
long e = 1231231231123L;
int f = 123;
short g = 10;
byte h = 8;
System.out.println(e+f+g+h);// Long
System.out.println(f+g+h);// Int
System.out.println(g+h);// Int
System.out.println("######################################");
//关系运算符
//返回结果；正确，错误 布尔值
int A = 10;
int B = 20;
int C = 21;
System.out.println(C%A);//取余，模运算
System.out.println(A>B);
System.out.println(A<B);
System.out.println(A==B);
System.out.println(A!=B);
System.out.println("######################################");
// ++ -- 自增 自减 一元运算符
int E = 3;
int F = E++;//执行玩这行代码后，先给 F 赋值，再自增
//E = E + 1
System.out.println(E);
//E = E + 1;
int G = ++E;//执行玩这行代码后，先自增，再给 G 赋值
//E = E + 1
System.out.println(E);
System.out.println(E);
System.out.println(F);
System.out.println(F);
System.out.println(G);
System.out.println(G);
System.out.println("######################################");
//幂运算 2^3 2*2*2 = 8 很多运算，我们会使用一些工具类来操作！
double pow = Math.pow(3,2);
System.out.println(pow);
}
}package opertor;
public class 逻辑运算符 {
public static void main(String[] args) {
// 与（and） 或（or） 非（取反）
boolean a = true;
boolean b = false;
System.out.println("a && b:"+(a&&b));//false 逻辑与运算：两个变量都为真，结果才为true
System.out.println("a || b:"+(a||b));//true 逻辑或运算：两个变量有一个位真，则结果为真
System.out.println("!(a && b)"+ !(a&&b));//true 逻辑非运算：取反
//短路运算
int c = 5;
boolean d = (c<4)&&(c++<4);//因为c<4是错的，那后面的(c++<4)就不会计算了，所以d为false，c还是5
System.out.println(d);//false
System.out.println(c);//c=5
}
}package opertor;
public class 位运算 {
public static void main(String[] args) {
/*
A = 0011 1100
B = 0000 1101
---------------------------
A&B = 0000 1100 //A与B，对应位全为1输出1，否则输出0
A|B = 0011 1101 //A或B，对应位全为0输出0，否则输出1
A^B = 0011 0001 //异或，对应位数字相同输出0，否则输出1
~B = 1111 0010 //取反，跟B取反
2*8 = 16 2*2*2*2
<< *2
>> /2
0000 0000 0
0000 0001 1
0000 0010 2 //
0000 0011 3
0000 0100 4 //1往左移了一位，就相当于*2
0000 1000 8
0001 0000 16
*/
System.out.println(2<<3);// 16
}
}package opertor;
public class 三元运算符 {
public static void main(String[] args) {
int a = 10;
int b = 20;
a+=b;// a = a+b
a-=b;// a = a-b
System.out.println(a);
//字符串连接符 +，在 + 两侧只要有一方出现了String类型的字符，就会把其他类型的变量转换成String类型，进行字符串的连接
System.out.println(""+a+b); //1020
System.out.println(a+b+""); //30
//三元运算符
// x ? y : z
//如果x==true，则结果为y，否则结果为z
int score = 50;
String type = score < 60 ? "不及格" : "及格";
System.out.println(type);
}
}
包机制
package com.uilufz.opertor;
//导入这个包下的所有类
import com.uilufz.base.*; // *是通配符，会导入这个包下所有的类
public class 包机制 {
//一般利用公司域名倒置作为包名
//语法格式：package pkg1[. pkg[. pkg3...]];
//使用import 导入包
//格式：import package1[.package2...].(classname|*);
}/**
* @author 作者名
* @version 版本号
* @since 指明需要最早使用的jdk版本
* @param 参数名
* @return 返回值情况
* @throws 异常抛出情况
*/包名统一使用小写，点分隔符之间有且仅有一个自然语义的英语单词。
包名统一使用单数形式，但是类名如果有复数含义，类名可以使用复数形式。
正例：应用工具类包名为 com.alibaba.ei.kunlun.aap.util、类名为 MessageUtils（此规则参考 spring 的
框架结构）
JavaDoc
命令行模式：
通过IDEA生成JavaDoc
-
注意生成 JavaDoc 的源代码对象的选择，一般以模块（Module）为主，必要时可以单独选择必要的 Java 源代码文件，
不推荐以 PRoject 为 JavaDoc 生成的源范围。
-
Locale 可选填项，表示的是需要生成的 JavaDoc 以何种语言版本展示，根据 javadoc.exe 的帮助说明，这其实对应的就是 javadoc.exe 的 -locale 参数，如果不填，默认可能是英文或者是当前操作系统的语言，既然是国人，建议在此填写 zh_CN，这样生成的 JavaDoc 就是中文版本的，当然指的是 JavaDoc 的框架中各种通用的固定显示区域都是中文的。你自己编写的注释转换的内容还是根据你注释的内容来。
-
Other command line arguments:”可选填项，非常重要，是填写直接向 javadoc.exe 传递的参数内容。因为有一些重要的设置，只能通过直接参数形式向 javadoc.exe 传递。这里必须要填写如下参数：
-encoding UTF-8 -charset UTF-8 -windowtitle "窗口名称" -link http://docs.Oracle.com/javase/8/docs/api
参数说明：
- -encoding UTF-8 表示你的源代码（含有符合 JavaDoc 标准的注释）是基于 UTF-8 编码的，以免处理过程中出现中文等非英语字符乱码；
- -charset UTF-8 表示在处理并生成 JavaDoc 超文本时使用的字符集也是以 UTF-8 为编码，目前所有浏览器都支持 UTF-8，这样最具有通用性，支持中文非常好；
- -windowtitle 表示生成的 JavaDoc 超文本在浏览器中打开时，浏览器窗口标题栏显示的文字内容；
- -link 很重要，它表示你生成的 JavaDoc 中涉及到很多对其他外部 Java 类的引用，是使用全限定名称还是带有超链接的短名称，举个例子，我创建了一个方法 public void func(String arg)，这个方法在生成 JavaDoc 时如果不指定 -link 参数，则 JavaDoc 中对该方法的表述就会自动变为 public void func(java.lang.String arg)，因为 String 这个类对我自己实现的类来讲就是外部引用的类，虽然它是 Java 标准库的类。如果指定了 -link http://docs.oracle.com/javase/8/docs/api 参数，则 javadoc.exe 在生成 JavaDoc 时，会使用 String 这样的短名称而非全限定名称 java.lang.String，同时自动为 String 短名称生成一个超链接，指向官方 JavaSE 标准文档 http://docs.oracle.com/javase/8/docs/api 中对 String 类的详细文档地址。
- -link 实质上是告诉 javadoc.exe 根据提供的外部引用类的 JavaDoc 地址去找一个叫 package-list 的文本文件，在这个文本文件中包含了所有外部引用类的全限定名称，因此生成的新 JavaDoc 不必使用外部引用类的全限定名，只需要使用短名称，同时可以自动创建指向其外部引用 JavaDoc 中的详细文档超链接。每个 JavaDoc 都会在根目录下有一个 package-list 文件，包括我们自己生成的 JavaDoc。
-
JavaDoc 生成完毕，即可在其根目录下找到 index.html 文件，打开它就可以看到我们自己的标准 JavaDoc API 文档啦。
Java开发手册（泰山版）
编程规约
(一) 命名风格
-
【强制】代码中的命名均不能以下划线或美元符号开始，也不能以下划线或美元符号结束。
反例：name / name / $name / name / name$ / name -
【强制】所有编程相关的命名严禁使用拼音与英文混合的方式，更不允许直接使用中文的方式。
说明：正确的英文拼写和语法可以让阅读者易于理解，避免歧义。注意，纯拼音命名方式更要避免采用。
正例：ali / alibaba / taobao / cainiao/ aliyun/ youku / hangzhou 等国际通用的名称，可视同英文。
反例：DaZhePromotion [打折] / getPingfenByName() [评分] / int 某变量 = 3 -
【强制】类名使用 UpperCamelCase 风格，
但以下情形例外：DO / BO / DTO / VO / AO /PO / UID 等。
正例：ForceCode / UserDO / HtmlDTO / XmlService / TcpUdpDeal / TaPromotion
反例：forcecode / UserDo / HTMLDto / XMLService / TCPUDPDeal / TAPromotion
-
【强制】方法名、参数名、成员变量、局部变量都统一使用 lowerCamelCase 风格。
正例： localValue / getHttpMessage() / inputUserId -
【强制】常量命名全部大写，单词间用下划线隔开，力求语义表达完整清楚，不要嫌名字长。
正例：MAX_STOCK_COUNT / CACHE_EXPIRED_TIME
反例：MAX_COUNT / EXPIRED_TIME -
【强制】抽象类命名使用 Abstract 或 Base 开头；异常类命名使用 Exception 结尾；
测试类命名以它要测试的类的名称开始，以 Test 结尾。
-
【强制】类型与中括号紧挨相连来表示数组。
正例：定义整形数组 int[] arrayDemo;
反例：在 main 参数中，使用 String args[]来定义。 -
【强制】POJO 类中的任何布尔类型的变量，都不要加 is 前缀，否则部分框架解析会引起序列
化错误。
说明：在本文 MySQL 规约中的建表约定第一条，表达是与否的值采用 is_xxx 的命名方式，所以，需要在
设置从 is_xxx 到 xxx 的映射关系。
反例：定义为基本数据类型 Boolean isDeleted 的属性，它的方法也是 isDeleted()，框架在反向解析的时
候，“误以为”对应的属性名称是 deleted，导致属性获取不到，进而抛出异常。
-
【强制】包名统一使用小写，点分隔符之间有且仅有一个自然语义的英语单词。包名统一使用
单数形式，但是类名如果有复数含义，类名可以使用复数形式。
正例：应用工具类包名为 com.alibaba.ei.kunlun.aap.util、类名为 MessageUtils（此规则参考 spring 的
框架结构） -
【强制】避免在子父类的成员变量之间、或者不同代码块的局部变量之间采用完全相同的命名，使可读性降低。
说明：子类、父类成员变量名相同，即使是 public 类型的变量也是能够通过编译，而局部变量在同一方法内的不同代码块中同名也是合法的，但是要避免使用。对于非 setter/getter 的参数名称也要避免与成员变量名称相同。
反例：
public class ConfusingName {
public int stock;
// 非 setter/getter 的参数名称，不允许与本类成员变量同名
public void get(String alibaba) {
if (condition) {
final int money = 666;
// ...
}
for (int i = 0; i < 10; i++) {
// 在同一方法体中，不允许与其它代码块中的 money 命名相同
final int money = 15978;
// ...
}
}
}
class Son extends ConfusingName {
// 不允许与父类的成员变量名称相同
public int stock;
}-
【强制】杜绝完全不规范的缩写，避免望文不知义。
反例：AbstractClass“缩写”命名成 AbsClass；condition“缩写”命名成 condi，此类随意缩写严重降低了代码的可阅读性。 -
【推荐】为了达到代码自解释的目标，任何自定义编程元素在命名时，使用尽量完整的单词组
合来表达。
正例：在 JDK 中，对某个对象引用的 volatile 字段进行原子更新的类名为：AtomicReferenceFieldUpdater。
反例：常见的方法内变量为 int a;的定义方式 -
【推荐】在常量与变量的命名时，表示类型的名词放在词尾，以提升辨识度。
正例：startTime / workQueue / nameList / TERMINATED_THREAD_COUNT
反例：startedAt / QueueOfWork / listName / COUNT_TERMINATED_THREAD -
【推荐】如果模块、接口、类、方法使用了设计模式，在命名时需体现出具体模式。
说明：将设计模式体现在名字中，有利于阅读者快速理解架构设计理念。
正例： public class OrderFactory;
public class LoginProxy;
public class ResourceObserver; -
【推荐】接口类中的方法和属性不要加任何修饰符号（public 也不要加），保持代码的简洁
性，并加上有效的 Javadoc 注释。尽量不要在接口里定义变量，如果一定要定义变量，确定
与接口方法相关，并且是整个应用的基础常量。
正例：接口方法签名 void commit();
接口基础常量 String COMPANY = "alibaba";
反例：接口方法定义 public abstract void f();
说明：JDK8 中接口允许有默认实现，那么这个 default 方法，是对所有实现类都有价值的默认实现。 -
接口和实现类的命名有两套规则：
1）【强制】对于 Service 和 DAO 类，基于 SOA 的理念，暴露出来的服务一定是接口，内部的实现类用
Impl 的后缀与接口区别。
正例：CacheServiceImpl 实现 CacheService 接口。
2）【推荐】如果是形容能力的接口名称，取对应的形容词为接口名（通常是–able 的形容词）。
正例：AbstractTranslator 实现 Translatable 接口。 -
【参考】枚举类名带上 Enum 后缀，枚举成员名称需要全大写，单词间用下划线隔开。
说明：枚举其实就是特殊的常量类，且构造方法被默认强制是私有。
正例：枚举名字为 ProcessStatusEnum 的成员名称：SUCCESS / UNKNOWN_REASON。 -
【参考】各层命名规约：
A) Service/DAO 层方法命名规约
1） 获取单个对象的方法用 get 做前缀。
2） 获取多个对象的方法用 list 做前缀，复数结尾，如：listObjects。
3） 获取统计值的方法用 count 做前缀。
4） 插入的方法用 save/insert 做前缀。
5） 删除的方法用 remove/delete 做前缀。
6） 修改的方法用 update 做前缀。
B) 领域模型命名规约
1） 数据对象：xxxDO，xxx 即为数据表名。
2） 数据传输对象：xxxDTO，xxx 为业务领域相关的名称。3） 展示对象：xxxVO，xxx 一般为网页名称。
4） POJO 是 DO/DTO/BO/VO 的统称，禁止命名成 xxxPOJO。
(二) 常量定义
-
【强制】不允许任何魔法值 （ 即未经预先定义的常量 ） 直接出现在代码中。
反例：
//本例中同学 A 定义了缓存的 key，然后缓存提取的同学 B 使用了 Id#taobao 来提取，少了下划线，导致故障。
String key = "Id#taobao_" + tradeId;
cache.put(key, value); -
【强制】在 long 或者 Long 赋值时，数值后使用大写的 L，不能是小写的 l，小写容易跟数字
混淆，造成误解。
说明：Long a = 2l; 写的是数字的 21，还是 Long 型的 2。 -
【推荐】不要使用一个常量类维护所有常量，要按常量功能进行归类，分开维护。
说明：大而全的常量类，杂乱无章，使用查找功能才能定位到修改的常量，不利于理解，也不利于维护。
正例：缓存相关常量放在类 CacheConsts 下；系统配置相关常量放在类 ConfigConsts 下。 -
【推荐】常量的复用层次有五层：跨应用共享常量、应用内共享常量、子工程内共享常量、包
内共享常量、类内共享常量。
1） 跨应用共享常量：放置在二方库中，通常是 client.jar 中的 constant 目录下。
2） 应用内共享常量：放置在一方库中，通常是子模块中的 constant 目录下。
反例：易懂变量也要统一定义成应用内共享常量，两位工程师在两个类中分别定义了“YES”的变量：
类 A 中：public static final String YES = "yes";
类 B 中：public static final String YES = "y";
A.YES.equals(B.YES)，预期是 true，但实际返回为 false，导致线上问题。
3） 子工程内部共享常量：即在当前子工程的 constant 目录下。
4） 包内共享常量：即在当前包下单独的 constant 目录下。
5） 类内共享常量：直接在类内部 private static final 定义。 -
【推荐】如果变量值仅在一个固定范围内变化用 enum 类型来定义。
说明：如果存在名称之外的延伸属性应使用 enum 类型，下面正例中的数字就是延伸信息，表示一年中的
第几个季节。
正例：
public enum SeasonEnum {
SPRING(1), SUMMER(2), AUTUMN(3), WINTER(4);
private int seq;
SeasonEnum(int seq) {
this.seq = seq;
}
public int getSeq() {
return seq;
}
}(三) 代码格式
-
【强制】如果是大括号内为空，则简洁地写成{}即可，大括号中间无需换行和空格；如果是非
空代码块则：
1） 左大括号前不换行。
2） 左大括号后换行。
3） 右大括号前换行。
4） 右大括号后还有 else 等代码则不换行；表示终止的右大括号后必须换行。 -
【强制】左小括号和右边相邻字符之间不出现空格 ； 右小括号和左边相邻字符之间也不出现空
格；而左大括号前需要加空格。详见第 5 条下方正例提示。
反例：if (空格 a == b 空格) -
【强制】if/for/while/switch/do 等保留字与括号之间都必须加空格。
-
【强制】任何二目、三目运算符的左右两边都需要加一个空格。
说明：包括赋值运算符=、逻辑运算符&&、加减乘除符号等。 -
【强制】采用 4 个空格缩进，禁止使用 tab 字符。
说明：如果使用 tab 缩进，必须设置 1 个 tab 为 4 个空格。IDEA 设置 tab 为 4 个空格时，请勿勾选 Use tab
character；而在 eclipse 中，必须勾选 insert spaces for tabs。
正例： （涉及 1-5 点）
public static void main(String[] args) {
// 缩进 4 个空格
String say = "hello";
// 运算符的左右必须有一个空格
int flag = 0;
// 关键词 if 与括号之间必须有一个空格，括号内的 f 与左括号，0 与右括号不需要空格
if (flag == 0) {
System.out.println(say);
}
// 左大括号前加空格且不换行；左大括号后换行
if (flag == 1) {
System.out.println("world");
// 右大括号前换行，右大括号后有 else，不用换行
} else {
System.out.println("ok");
// 在右大括号后直接结束，则必须换行
}
}-
【强制】注释的双斜线与注释内容之间有且仅有一个空格。
正例：
// 这是示例注释，请注意在双斜线之后有一个空格
String commentString = new String(); -
【强制】在进行类型强制转换时，右括号与强制转换值之间不需要任何空格隔开。
正例：
long first = 1000000000000L;
int second = (int)first + 2; -
【强制】单行字符数限制不超过 120 个，超出需要换行，换行时遵循如下原则：
1）第二行相对第一行缩进 4 个空格，从第三行开始，不再继续缩进，参考示例。
2）运算符与下文一起换行。
3）方法调用的点符号与下文一起换行。
4）方法调用中的多个参数需要换行时，在逗号后进行。
5）在括号前不要换行，见反例。
正例：
StringBuilder sb = new StringBuilder();
// 超过 120 个字符的情况下，换行缩进 4 个空格，并且方法前的点号一起换行
sb.append("zi").append("xin")...
.append("huang")...
.append("huang")...
.append("huang");
反例：
StringBuilder sb = new StringBuilder();
// 超过 120 个字符的情况下，不要在括号前换行
sb.append("you").append("are")...append
("lucky");
// 参数很多的方法调用可能超过 120 个字符，逗号后才是换行处
method(args1, args2, args3, ...
, argsX);-
【强制】方法参数在定义和传入时，多个参数逗号后边必须加空格。
正例：下例中实参的 args1，后边必须要有一个空格。
method(args1, args2, args3); -
【强制】IDE 的 text file encoding 设置为 UTF-8; IDE 中文件的换行符使用 Unix 格式，不要
使用 Windows 格式。 -
【推荐】单个方法的总行数不超过 80 行。
说明：除注释之外的方法签名、左右大括号、方法内代码、空行、回车及任何不可见字符的总行数不超过
80 行。
正例：代码逻辑分清红花和绿叶，个性和共性，绿叶逻辑单独出来成为额外方法，使主干代码更加清晰；共
性逻辑抽取成为共性方法，便于复用和维护。 -
【推荐】没有必要增加若干空格来使变量的赋值等号与上一行对应位置的等号对齐。
正例：
int one = 1;
long two = 2L;
float three = 3F;
StringBuilder sb = new StringBuilder();
说明：增加 sb 这个变量，如果需要对齐，则给 one、two、three 都要增加几个空格，在变量比较多的情
况下，是非常累赘的事情。 -
【推荐】不同逻辑、不同语义、不同业务的代码之间插入一个空行分隔开来以提升可读性。
说明：任何情形，没有必要插入多个空行进行隔开。
