常量：在程序运行期间，固定不变的量。
常量的分类：
举例：
//字符串常量
System.out.println(""); // 正确！字符串两个双引号中间的内容为空，像空一行的效果。
//字符常量
System.out.println(''); // 错误！两个单引号中间必须有且仅有一个字符，没有不行。
System.out.println('AB'); // 错误！两个单引号中间必须有且仅有一个字符，有两个不行。
//空常量。空常量不能直接用来打印输出。
System.out.println(null); // 错误！System.out.println里 \n： 换行
\t： tab
变量：程序运行期间，内容可以发生改变的量。
创建一个变量并且使用的格式：
1、数据类型 变量名称; // 创建了一个变量
变量名称 = 数据值; // 赋值，将右边的数据值，赋值交给左边的变量
2、一步到位的格式：
数据类型 变量名称 = 数据值; // 在创建一个变量的同时，立刻放入指定的数据值
注意：右侧数值的范围不能超过左侧数据类型的取值范围
int num1;
num1 = 10;
System.out.println(num1); // 10
int num2 = 25;
System.out.println(num2); // 25
var1 = false;
System.out.println(var1); // false
// 将一个变量的数据内容，赋值交给另一个变量
// 右侧的变量名称var1已经存在，里面装的是false布尔值
// 将右侧变量里面的false值，向左交给var2变量进行存储
boolean var2 = var1;
System.out.println(var2); // false // 同时创建了三个全都是int类型的变量
int a, b, c;
// 各自分别赋值
a = 10;
b = 20;
c = 30;
// 同时创建三个int变量，并且同时各自赋值
int x = 100, y = 200, z = 300;基本数据类型：包括 整数、浮点数、字符、布尔
引用数据类型：包括 类、数组、接口
将“数据范围小的类型”自动提升为“数据范围大的类型”
数据范围从小到大，与字节数不一定相关
比较对象： int double
注意！右侧的数值大小不能超过左侧的类型范围 // byte num4 = 40;
byte / short / char --> int --> long --> float --> double
? boolean类型不能发生数据类型转换！
? byte / short / char 运算时，先提升为int再计算。
? 对于byte/short/char三种类型来说，如果右侧赋值的数值没有超过范围，那么javac编译器将会自动隐含地为我们补上一个(byte)(short)(char)。
【举例】
int --> byte，不是自动类型转换，没有超过范围
编译器将会自动补上一个隐含的(byte)
byte num1 = /*(byte)*/ 30; // 右侧没有超过左侧的范围//byte num2 = 128; // 报错，右侧超过了左侧的范围int --> char
char zifu = /*(char)*/ 65; // A? 在给变量进行赋值的时候，如果右侧的表达式当中全都是常量，没有任何变量，那么编译器javac将会直接将若干个常量表达式计算得到结果。
short result = 5 + 8; // 等号右边全都是常量，没有任何变量参与运算编译之后，得到的.class字节码文件当中相当于【直接就是】：
short result = 13;右侧的常量结果数值，没有超过左侧范围，所以正确。
这称为“编译器的常量优化”。
但是注意：一旦表达式当中有变量参与，那么就不能进行这种优化了。
short num1 = 10; // 正确写法，右侧没有超过左侧的范围short + short --> int + int --> int
//short result = a + b; // 错误写法！左侧需要是int类型正确写法：右侧不用变量，而是采用常量，而且只有两个常量，没有别人。
short result = 5 + 8;short s = 1;
s+=1;
s+=1 就是 s = (short)(s+1)一旦运算中有不同类型的数据，结果是大范围的类型
被除数/除数 = 商…余数
对于整数表达式来说，整数/整数=商，结果仍为整数，只看商，不看余数
取模（取余数）：整数 % 整数 = 余数，只有对整数的除法来说，取模才有意义
% 判断奇偶 如：5%2=1
将 数据范围大的类型 自动提升为 数据范围小的类型
数据类型 变量名 = （数据类型）（被转数据值）
double（浮点）类型转成整数型，直接去掉小数点，可能造成数据损失精度
?int a = (int)1.5
int强制转换成short，砍掉2个字节，可能造成数据丢失
String 如：String str = ‘Hello‘;
对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作。
/String + int --> String
任何数据类型 + 字符串 = 字符串
优先级问题 ：
? 从左往右
? String + int + int -->
? String + int -->
? String
破解之法：小括号优于一切
数组、类、接口
特点：
如：public class static void
static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况下，去调用方法。
静态方法/变量占用时间长，不容易被释放
static{} 后面加载数据库jdbc用的广泛
如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享同一份数据。
当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。
定义格式：
static 数据类型 变量名；举例：
static int numberID;当 static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有 static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。
定义格式：
修饰符 static 返回值类型 方法名（参数列表）{
//执行语句
}举例：在Student类中定义静态方法
public static void showNum(){
System.out.println("num:" + numberOfStudent);
}静态方法调用的注意事项：
静态方法可以直接访问类变量和静态方法。
静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
静态方法中，不能使用this关键字。
静态方法只能访问静态成员。
调用格式：
//访问类变量
类名.类变量名；
//调用静态方法
类名.静态方法名（参数）static 修饰的内容：
是随着类的加载而加载的，且只加载一次。
存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。
它优先于对象存在，所以，可以被所有对象共享。
定义在成员位置，使用static修饰的代码块{ }。
位置：类中方法外。
执行：随着类的加载而执行且只执行一次，优先于main方法和构造方法的执行。
格式：
public class ClassName{
static{
//执行语句
}
}作用：给类变量进行初始化赋值
不可改变。可以用于修饰类、方法和变量。
final class 类名{
}修饰符 final 返回值类型 方法名（参数列表）{
//方法体
}1、局部变量——基本类型
基本类型的局部变量，被final修饰后，只能赋值1次，不能再更改。
2、局部变量——引用类型
引用类型的局部变量，被final修饰后，只能指向一个对象，地址不得再更改，但是不影响对象内部的成员变量值的变化。
3、成员变量
对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。
自己定义的内容。比如类名、方法名、变量名等。
标识符可以包含 英文字母26个（区分大小写）、数字0-9、$、_
标识符不能以数字开头。
标识符不能是关键字
类名（接口名）规范：首字母大写，后面每个单词首字母大写（大驼峰）
方法名规范：首字母小写，后面每个单词首字母大写（小驼峰）
变量名规范：全部小写
赋值运算符分为：
基本赋值运算符：就是一个等号“=”，代表将右侧的数据交给左侧的变量。
int a = 30;
复合赋值运算符：
| 符号 | 用法 | 解释 |
|---|---|---|
| += | a += 3 | 相当于 a = a + 3 |
| -= | b -= 4 | 相当于 b = b - 4 |
| *= | c *= 5 | 相当于 c = c * 5 |
| /= | d /= 6 | 相当于 d = d / 6 |
| %= | e %= 7 | 相当于 e = e % 7 |
注意事项：
基本含义：让一个变量涨一个数字1，或者让一个变量降一个数字1
使用格式：写在变量名称之前，或者写在变量名称之后。例如：++num，也可以num++
使用方式：
使用区别：
注意事项：
只有变量才能使用自增、自减运算符。常量不可发生改变，所以不能用。
大于： >
小于： <
大于等于： >=
小于等于： <=
相等： == 【两个等号连写才是相等，一个等号代表的是赋值】
不相等： !=
注意事项：
与（并且） && 全都是true，才是true；否则就是false
或（或者） || 至少一个是true，就是true；全都是false，才是false
非（取反） ! 本来是true，变成false；本来是false，变成true
与“&&”，或“||”，具有短路效果：如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能。
注意事项：
TIPS：
对于1 < x < 3的情况，应该拆成两个部分，然后使用与运算符连接起来：
int x = 2;
1 < x && x < 3
一元运算符：只需要一个数据就可以进行操作的运算符。例如：取反!、自增++、自减--
二元运算符：需要两个数据才可以进行操作的运算符。例如：加法+、赋值=
三元运算符：需要三个数据才可以进行操作的运算符。
格式：
数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;
流程：
首先判断条件是否成立：
如果成立为true，那么将表达式A的值赋值给左侧的变量；
如果不成立为false，那么将表达式B的值赋值给左侧的变量；
二者选其一。
注意事项：
如：int i = (1==2 ? 100 : 200);
System.out.println(i);//200
又如：System.out.println(3==4 ? 100.12 : 400); //400.0
定义一个方法的格式：
public static void 方法名称() {
方法体
}方法名称的命名规则和变量一样，使用小驼峰。
方法体：也就是大括号当中可以包含任意条语句。
注意事项：
如何调用方法，格式：
方法名称();不能用输出语句（System.out...）调用void方法，因为方法执行后没有结果，就打印不出任何内容。
修饰符 返回值类型 方法名称（参数类型 参数名称, … ）{
方法体;
return 返回值;
}参数类型可以是不同的
方法体里定义的变量或数组，都仅在方法里存在，出了方法就没有了
修饰符：现阶段的固定写法：public static
返回值类型：也就是方法最终产生的数据结果是什么类型
方法名称：方法的名字、规则和变量一样，小驼峰
参数类型：进入方法的数据是什么类型
参数名称：进入方法的数据对应的变量名称
PS：参数如果有多个，使用逗号进行分隔
方法体：方法需要做的事，若干行代码
return：两个作用，①停止当前方法，②将后面的返回值还给调用处
返回值：也就是方法执行后最终产生的数据结果
注意：return后面的“返回值”，必须和方法名称前面的“返回值类型”保持对应。
单独调用：方法名称（参数）;
打印调用：System.out.println(方法名称（参数）);
赋值调用：数据类型 变量名称 = 方法名称（参数）;
/**
* //方法描述
*@param //变量说明
*@param //变量说明
*@return //返回值说明
**/参数个数不同
参数类型不同
参数的多类型顺序不同
核心：确保重载的方法的参数列表都是唯一的，不能有重复，确保根据参数个数可以直接找到需要调用的唯一的方法
byte a = 20;
byte b = 20;
getAdd(a,b);
getAdd((short)20,(short)20);
getAdd(20L,20L);与参数的名称无关
与方法的返回值类型无关
先断点：（多）选中要单独测试的行（红点）
鼠标定位在打算Debug行，再 在左侧右键Debug || shift + F9 || 上方爬虫图标
按 F8 依次向下查看结果
蓝色的行是定位，需要F8后，才会显示
定位到调用方法的方法所在 ：
断点到调用方法所在行，Debug，再鼠标点击所调用方法
Run -> Step into || F7
如果是多行调用方法，只会找到第一行的方法
打开工具栏，会显示定位到哪一个class
View -> Toolbar
if(关系表达式){
语句体；
}if(关系表达式){
语句体1；
}
else{
语句体2；
}if (判断条件1){
?执行语句1;
} else if (判断条件2){
执行语句2;
}
...
} else if (判断条件n){
?执行语句n; ???
} else {
?执行语句n+1; ??
}swith(表达式，即被检测量){
case 常量值1:
语句体1;
break;
case 常量值2:
语句体2;
break;
…
default:
语句体n+1;
break;
} 注意：
注意：
控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。
在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。
使用场景：终止switch或者循环 打断整个循环（if，但switch或for打断1个）
在选择结构switch语句中
在循环语句中
离开使用场景的存在是没有意义的
使用场景：结束本次循环，继续下一次的循环
死循环：也就是循环中的条件永远为true，死循环的是永不结束的循环。
例如：
while(true){
循环体;
}? 在后期的开发中，会出现使用死循环的场景，例如：我们需要读取用户输入的输入，但是用户输入多少数据我们并 不清楚，也只能使用死循环，当用户不想输入数据了，就可以结束循环了，如何去结束一个死循环呢，就需要使用 到跳出语句了 if … break
死循环后面除了有break，不然轮不到！就报错！
? 小黑框里停止刷屏：control + C
数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致
特性：
数组是引用数据类型；
数组里面存储的数据类型都是一致的；
数组的长度在运行期间无法改变
数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
注意：数组有定长特性，长度一旦指定，不可更改。
int[] arr = new int[3];动态初始化（指定长度）
// 动态初始化可以拆分成为两个步骤
int[] arr;
arr = new int[3];数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
int[] arr = new int[]{1,2,3,4,5};静态初始化（指定内容）
// 静态初始化的标准格式，可以拆分成为两个步骤
int[] arr;
arr = new int[]{1,2,3,4,5};数据类型[] 数组名 = {元素1,元素2,元素3...};
int[] arr = {1,2,3,4,5};省略型静态初始化（指定内容）
// 静态初始化的省略格式，不能拆分成为两个步骤。
方法中的变量arr保存的是数组的地址哈希值，因此是引用数据类型
数组中元素默认值0
每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引 (index)，可以通过数组的索引访问到数组中的元素。
数组名[索引]
| 语法 | 功能 |
|---|---|
| 数组名.length | 数组的长度 |
| 数组名.length - 1 | 数组的最大索引值 |
| 数组名[索引]=数值 | 为数组中的元素赋值 |
| 变量=数组名[索引] | 获取出数组中的元素 |
//定义数组变量arr2，将arr的地址赋值给arr2
int[]?arr2?=?arr;
arr2[1]?=?9; //arr[1]也会同时改变为9，因为同一个地址arr?=?null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候 会抛出 NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修 改我们编写的代码。
我们不能访问数组中不存在的索引，程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。
public class Demo1 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
for (int i = 0; i < arr.length; i++) { //arr.fori 倒：arr.forr
System.out.println(arr[i]);
}
}
}public static void main(String[] args){
//调用方法，接收数组的返回值
//接收到的是数组的内存地址
int[]?arr?=?getArray();
for(int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
? }
}
public static int[] getArray() {
int[] arr?=?{1,2,3,4,5};
? //返回数组的地址，返回到调用者
? return?arr;
}public static void main(String[] args){
int[] arr = {1,2,3,4,5};
change();
}
public static void change(int[] arr) {
?? arr[0]?=?200; ??
}方法的参数为基本类型时,传递的是数据值.
方法的参数为引用类型时,传递的是地址值.
File -> Setting -> Live Templates -> 先 + Templates Group，再 + Live Templates，在Abbreviation中輸入一個（這裏是）（在方法内輸入 ，再按 tab 就會跳出的意思）
在Template text裏輸入以下：
/**
* @author: $user$
$params$
* @return $returns$
* @description:
* @date: $time$ $date$
**/在Edit variables裏定義以下：
params - Expression：
groovyScript("def result=‘‘; def params="${_1}".replaceAll(‘[\\[|\\]|\\s]‘, ‘‘).split(‘,‘).toList(); for(i = 0; i < params.size(); i++) {result+=‘ * @param ‘ + params[i] + ((i < params.size() - 1) ? ‘\n\b‘ : ‘‘)}; return result", methodParameters())
returns：methodReturnType()
time：time()
date：date()
Apply -> OK
Scanner
Scanner sc = new Scanner(System.in);
int j = sc.nextInt();public：公共的
protected：受保护的
default：默认的
private：私有的
成员变量使用private，隐藏细节
构造方法使用public，方便构建对象
成员方法使用public，方便调用方法
将一个类A定义在另一个类B里面，里面那个类A就称为内部类，B则称为外部类
定义在类中方法外的类
class 外部类{
class 内部类{
}
}内部类可以直接访问外部类的成员，包括私有成员。
外部类要访问内部类的成员，必须要建立内部类的对象。
创建内部类对象格式：
外部类名.内部类名 对象名 = new 外部类型().new 内部类型();内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。
比如，Person$Heart.class
// 如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名
public class Outer {
int num = 10; // 外部类的成员变量
public class Inner /*extends Object*/ {
int num = 20; // 内部类的成员变量
public void methodInner() {
int num = 30; // 内部类方法的局部变量
System.out.println(num); // 局部变量，就近原则
System.out.println(this.num); // 内部类的成员变量
System.out.println(Outer.this.num); // 外部类的成员变量
}
}
}修饰符 class 外部类名称 {
修饰符 返回值类型 外部类方法名称(参数列表) {
class 局部内部类名称 {
// ...
}
}
}局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】。
备注：从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。
原因：
public class MyOuter {
public void methodOuter() {
int num = 10; // 所在方法的局部变量
class MyInner {
public void methodInner() {
System.out.println(num);
}
}
}
}public > protected > (default) > private
定义一个类的时候，权限修饰符规则：
是内部类的简化写法。它的本质是一个【带具体实现的】【父类或者父接口】【匿名的】子类对象
如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。
接口名称 对象名 = new 接口名称() {
// 覆盖重写所有抽象方法
};对格式“new 接口名称() {...}”进行解析：
| 场景 | 说明 |
|---|---|
| class作为成员变量 | 类作为成员变量时，对它进行赋值的操作，实际上，是赋给它该类的一个对象 |
| interface作为成员变量 | 接口作为成员变量，对它进行赋值的操作，实际上是赋给它该接口的一个子类对象 |
| interface作为方法参数和返回值类型 | 当接口作为方法的返回值类型时，返回的是它的子类对象。 |
原文：https://www.cnblogs.com/shinl00/p/10536179.html