1. 命令提示符（cmd）

启动 Win+R
切换盘符 盘符名称：
进入文件夹 cd 文件夹名称
进入多级文件夹 cd 文件夹1\文件夹2\文件夹3
返回上一级 ** cd …**
直接回根路径 *cd *
查看文件夹 dir
清屏 cls
退出 exit

2. 基本数据类型

基本数据类型：整形浮点型字符型布尔型
整数型：byte short int long
浮点型：float double
字符型：char
布尔型：boolean
引用数据类型：字符串、Lambda、类、数组、接口等
四类八种基本数据类型
注意事项：
① 字符串不是基本数据类型，而是引用数据类型。
② 浮点型可能只是一个近似值，并非精确的值。
③ 数据范围与字节数不一定相关，例如float数据范围比long更加广泛，但是float是4字节，long是8字节。
④ 浮点数当中默认类型是double。如果要使用float类型，需要加上一个后缀F。
⑤ 如果是整数，默认类型为int，如果要使用long类型，需要加上一个后缀L。推荐使用大写。

3. 强制类型转换

特点：代码需要进行特殊的格式处理，不能自动完成
格式：范围小的类型范围小的类型名 = （范围小的类型）原本范围大的数据
注意事项：
① 强制类型转换一般不推荐使用，因为有可能发生精度损失，数据溢出。
② byte/short/char这三种类型都可以发生数学运算，例如加法"+"。
③ byte/short/char这三种类型在发生运算的时候，都会首先提升为int类型，然后再计算。

4. IDEA常用快捷键

5. 使用方法的时候，注意事项：

方法应该定义在类当中，但是不能在方法中再定义方法。不能嵌套。
方法定义的前后顺序无所谓。
方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用。
如果方法有返回值，必须写上"return 返回值;"，不能没有。
return后面的返回值数据，必须和方法的返回值类型相对应。
对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。
对于void方法当中最后一行的return，可以省略不写。
一个方法中可以有多个return语句，但是必须保证只有一个会被执行到。

6. 方法的重载（Overload）

定义：多个方法的名称一样，但是参数列表不一样。
好处：只需要记住唯一一个方法名称，就可以实现多个类似功能。
方法重载与下列因素有关：

参数个数不同
参数类型不同
参数多类型顺序不同

方法重载与下列因素无关：

与参数名称无关删除线格式
与方法的返回值类型无关

7. Java中的内存划分

Java的内存需要划分为5个部分：

栈（Stack）：存放的都是方法中的局部变量。方法的运行一定都在栈当中。
局部变量：方法的参数，或者是方法{}内部的变量。
作用域：一旦超出作用域，立即从栈内存中消失。
堆（Heap）：凡是new出来的东西，都在堆当中。
堆内存里面的东西都有一个地址值：16进制。
对内存里面的数据，都有默认值。规则：
如果是整数默认为0
如果是浮点数默认为0.0
如果是字符默认为’\u0000’
如果是布尔默认为false
如果是引用类型默认为null
方法区（Method Area）：存储.class相关信息，包含方法的信息。
本地方法栈（Native Method Stack）：与操作系统相关。
寄存器（pc Register）：与CPU相关。

一个数组的内存图：

定义数组的array为局部变量，是存储在栈当中的。
new出来的int[3]数组是存储在堆当中的。
array实际存储的为堆中int[3]的地址。
两个数组的内存图：

数组与数组之间互不影响。
两个引用指向同一个数组

引用指向同一个数组，作用的地址相同。

8. 对象的创建

通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。

导包：也就是指出需要使用的类，在什么位置
import 包名称.类名称
对于和当前类属于一个包的情况，可以省略导包语句不写。
创建，格式：
类名称对象名 = new 类名称();
使用，分为两种情况
① 使用成员变量：对象名.成员变量名
② 使用成员方法：对象名.成员方法名(参数0)
注意事项：如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

一个对象的内存图

成员变量直接在堆中进行访问使用，成员方法先访问堆中成员方法，获取地址，再进入方法区，获取成员方法，将该方法入栈，执行完后立即出栈。
两个对象使用同一个方法的内存

成员变量是分开各自的，成员方法都是记录的地址。
两个引用指向同一个对象的
使用对象类型作为方法的返回值

当使用一个对象类型作为方法的返回值时：返回值其实就是对象的地址值。

9. 局部变量和成员变量的区别

定义的位置不一样
局部变量：在方法的内部。
成员变量：在方法的外部，直接写在类当中。
作用范围不一样
局部变量：只有方法当中才可以使用，出了方法就不能再用。
成员变量：整个类全都可以通用。
默认值不一样
局部变量：没有默认值，如果想使用，必须手动赋值。
成员变量：如果没有赋值，会有默认值，规则和数组一样。
内存的位置不一样
局部变量：位于栈内存。
成员变量：位于堆内存。
生命周期不一样
局部变量：随着方法进栈而诞生，随着方法出栈而消失。
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失。

10. private

对于基本类型中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变。

11. 构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。

public 类名称(参数类型 参数名称){方法体
}

注意事项：

构造方法的名称必须和所在的类名完全一样，就连大小写也要一样。
构造方法不能有返回值，不要写返回值类型，连void都不写。
构造方法可以重载。（方法名称相同，参数列表不同）

12. 标准的类

一个标准的类通常要拥有以下四个组成部分：

所有的成员变量都要使用private关键字修饰
为每一个成员变量编写一对儿Getter/Setter方法
编写一个无参数的构造方法
编写一个全参数的构造方法

这样标准的类也叫做Java Bean

13. ArrayList

对于ArrayList来说，有一个尖括号< E >代表泛型。
泛型：也就是装在集合中的所有元素，全都是统一的什么类型。
注意：泛型只能是引用类型，不能是基本类型。

14. 字符串

字符串的特点：

字符串的内容用不可变。
正是因为字符串不可改变，所以字符串是可以共享使用的。
字符串效果上相当于chart[]字符数组，底层原理是byte[]字节数组。

字符串常见的3+1中创建方式：
三种构造方法：

public String():创建一个空白字符串，不含有任何内容。
public String(char[] array):根据字符数组的内容，来创建对应的字符串。
public String(byte[] array):根据字节数组的内容，来创建对应的字符串。

一种直接创建：

String str = "Hello"; // 右边直接用双引号

注意：直接写上双引号，就是字符串对象。

字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。new的不在常量池当中。

对于基本类型来说，==是进行数值比较。

对于引用类型来说，==是进行地址值比较。

15. static

一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。
静态变量：类名称.静态变量
静态方法：类名称.静态方法()

注意事项：

静态不能直接访问非静态。
原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容。
“先人不知道后人，但是后人知道先人。”
静态方法当中不能用this。
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

静态static的内存图

根据类名称访问静态成员变量的时候，全程和对象没有关系，只和类有关系。

16. 继承

继承主要解决的问题是：共性抽取

在继承关系中，“子类就是一个父类”。也就是说，子类可以被当作父类看待。
例如父类是员工，子类是讲师，那么"讲师就是一个员工"。关系： is-a

定义父类的格式：（一个普通的类定义）
public class 父类名称 {// ...
}定义子类的格式：
public class 子类名称 extends 父类名称 {// ...
}

在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：

直接通过子类对象访问成员变量：

等号左边是谁，就优先用谁，没有则向上找。

间接通过成员方法访问成员变量：

该方法属于谁，就优先用谁，没有则向上找。

区分子类方法中重名的三种

局部变量：直接写成员变量名
本类的成员变量： this.成员变量名
父类的成员变量： super.成员变量名

在父子类的继承关系当中，创建子类对象，访问成员方法的规则：
创建的对象是谁，就优先用谁，如果没有则向上找。

注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。

重写（Override）
概念：在继承关系当中，方法的名称一样，参数列表也一样。

重写（Override）：方法的名称一样，参数列表【也一样】。覆盖、覆写。
重载（Overload）：方法的名称一样，参数列表【不一样】。

方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。

方法覆盖重写的注意事项：

必须保证父子类之间方法的名称相同，参数列表也相同。
@Override：写在方法前面，用来检测是不是有效的正确覆盖重写。
这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。
子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。
子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示：public > protected > (default) > private
备注：(default)不是关键字default，而是什么都不写，留空。

继承关系中，父子类构造方法的访问特点：

子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造。
子类构造可以通过super关键字来调用父类重载构造。
super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
总结：
子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super调用，super只能有一个，还必须是第一个。

super关键字的用法有三种：

在子类的成员方法中，访问父类的成员变量。
在子类的成员方法中，访问父类的成员方法。
在子类的构造方法中，访问父类的构造方法。
在第三种用法当中也要注意：
A. this(…)调用也必须是构造方法的第一个语句，唯一一个。
B. super 和 this 两种构造调用，不能同时使用

super关键字和this关键字图解

17. 抽象

如果父类当中的方法不确定如何{}方法体实现，那么这就应该是一个抽象方法。

抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。

如何使用抽象类和抽象方法：

不能直接创建new抽象类对象。
必须用一个子类来继承抽象父类。
子类必须覆盖重写抽象父类当中所有的抽象方法。
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。
创建子类对象进行使用。

18. 接口

接口就是一种公共的规范标准。
只要符合规范标准，就可以大家通用。

接口就是多个类的公共规范。
接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。

如何定义一个接口的格式：
public interface 接口名称 {
// 接口内容
}

备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java --> .class。

如果是Java 7，那么接口中可以包含的内容有：

常量
抽象方法

如果是Java 8，还可以额外包含有：

默认方法
静态方法

如果是Java 9，还可以额外包含有：

私有方法

接口的抽象方法定义及使用
① 定义
在任何版本的Java中，接口都能定义抽象方法。
格式：
```
public abstract 返回值类型 方法名称(参数列表);
```
注意事项：
1. 接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
2. 这两个关键字修饰符，可以选择性地省略。（今天刚学，所以不推荐。）
3. 方法的三要素，可以随意定义。
```
package cn.itcast.day10.demo01;public interface MyInterfaceAbstract {// 这是一个抽象方法public abstract void methodAbs1();// 这也是抽象方法abstract void methodAbs2();// 这也是抽象方法public void methodAbs3();// 这也是抽象方法void methodAbs4();}
```
② 使用
接口使用步骤：
1. 接口不能直接使用，必须有一个“实现类”来“实现”该接口。
  格式：
  public class 实现类名称 implements 接口名称 {
  // …
  }
2. 接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。
  实现：去掉abstract关键字，加上方法体大括号。
3. 创建实现类的对象，进行使用。
注意事项：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。
```
package cn.itcast.day10.demo01;public class MyInterfaceAbstractImpl implements MyInterfaceAbstract {@Overridepublic void methodAbs1() {System.out.println("这是第一个方法！");}@Overridepublic void methodAbs2() {System.out.println("这是第二个方法！");}@Overridepublic void methodAbs3() {System.out.println("这是第三个方法！");}@Overridepublic void methodAbs4() {System.out.println("这是第四个方法！");}
}
```
接口的默认方法定义及使用
① 定义
从Java 8开始，接口里允许定义默认方法。
格式：
```
public default 返回值类型 方法名称(参数列表) {方法体
}
```
备注：接口当中的默认方法，可以解决接口升级的问题。
② 使用
默认方法会被接口的实现类自动继承
1. 接口的默认方法，可以通过接口实现类对象，直接调用。
2. 接口的默认方法，也可以被接口实现类进行覆盖重写。
接口的静态方法定义及使用
① 定义
从Java 8开始，接口当中允许定义静态方法。
格式：
```
public static 返回值类型 方法名称(参数列表) {方法体
}
```
提示：就是将abstract或者default换成static即可，带上方法体。
② 使用
注意事项：不能通过接口实现类的对象来调用接口当中的静态方法。
正确用法：通过接口名称，直接调用其中的静态方法。
格式：
接口名称.静态方法名(参数);
接口的私有方法定义及使用
① 定义
问题描述：
我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。
但是这个共有方法不应该让实现类使用，应该是私有化的。
解决方案：
从Java 9开始，接口当中允许定义私有方法。
1. 普通私有方法，解决多个默认方法之间重复代码问题
  格式：
```
private 返回值类型 方法名称(参数列表) {方法体
}
```
2. 静态私有方法，解决多个静态方法之间重复代码问题
  格式：
```
private static 返回值类型 方法名称(参数列表) {方法体
}
```

② 使用
普通私有方法，解决多个默认方法之间重复代码问题
静态私有方法，解决多个静态方法之间重复代码问题

接口常量的定义和使用
① 定义
接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。
从效果上看，这其实就是接口的【常量】。
格式：
```
public static final 数据类型 常量名称 = 数据值;
```
备注：
一旦使用final关键字进行修饰，说明不可改变。
注意事项：
1. 接口当中的常量，可以省略public static final，注意：不写也照样是这样。
2. 接口当中的常量，必须进行赋值；不能不赋值。
3. 接口中常量的名称，使用完全大写的字母，用下划线进行分隔。（推荐命名规则）
② 使用
直接用接口.常量使用

接口总结
在Java 9+版本中，接口的内容可以有：

成员变量其实是常量，格式：
[public] [static] [final] 数据类型常量名称 = 数据值;
注意：
常量必须进行赋值，而且一旦赋值不能改变。
常量名称完全大写，用下划线进行分隔。
接口中最重要的就是抽象方法，格式：
[public] [abstract] 返回值类型方法名称(参数列表);
注意：实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。
从Java 8开始，接口里允许定义默认方法，格式：
[public] default 返回值类型方法名称(参数列表) { 方法体 }
注意：默认方法也可以被覆盖重写
从Java 8开始，接口里允许定义静态方法，格式：
[public] static 返回值类型方法名称(参数列表) { 方法体 }
注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法
从Java 9开始，接口里允许定义私有很乏，格式：
普通私有方法：private 返回值类型方法名称(参数列表) { 方法体 }
静态私有方法：private static 返回值类型方法名称(参数列表) { 方法体 }
注意：private的方法只有接口自己才能调用，不能被实现类或别人使用。

接口注意事项：

接口是没有静态代码块或者构造方法的。

一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
格式：

public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {// 覆盖重写所有抽象方法
}

如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
如果实现类锁实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。

接口与类的关系：

类与类之间是单继承的。直接父类只有一个。
类与接口之间是多实现的。一个类可以实现多个接口。
接口与接口之间是多继承的。
注意事项：
1. 多个父接口当中的抽象方法如果重复，没关系。
2. 多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，【而且带着default关键字】。

19. 多态

面向对象三大特征：封装、继承、多态

extends继承或者implements接口的实现，是多态的前提。

代码当中体现多态性，其实就是一句话：父类引用指向子类对象。

格式：
父类名称对象名 = new 子类名称();
或者：
接口名称对象名 = new 实现类名称();

多态中成员变量的使用规则

直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找。
间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找。

多态中成员方法的使用规则
在多态的代码当中，成员方法的访问规则是：
看new的是谁，就优先用谁，没有则向上找。

口诀：编译看左边，运行看右边。

对比一下：
成员变量：编译看左边，运行还看左边。
成员方法：编译看左边，运行看右边。

多态的好处
多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。

对象的向上转型和向下转型
含义：

右侧创建一个子类对象，把它当作父类来看待使用。
将父类对象，还原为本来的子类对象。

格式：

向上转型：父类名称对象名 = new 子类名称();
向下转型：子类名称对象名 = (子类名称)父类对象;

注意：

向上转型一定是安全的
对象一旦向上转型为父类，就无法调用子类原本特有的内容。解决方案：向下转型

如何才能知道一个父类引用的对象，本来是什么子类？
格式：

对象 instanceof 类名称

这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。

20. final关键字

final关键字代表最终、不可改变的。

常见四种用法：

可以用来修饰一个类
可以用来修饰一个方法
还可以用来修饰一个局部变量
还可以用来修饰一个成员变量

① 修饰类
当final关键字用来修饰一个类的时候，格式：

public final class 类名称 {// ...
}

含义：当前这个类不能有任何的子类。（太监类）
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子。）

② 修饰成员方法
当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
格式：

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

注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

③ 修饰局部变量
一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。“一次赋值，终生不变”
对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。
1. 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
2. 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
3. 必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。

对于基本类型来说，不可变说的是变量当中的数据不可改变
对于引用类型来说，不可变说的是变量当中的地址值不可改变

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

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

21. 四种权限修饰符

	public	protected	default（空的）	private
同一类中	√	√	√	√
同一包中(子类与无关类)	√	√	√
不同包的子类	√	√
不同包中的无关类	√

可见，public具有最大权限。private则是最小权限。
编写代码时，如果没有特殊的考虑，建议这样使用权限：

成员变量使用private ，隐藏细节。
构造方法使用public ，方便创建对象。
成员方法使用public ，方便调用方法。

22. 内部类

如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
例如：身体和心脏的关系。又如：汽车和发动机的关系。

分类：

成员内部类
局部内部类（包含匿名内部类）

成员内部类的定义格式：

修饰符 class 外部类名称 {修饰符 class 内部类名称 {// ...}// ...
}

注意：内用外，随意访问；外用内，需要内部类对象。

如何使用成员内部类？有两种方式：

间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。

直接方式，公式：

类名称 对象名 = new 类名称();
【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】

内部类的同名变量访问
如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名

package cn.itcast.day11.demo03;// 如果出现了重名现象，那么格式是：外部类名称.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); // 外部类的成员变量}}}

23. 局部内部类

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。

定义格式：

修饰符 class 外部类名称 {修饰符 返回值类型 外部类方法名称(参数列表) {class 局部内部类名称 {// ...}}
}

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】。

备注：从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。

原因：

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

举例
Outer.java

package cn.itcast.day11.demo04;class Outer {public void methodOuter() {class Inner { // 局部内部类int num = 10;public void methodInner() {System.out.println(num); // 10}}Inner inner = new Inner();inner.methodInner();}}

DemoMain.java

package cn.itcast.day11.demo04;public class DemoMain {public static void main(String[] args) {Outer obj = new Outer();obj.methodOuter();}
}

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

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

24. 匿名内部类

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

匿名内部类的定义格式：

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

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

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

另外还要注意几点问题：

匿名内部类，在【创建对象】的时候，只能使用唯一一次。
如果希望多次创建对象，而且类的内容一样的话，那么就需要使用单独定义的实现类了。
匿名对象，在【调用方法】的时候，只能调用唯一一次。
如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
强调：匿名内部类和匿名对象不是一回事！！！

举例

package cn.itcast.day11.demo05;public class DemoMain {public static void main(String[] args) {//        MyInterface obj = new MyInterfaceImpl();
//        obj.method();//        MyInterface some = new MyInterface(); // 错误写法！// 使用匿名内部类，但不是匿名对象，对象名称就叫objAMyInterface objA = new MyInterface() {@Overridepublic void method1() {System.out.println("匿名内部类实现了方法！111-A");}@Overridepublic void method2() {System.out.println("匿名内部类实现了方法！222-A");}};objA.method1();objA.method2();System.out.println("=================");// 使用了匿名内部类，而且省略了对象名称，也是匿名对象new MyInterface() {@Overridepublic void method1() {System.out.println("匿名内部类实现了方法！111-B");}@Overridepublic void method2() {System.out.println("匿名内部类实现了方法！222-B");}}.method1();// 因为匿名对象无法调用第二次方法，所以需要再创建一个匿名内部类的匿名对象new MyInterface() {@Overridepublic void method1() {System.out.println("匿名内部类实现了方法！111-B");}@Overridepublic void method2() {System.out.println("匿名内部类实现了方法！222-B");}}.method2();}}

25. StringBuilder

String类和StringBuilder类的区别

26. 可变参数

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格式：

修饰符 返回值类型 方法名(参数类型... 形参名){ }

其实这个书写完全等价与

修饰符 返回值类型 方法名(参数类型[] 形参名){ }

只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。
JDK1.5以后。出现了简化操作。… 用在参数上，称之为可变参数。
同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，自动完成了。
代码演示：

public class ChangeArgs {public static void main(String[] args) {int[] arr = { 1, 4, 62, 431, 2 };int sum = getSum(arr);System.out.println(sum);// 6 7 2 12 2121// 求 这几个元素和 6 7 2 12 2121int sum2 = getSum(6, 7, 2, 12, 2121);System.out.println(sum2);}/** 完成数组 所有元素的求和 原始写法public static int getSum(int[] arr){int sum = 0;for(int a : arr){sum += a;}return sum;}*///可变参数写法public static int getSum(int... arr) {int sum = 0;for (int a : arr) {sum += a;}return sum;}
}

tips: 上述add方法在同一个类中，只能存在一个。因为会发生调用的不确定性
注意：如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末
尾位置。

27. HashTable/ConcurrentHashMap

HashTable/ConcurrentHashMap：底层是一个哈希表，是一个线程安全的集合，单线程集合，速度慢
HashMap：底层是一个哈希表，是一个线程不安全的集合，是多线程的集合，速度快

Java基础：查漏补缺相关推荐

Java基础查漏补缺（2）
Java基础查漏补缺(2) apache和spring都提供了BeanUtils的深度拷贝工具包 +=具有隐形的强制转换 object类的equals()方法容易抛出空指针异常 String a=nu ...
Java基础查漏补缺（个人向）
关键字不熟悉的关键字 instanceof throw(手动的生成一个异常) throws(处理异常的方式) native strictfp transient volatile assert th ...
Java基础查漏补缺：(String篇)一个面试题问倒了我，原来String并不简单
先来一道java面试题: String s = new String("zsx"); 问:创建了几个String Object? 先别往下看,想想答案先上一个图: 如图所示,问题 ...
java怎么快速补缺_Java基础查漏补缺（1）
Java基础查漏补缺 String str2 = "hello"; String str3 = "hello"; System.out.println(str3 ...
C/C++基础查漏补缺（八）----------寒假学习笔记（八）
寒假C语言基础查漏补缺笔记(八) 本系列文章是基于自身的编程基础而编写的,其内容并非适用于所有人,请海涵~ 不过内容应该包括了所有的考点.用法,初学C/C++的大学生或者noip入门级选手可以以此作为 ...
C/C++基础查漏补缺（一）----------寒假学习笔记（一）
寒假C语言基础查漏补缺笔记(一) 本系列文章是基于自身的编程基础而编写的,其内容并非适用于所有人,请海涵~ 不过内容应该包括了所有的考点.用法,初学C/C++的大学生或者noip入门级选手可以以此作为 ...
C语言——基础查漏补缺（三）：谭浩强红书刷题笔记大杂烩
相关文章: C语言--基础查漏补缺(一):超长文帮你理清一些概念 C语言--基础查漏补缺(二):<C程序设计试题汇编>应试概念总结 C语言--基础查漏补缺(四):利用<挑战程序设计竞 ...
Java学习查漏补缺及知识点整理
本文是根据B站up主青空の霞光的JavaSE教程所整理的查漏补缺知识点笔记,有所简陋,希望能帮到大家.有错误希望大家指正.持续更新中- 注意:读此笔记需有一定的Java基础. 文章目录一.断点调试 ...
【Java语法】基础查漏补缺
1.nextLine问题首先需要明确nextLine的作用 :返回的是Enter键之前的所有字符情景一:对于通过空格分隔输入的场景(并列输出) nextLine和nextInt等一起并列使用时,n ...
Java面试查漏补缺
一.基础 1.&和&&的区别. [概述] &&只能用作逻辑与(and)运算符(具有短路功能):但是&可以作为逻辑与运算符(是"无条件与&quo ...

Java基础：查漏补缺