编程基础

编程基础

常量

常量：在程序运行期间，固定不变的量。

常量的分类：

字符串常量：凡是用双引号引起来的部分，叫做字符串常量。例如："abc"、"Hello"、"123"
整数常量：直接写上的数字，没有小数点。例如：100、200、0、-250
浮点数常量：直接写上的数字，有小数点。例如：2.5、-3.14、0.0
字符常量：凡是用单引号引起来的单个字符，就做字符常量。例如：'A'、'b'、'9'、'中'、'!'，'@'
布尔常量：只有量中取值。true、false。
空常量：null。代表没有任何数据。

举例：

//字符串常量
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

使用变量的注意事项

如果创建多个变量，那么变量之间的名称不可以重复。
对于float和long类型来说，字母后缀F和L不要丢掉。
如果使用byte或者short类型的变量，那么右侧的数据值不能超过左侧类型的范围。
没有进行赋值的变量，不能直接使用；一定要赋值之后，才能使用。
变量使用不能超过作用域的范围。
【作用域】：从定义变量的一行开始，一直到直接所属的大括号结束为止。
可以通过一个语句来创建多个变量，但是一般情况不推荐这么写，不方便注释。

  // 同时创建了三个全都是int类型的变量
  int a, b, c;
  // 各自分别赋值
  a = 10;
  b = 20;
  c = 30;

  // 同时创建三个int变量，并且同时各自赋值
  int x = 100, y = 200, z = 300;

数据类型

基本数据类型：包括整数、浮点数、字符、布尔
引用数据类型：包括类、数组、接口

基本数据类型

1 自动类型转换

将“数据范围小的类型”自动提升为“数据范围大的类型”
数据范围从小到大，与字节数不一定相关
比较对象： int double
注意！右侧的数值大小不能超过左侧的类型范围 // byte num4 = 40;

2 转换规则

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)

3 四则运算

一旦运算中有不同类型的数据，结果是大范围的类型
被除数/除数 = 商…余数
对于整数表达式来说，整数/整数=商，结果仍为整数，只看商，不看余数
取模（取余数）：整数 % 整数 = 余数，只有对整数的除法来说，取模才有意义
% 判断奇偶如：5%2=1

4 强制类型转换

将数据范围大的类型自动提升为数据范围小的类型
数据类型变量名 = （数据类型）（被转数据值）

double（浮点）类型转成整数型，直接去掉小数点，可能造成数据损失精度

int a = (int)1.5
int强制转换成short，砍掉2个字节，可能造成数据丢失

5 字符串

String 如：String str = 'Hello';
对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作。
/String + int --> String
任何数据类型 + 字符串 = 字符串

优先级问题 ：

从左往右
String + int + int -->
String + int -->
String
破解之法：小括号优于一切

引用数据类型

数组、类、接口

关键字

特点：

完全小写的字母。
在增强版的记事本当中（例如Notepad++）有特殊颜色。

如：public class static void

static关键字

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

不可改变。可以用于修饰类、方法和变量。

类：被修饰的类，不能被继承。
方法：被修饰的方法，不能被重写。
变量：被修饰的变量，不能被重新赋值。

修饰类

final class 类名{

}

修饰方法

修饰符 final 返回值类型 方法名（参数列表）{
    //方法体
}

修饰变量

1、局部变量——基本类型

基本类型的局部变量，被final修饰后，只能赋值1次，不能再更改。

2、局部变量——引用类型

引用类型的局部变量，被final修饰后，只能指向一个对象，地址不得再更改，但是不影响对象内部的成员变量值的变化。

3、成员变量

对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。

由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。

被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++
使用方式：

单独使用：不和其他任何操作混合，自己独立成为一个步骤。
混合使用：和其他操作混合，例如与赋值混合，或者与打印操作混合，等。

使用区别：

在单独使用的时候，前++和后++没有任何区别。即：++num;和num++;是完全一样的。
在混合的时候，有【重大区别】
A. 如果是【前++】，那么变量【立刻马上+1】，然后拿着结果进行使用【先加后用】
B. 如果是【后++】，那么首先使用变量本来的数值，【然后再让变量+1】【先用后加】

注意事项：
只有变量才能使用自增、自减运算符。常量不可发生改变，所以不能用。

比较运算符

大于： >
小于： <
大于等于： >=
小于等于： <=
相等： == 【两个等号连写才是相等，一个等号代表的是赋值】
不相等： !=

注意事项：

比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false
如果进行多次判断，不能连着写。
数学当中的写法，例如：1 < x < 3
程序当中【不允许】这种写法。

逻辑运算符【与或非】

与（并且） && 全都是true，才是true；否则就是false
或（或者） || 至少一个是true，就是true；全都是false，才是false
非（取反） ! 本来是true，变成false；本来是false，变成true

与“&&”，或“||”，具有短路效果：如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能。

注意事项：

逻辑运算符只能用于boolean值。
与、或需要左右各自有一个boolean值，但是取反只要有唯一的一个boolean值即可。
与、或两种运算符，如果有多个条件，可以连续写。
两个条件：条件A && 条件B
多个条件：条件A && 条件B && 条件C

TIPS：
对于1 < x < 3的情况，应该拆成两个部分，然后使用与运算符连接起来：
int x = 2;
1 < x && x < 3

三元运算符（推荐）

一元运算符：只需要一个数据就可以进行操作的运算符。例如：取反!、自增++、自减--
二元运算符：需要两个数据才可以进行操作的运算符。例如：加法+、赋值=
三元运算符：需要三个数据才可以进行操作的运算符。

格式：
数据类型变量名称 = 条件判断 ? 表达式A : 表达式B;

流程：
首先判断条件是否成立：
如果成立为true，那么将表达式A的值赋值给左侧的变量；
如果不成立为false，那么将表达式B的值赋值给左侧的变量；
二者选其一。

注意事项：

必须同时保证表达式A和表达式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行，再在左侧右键Debug || shift + F9 || 上方爬虫图标
按 F8 依次向下查看结果

蓝色的行是定位，需要F8后，才会显示

定位到调用方法的方法所在 ：

断点到调用方法所在行，Debug，再鼠标点击所调用方法
Run -> Step into || F7

如果是多行调用方法，只会找到第一行的方法

control + 单击方法

打开工具栏，会显示定位到哪一个class

View -> Toolbar

流程控制语句

if else判断语句

if(关系表达式){
  语句体；
}

if(关系表达式){
  语句体1；
}
else{
  语句体2；
}

if (判断条件1){
  执行语句1;
} else if (判断条件2){
   执行语句2;
}
 ... 
} else if (判断条件n){
  执行语句n;     
} else {
  执行语句n+1;    
}

switch选择语句

swith(表达式，即被检测量){  
  case 常量值1:
    语句体1;
    break;
  case 常量值2:
    语句体2;
    break;
…
  default:
    语句体n+1;
    break;
}

注意：

小括号里只能是基本数据类型：byte/short/char/int 或引用数据类型：String字符串、enum枚举
匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止。
如果case的后面不写break，将出现穿透现象，程序会一直向后走，不会再判断case，直到遇到break，或者整体switch结束。
如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉

for循环语句

注意：

初始化表达式不要忘记定义变量如：int x = 1
步进表达式可以不写
for的初始表达式如果想初始化多个变量，应该这样写: int a = 0,b = o,c = 0;

while循环语句

do while循环语句

for 和 while 的小区别

控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。
在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。

跳出语句break

使用场景：终止switch或者循环打断整个循环（if，但switch或for打断1个）

在选择结构switch语句中
在循环语句中

离开使用场景的存在是没有意义的

跳出语句continue

使用场景：结束本次循环，继续下一次的循环

死循环

死循环：也就是循环中的条件永远为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	数组的最大索引值
数组名[索引]=数值	为数组中的元素赋值
变量=数组名[索引]	获取出数组中的元素

JVM的内存划分

两个变量指向一个数组

//定义数组变量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关键字可以省略。

原因：

new出来的对象在堆内存当中。
局部变量是跟着方法走的，在栈内存当中。
方法运行结束之后，立刻出栈，局部变量就会立刻消失。
但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。

public class MyOuter {
    public void methodOuter() {
        int num = 10; // 所在方法的局部变量
        class MyInner {
            public void methodInner() {
                System.out.println(num);
            }
        }
    }
}

小节一下类的权限修饰符

public > protected > (default) > private
定义一个类的时候，权限修饰符规则：

外部类：public / (default)
成员内部类：public / protected / (default) / private
局部内部类：什么都不能写

匿名内部类【重点】

是内部类的简化写法。它的本质是一个【带具体实现的】【父类或者父接口】【匿名的】子类对象

如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。

匿名内部类的定义格式

接口名称 对象名 = new 接口名称() {
    // 覆盖重写所有抽象方法
};

对格式“new 接口名称() {...}”进行解析：

new代表创建对象的动作
接口名称就是匿名内部类需要实现哪个接口
{...}这才是匿名内部类的内容

引用类型用法总结

场景	说明
class作为成员变量	类作为成员变量时，对它进行赋值的操作，实际上，是赋给它该类的一个对象
interface作为成员变量	接口作为成员变量，对它进行赋值的操作，实际上是赋给它该接口的一个子类对象
interface作为方法参数和返回值类型	当接口作为方法的返回值类型时，返回的是它的子类对象。

编程基础

编程基础

常量

变量

使用变量的注意事项

数据类型

基本数据类型

1 自动类型转换

2 转换规则

3 四则运算

4 强制类型转换

5 字符串

引用数据类型

关键字

static关键字

类变量

类方法（静态方法）

静态原理

静态代码块

final

修饰类

修饰方法

修饰变量

被final修饰的常量名称，一般都有书写规范，所有字母都大写。

标识符

硬要求

软建议

运算符

复合赋值运算符

自减运算符-- 自增运算符++

比较运算符

逻辑运算符【与 或 非】

三元运算符（推荐）

方法

方法定义注意事项

定义方法的完整格式

方法的三种调用方式

写方法时的注释

方法重载和下列因素 有关

方法重载和下列因素 无关

Debug

流程控制语句

if else判断语句

switch选择语句

for循环语句

while循环语句

do while循环语句

for 和 while 的小区别

跳出语句break

跳出语句continue

死循环

循环结构的四个组成部分（面试）

数组

定义数组

索引

JVM的内存划分

两个变量指向一个数组

数组空指针异常

数组越界异常

数组遍历

数组作为方法的返回值， 返回的是数组的内存地址

数组作为方法参数

设置方法的注释

通过键盘录入数字

权限修饰符

不同权限的访问能力

建议

内部类

成员内部类

访问特点【内用外，随意访问；外用内，需要内部类对象。】

调用不同位置的变量

局部内部类

小节一下类的权限修饰符

匿名内部类【重点】

匿名内部类的定义格式

引用类型用法总结

逻辑运算符【与或非】

方法重载和下列因素有关

方法重载和下列因素无关

数组作为方法的返回值，返回的是数组的内存地址