Java基础知识点

Eclipse常用快捷键

alt+?：提示代码
Alt+/：自动补全代码
Ctrl+/：自动注释当前行或者选择多行
main+alt+/：主函数

IDEA常用快捷键

CMD基本语法

命令提示符:（cmd）：
启动：win+R,输入cmd回车
切换盘符: 盘符名称:
进入文件夹: cd文件夹名称
进入多级文件夹: cd 文件夹1\文件夹2\文件夹3
返回上一级： cd ..
直接回根目录：cd \
查看当前内容： dir
清屏： cls
退出： exit

一．定义引用类

（一）定义类
1.成员变量（属性）
2.成员方法（行为）
（二）引用类
3.通常情况，一个类不能直接使用，需要根据类创建一个对象，才能使用
4.导包：也就是指出需要使用的类，在什么位置
5. 对于和当前类属于一个包的情况，可以省略不写。
7. 创建对象格式格式：类名称 对象名 = new 类名称
8.使用，分两种情况：
使用成员变量：对象吗.成员变量名
使用成员方法：对象名.成员方法名（参数）

注意事项：如果成员变量没有进行赋值，那么将有一个默认值，规则和数组一样

二．局部变量与成员变量区别

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

三．封装性

面对对象三大特征：封装、继承、多态
封装就是将一些细节信息隐藏起来，对于外界不可见。
封装性在java当中的体现：
1.方法就是一种封装
2.关键字pricate也是一种封装
（一） Private 关键字
用private关键字将需要保护的成员变量进行修饰。

1.一旦使用private进行修饰，那么本类当中仍然可以随便访问。但是，超出本类围之外就不能直接访问了
2.间接访问成员变量，就是定义一对Getter/Setter方法
3.格式必须以setxxx或者getxxx命名规则
4.对于Getter来说，不能有参数，返回值和成员变量对应。
5.对于Setter来说，不能有返回值，参数类型和成员变量对应
注意：对于基本类型当中的boolean值，Getter方法一定要写成isxxx的形式，而setxxx规则不变
（二）this关键字
当方法的局部变量和类的成员的变量重名的时候，根据“就近原则”，优先使用局部变量
如果需要访问本类当中的成员变量，需要使用格式：this.成员变量名
“通过谁调用的方法，谁就是this。”
（三）构造方法
构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法
格式：

public 类名称（参数类型 参数名称）{
          方法体
}

注意事项：
1.构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
2.构造方法不要写返回值类型，连void都不写
3.构造方法不能return一个具体的返回值
4.如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数，方法 体什么事情都不做
5.一旦编写了至少一个编译方法，那么编译器将不再赠送
6.构造方法也是可以重载的，重载：方法名称相同，参数列表不同
（四）标准的类
1.所有的成员变量通常都要使用private关键字修饰
2.为每一个成员变量编写一对Getter/Setter方法
3.编写一个无参的构造方法
4.编写一个全参的构造方法

这样的类也叫做Java bean

针对Eclipse
自动生成标准类getter/setter：右键→Source→Generate Getters and
Setters自动生成标准类构造函数：右键→Source→Generate Constructor using Fields`
输出函数快速生成：syso+’/’;

四．API

（一）Scanner类

Scanner类的功能：可以实现键盘输入数据，到程序当中。
引用类型的一般使用步骤：
1.导包

  import 包路径.类名称;

如果需要使用的目标类，和当前类位于同一路径下，则可省略导包语句不写。
只有java.lang包下的内容不需要导包，其他的包都需要import语句。
在这里是 import java.util.Scanner;

2.创建

类名称 对象名 = new 类名称（）；
在这里是 Scanner 对象名= new Scanner（System.in）;
//System.in代表从键盘进行输入，不管怎么样键盘读入的都是字符串，只是对应方法进行转化了而已

3.使用

 对象名.成员方法名（）；

获取键盘输入的一个int数字：int num = 对象名.nextInt（）；
获取键盘输入的一个字符串： String str = 对象名.next（）；

（二）匿名对象

创建对象的标准格式：

类名称 对象名 =  new 类名称（）；

匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。
创建：Nwe 类名称（）;
使用：new 类名称.成员变量/成员方法
注意事项：匿名对象只能使用唯一的一次，下次再用不得不创建一个新对象
使用建议：如果确定有一个对象只需要使用唯一一次，就可以用匿名对象

（三）Random类

作用：用来生成随机数字，使用起来三个步骤
1.导包

  import.java.util.Random;

2.创建

Randow r=new Random();//小括号留空

4.使用
获取一个随机数字（范围是int所有范围：有正负两种）：

int num=r.nextInt();

获取一个随机的int数字（参数代表范围，左闭右开区间）：

int num=r.nextInt(3);
//实际上代表的含义是[0,3);

（四）ArrayList（类）

与数组的区别：长度可以随意变化

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

注意事项：对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。
如果内容是空，得到的是空的中括号：[]

（1）常用方法：
Public boolean add（E e）:向集合里面添加元素，参数类型和泛型一致。返回值代表添加是否成功
备注：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。但对于其他集合来说，add添加动作不一定成功。

Public E get(int index):从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素

Public E remove(int index) :从集合当中删除元素：参数是索引编号，返回值是被删除掉的元素

Public int size():获取集合的尺寸长度，返回值是集合中包含的元素个数

遍历集合：

for(int i=0;i<list.size();i++) {
		   System.out.println(list.get(i));
	   }

（2）存放基本类型
使用“包装类”
基本类型 包装类（引用类型，包装都位于java.long包下）

byte(Byte)     short(Short)     int(Integer)         long(Long)  
float(Float)   double(Double)   char(Character)      boolean (Boolean)

从JDK 1.5+开始，支持自动装箱、自动拆箱
自动装箱：基本类型–>包装类型
自动拆箱：包装类型–>基本类型

五．字符串（待补）

六．继承

（一）中国大学mooc笔记
继承主要解决问题：共性抽取
从多个类别（对象）中提取共性，形成父类。其他类继承父类，成为子类，也拥有这些共性
定义子类：class 子类名 extends 父类名{}
注意：不能访问private成员
1.子类会继承父类的父类的所有属性和方法
2.在同样方法名和参数情况下，本类的方法会比父类的方法优先级高
直接通过子类访问成员变量：
等号左边是谁，就优先用谁，没有则向上找
间接通过成员方法访问成员变量：
该方法属于谁就优先用谁，没有就向上找
3.单根继承原则：每个类只能继承一个类
4.如果不写ectends,Java类都默认继承java.lang.Object类
5.Object类里面默认就有clone,equals,finalize,getClass,hashCode,toString等方法

父类：Parent class
基类：Base class
超类：Super class
子类：Child class
派生类:Derived class

（二）子类方法中三种重名变量访问

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

（三）继承中成员方法访问特点
在子类的继承关系中，创建子类对象，访问成员方法的规则:创建对象时谁，就优先用谁，如果没有就向上找
注意事项：无论是成员变量还是成员方法，如果没有都是向上找父类，绝对不会向下找子类的
（四）方法的重写与重载
重写：方法的名称一样，参数列表【也一样】。覆盖，覆写
重载：方法的名称一样，参数列表【不一样】

方法的覆盖重写特点：创建的是子类对象，则优先用子类方法
注意事项：
1.必须保证父子类之间方法名称相同，参数列表也相同
@override:写在方法前面，用来检测是不是有效的正确覆盖重写。（可选）
2.子类方法的放回值必须小于父类的返回返回范围
小扩展提示：java.lang.object类是所有类的公共最高类（祖宗类），java.lang.String就是object的子类
3.子类方法的权限必须【大于等于】父类方法的权限修饰符
小扩展提示：public > pratected > (defuult) > private

备注：(default)不是关键字default,而是什么都不写，留空

（五）继承中构造方法访问特点
1.子类构造方法中有一个默认“super()”调用，所以一定先调用的父类构造，后执行的子类构造
2.可以通过super关键字来子类构造调用父类重载构造
3.super的父类构造调用，必须是子类构造方法的第一个语句，不能一个子类构造调 用多次super构造
总结：子类必须调用父类构造方法，不写则赠送super();写了则用写的指定的super调用
（六）java继承的三个特点
1.java语言是单继承的：一个类的直接父类只能有一个
2.Java语言可以多级继承
3.Java语言父类可以有多个子类

七．super关键字的三种用法

1.在子类的成员方法中访问父类的成员变量: super.父类成员变量
2.在子类的成员方法中访问父类的成员方法 : super.父类成员方法
3.在子类的构造方法中访问父类的构造方法: super();

八．this关键字三种用法

1.在本类成员中，访问本类的成员变量:this.成员变量
2.在本类的成员方法中，访问本类的另一个成员方法: this.成员方法名
3.在本类的构造方法中访问另一个构造方法 :this(num) 调用本类的有参构造方法
在第三种用法中要注意：
A.this(…)调用也必须是构造方法的第一个语句，唯一一个
B.Super和this两种构造调用，不能同时使用

七.static、final

（一）Static

1.用于修饰成员变量
（1）一旦用了static关键字，那么这样的内容不再属于自己，而是属于类的，所以凡是本类的对象，都共享同一份数据
（2）和C的静态变量类似，可以用来计数，值会保留到写一个对象
2.用于静态方法
（1）一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类
（2）如果没有static关键字，那么必须创建对象，然后通过对象才能使用它
（3）如果有static关键字，那么不需要创建对象，直接用类名称来使用它
（4）对于静态方法来说，可以通过对象名进行调用（编译之后会被翻译成 “类名称.方法名”），也可以通过类名称来调用，推荐使用类名称调用
（5）无论是成员变量还是成员方法，如果有static，都推荐使用类名称进行调用。

对于本类当中的静态方法，可以省略类名称
注意事项：
1.静态不能直接访问非静态(原因：内存当中先有静态，后有非静态)
2.静态方法中不能使用this关键字
3.静态代码块
静态代码块的格式是：

public class 类名称{
       static{
             静态代码块的内容
            }
}

特点：当第一次用到本类时，静态代码块执行唯一一次
优先级：static块 > 匿名块 > 构造函数
典型用途：用来一次性对静态成员变量赋值

（二）单例模式（待补）

（三）Final

四种用法：
1.修饰一个类
2.修饰一个方法
3.修饰一个局部变量
4.修饰一个成员变量

1.用来修饰一个类
格式:public final class 类名称{}
含义：当前这个类不能有任何子类。（太监类）
注意：一个类如果是final的，那么所有的成员方法都无法进行覆盖重写（因为没儿子）

2.用来修饰一个方法
格式：修饰符 final 返回值类型 方法名称{}
含义：此方法就是最终方法，不能被覆盖重写
注意：对于类，方法来说，obstract关键字和final关键字不能同时使用，因为矛盾

3.用来修饰局部变量
格式：final 局部变量名
含义：这个变量不能被修改，但是可以赋值（只要保证是唯一的一次赋值）
对于基本类型来说，不可变说的是变量当中的数据不可变
对于引用类型来说，不可变说的是变量当中的地址值不可变，可以改变变量的值

4.用来修饰成员变量
格式：final 成员变量名
对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变的
（1）由于成员变量有默认值，所以用了final之后必须手动赋值，不会再给默认值了
（2）对于final的成员变量要么使用直接赋值，要么通过构造方法赋值
（3）必须保证所有的重载方法都最终会对final的成员变量进行赋值

（四）常量设计方法（待补）

八．四种权限修饰符

java中有四种权限修饰符：

                      Public  >  pratected  >  (default)（表示不写）  >  private
同一个类（我自己）      YES          YES                YES                 YES
同一个包（我邻居）      YES          YES                YES                 YES
不同包子类（我儿子）    YES          YES                 NO                 NO
不同包非子类（陌生人）  YES           NO                 NO                 NO

九．抽象类与抽象方法

（1）抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束
格式：public abstract 返回值类型 方法名称（参数列表）；

（2）抽象类：抽象方法所在类，必须是抽象类才行。在class之前写上abstract即可
格式：Public abstract class 类名称{}

（3）如何使用抽象类和抽象方法：
1.不能直接创建抽象类对象
2.必须用一个子类来继承父类
3.子类必须要覆盖重写抽象父类当中的所有抽象方法
覆盖重写（事项）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号
4.创建子类对象进行使用.

十．接口

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

Public interface 接口名称{
    接口内容
}

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

如果是java 7 那么接口中可以包含的内容有：1.常量 2.抽象方法
如果是java 8 还可以额外包含有： 3.默认方法 4.静态方法
如果是java 9 还可以额外包含有： 5.私有方法

（二）接口抽象方法定义
格式：

public abstract 返回值类型 方法名称（参数列表）；

注意事项：
1.接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
2.这两个关键字修饰符，可以选择性地省略
3.方法三要素可以随意定义

（三）接口抽象方法的使用步骤
1.接口不能直接使用，必须有一个实现类来实现该接口
格式：

Public class 实现类名称 implements 接口名称{
}

2.接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。
实现：去掉abstract关键字，加上方法体大括号

3.创建实现类的对象，进行使用。
注意事项：如果类并没有覆盖重写接口中的所有抽象方法，那么这个实现类自己就必须是抽象类。

（四）接口默认方法的定义使用
默认方法会被实现类继承下去
格式：

public default 返回值类型 方法体名称（参数列表）{
      方法体
}

备注：接口中的默认方法可以解决接口升级的问题
1.接口的默认方法，可以通过接口实现类对象，直接调用
2.接口的默认方法，也可以被接口实现类进行覆盖重写

（五）接口静态方法定义使用
只跟接口有关，与实现类和实现类对象均无关

格式：
Public static 返回值类型 方法名称（参数列表）{
方法体
}

注意：不能通过接口实现类的对象来调用接口当中的静态方法
正确用法：通过接口名称，直接调用其中的静态方法
格式：
接口名称.静态方法（参数）；

（六）接口私有方法定义使用
(1)普通私有方法，解决多个默认方法之间重复代码问题
我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题，但是这个共有方法不应该让实现类使用，应该是私有化的
格式：

private 返回值类型 方法名称（参数列表）{
    方法体
}

(2)静态私有方法，解决多个静态方法之间重复代码问题
格式：

Private static 返回值类型 方法名称（参数列表）{
   方法体
}

（七）接口变量定义与使用
接口中也可以定义“成员变量”，但是必须使用public static final 三个关键字进行修饰
从效果上看：这其实即使接口的【常量】
定义格式：

public static final 数据类型 常量名称 = 数据值；

注意：
1.一旦使用final关键字进行修饰，说明不可改变。
2.接口当中的常量，可以省略public static final,注意：不不写也照样是这样
3.接口当中的常量，必须进行赋值，不能不赋值
4.接口中常量名称，使用完全大写的字母，用下划线进行分隔。

使用格式：

接口名.常量名

（七）接口总结（java 9）

使用注意事项：
1.接口是没有静态代码块或者构造方法的。
2.一个类的直接父类是唯一的，但是一个类可以实现多个接口
格式：

Public class 类名 implements 接口名1，接口名2{
//覆盖重写所有抽象方法
}

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

public class 类名 extends 父类名 implements 接口名

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

十一．多态性

（一）多态性规则

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

父类名称 对象名 = new 子类名称（）；

或者：

接口名称 对象名 = new 实现类名称（）；

访问成员变量的两种方式：
1.直接通过对象名称访问成员变量：看等号左边是谁优先用谁，没有则往上找
2.间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则往上找

访问成员方法的规则：
看new的是谁就优先用谁，没有就向上找

访问成员方法规则口诀：编译看左边，运行看右边
访问成员变量规则口诀：编译看左边，运行看左边
访问成员变量：等号左边是谁优先用谁
访问成员方法：等号右边是谁优先用谁

好处：无论右边new的时候换成哪个子类对象，等号左边调用的方法都不会变化

（二）向上转型

对象向上转型就是多态写法：

父类名称 对象名 = new 子类名称();

含义：右边创建一个子类对象，把他当作父类来看待使用。
例如：Animal animal = new cat();
注意事项：向上转型一定是安全的。从小范围转向了大范围

类似于:
double num=100;//正确 int-->double,自动类型转换

对象一旦向上转型为父类，那么就无法调用子类原本特有的内容
解决方案：用对象的向下转型【还原】

（三）向下转型

对象的向下转型：其实就是一个【还原】的动作
格式：

子类名称 对象名 = （子类名称）父类对象；

含义：将父类对象，还原成为本来的子类对象

Animal animal = new Cat();//本来是猫，向上转型成为动物
Cat cat = (Cat) animal;//本来是猫，已经被当作动物了，还原回来成为本来的猫

注意事项：
A.必须保证对象本来创建的时候就是猫，才能向下转型成为猫
B.对象如果原本不是猫，现在非要向下转型成为猫，就会报错

如何才能知道一个父类引用的对象，本来是什么子类？
格式： 对象 instanceof 类名称
会得到一个boolean值结果，也就是判断前面的对象能不能当作后面类型的

十二．常用类

（一）Object类

概述：
类层次结构最顶级的基类，所有类都直接或间接的继承object类
构造方法：

Public  Object()

成员方法：
Int hashCode: 返回对象的哈希码值，不同对象的哈希码值一般不同
Class<?> getClass: 返回该调用者的字节码文件对象，一个类只有一个文件字节码对象
String toString(): 返回该对象的字符串表示形式，打印的是地址值，但不同对象打印的地址值肯定不同
地址值的组成：全类名+@+该对象的哈希码的无符号十六进制形式
Boolean equals(): 比较两个对象是否相等，默认的是地址值无意义，子类一般会重写这个方法
注意：java.lang包下的类可以直接使用，不需要导包

输出语句直接打印对象默认调用了该对象的toString()方法

toString（）重写：右键→source→Generate toString() //返回对象的基本信息
equeals（）重新：右键→source→Generate hashCode() and equals() //比较两个对象是否相等 (使用：a对象.equeals（b对象） 相等返回true不相等返回false;)

比较两个对象时，会先比较他他们的hashCode,如果相同才会调用equals

（二）String类

构造方法：
String（byte[]）:构造一个String对象，将指定字节数组中的数据转化为字符串
String（char []）:构造一个String对象，将指定字符数组中的数据转化成字符串

成员方法：
boolean equals（String）:
判断当前字符串与给定字符串是否相同，区分大小写
boolean equalsIgnore（String）:
判断当前字符串与给定字符串是否相同，不区分大小写
boolean startsWith(String)：
判断是否以给定字符串开头
boolean isEmpty（）:
判断字符串是否为空
Int length()：
返回当前字符串的长度
Char charAt(int index):
获取指定字符（串）第一次出现的索引
Int lastIndex(String):
获取指定字符串最后一次出现的索引
String substring(int ):
获取指定索引位置（含）之后的字符串
String substring(int ,int):
获取从索引start位置（含）起至索引lend位置（不含）的字符串
byte[] getBytes():
将字符串转换成字节数组
char[] tocharArray():
将字符串转化成字符数粗
Static String valueOf(..):
将指定类型数据转换成字符串
String replase(old,new):
将指定字符（串）替换成新的字符（串）
String[] split(String):
切割字符串，返回切割后的字符串数据，原字符串不变
String trim():
去掉字符串两端的空白字符

（三）StringBuilder和StringBuffer类

简介：
可变字符序列，用于构造字符串对象。内部使用自动扩容的数组操作字符串数据。StringBuilder和StringBuffer使用相同的API.

构造方法：
StringBulider():构造一个空的StringBuder容器
StringBulider(String):构造一个StringBuilder容器，并添加指定字符串

成员方法：
StringBuilder append(...):
将任意数据添加到StringBuilder容器中
String toString():
将当前StringBuilder容器转化成字符串

（四）Date和Calender类

**简介：**日期类和日历类，用于操作日期相关信息。

(1)Date类：
构造方法：
Date():构造一个日期对象，当前系统时间，精确到毫秒
Date(long):构造一个日期对象，时间为自“1970年1月1日 00:00:00 GMT”起，至指定参数的毫秒数

成员方法：
long getTime():
将日期对象转化为对应时间的毫秒值

（2）Calendar类（静态类）：
static Calendar getInstance():
根据当前系统时区和语 言环境获取日历对象
int get(int field):
返回给定日历字段的值
void set(int field,int value):
将给定的日历字段设置为指定的值

十三．Java数据结构

（一）数组

定义格式：
格式一：数据类型[] 数组名 = new 数据类型[长度]
格式二：数据类型[] 数组名 = new 数据类型[]{值1，值2，值3...}
格式三：数据类型[] 数组名 = {值1，值2，值3...}

初始化：
动态初始化：只指定长度，由系统给出默认值

 int[] arr= new int[5];

静态初始化：给出初始化值，由系统决定数组的长度

int[] arr = new int[]{1,2,3,4};
int[] arr ={1,2,3,4};

错误提示： 数组索引越界异常：ArrayIndexOutOfBoundsException
空指针异常：NullPointerException

（二）JAVA程序内存分配

方法区：存储可运行的class文件，包含方法，静态成员，常量等
栈：方法运行时使用的内存，特点是后进先出
堆：储存new出来的数组或对象

（三）集合

单列集合（collection）

 List：
       ArrayList
  Set：
       HashSet

双列集合（Map：key ,value）

 Map：
       HashMap

（1）list集合
特点：可重复、有序（存取顺序相同）
创建：List list = new ArrayList();
添加元素：add();
获取大小：size();
（2）Set集合
特点：不可重复、无序
去重依赖equals()和hashCode()两个方法，需要重写

（四）增强for循环和迭代器

格式：

for(数据类型 变量名 : 数组或者集合对象){ 
           //循环体，变量即元素
} 

对过程的重复，称为迭代。
迭代器是遍历Collection集合的通用方式，可以在对集合遍历的同时进行添加、删除操作

迭代器的常用方法：
Iterator it = 对象.itrerator()：首先要创建迭代器对象
Next()：返回迭代器的下一个元素
hasNext()：如果仍有元素可以迭代，则返回true

（五）Collections工具类

使用格式：

Collections.方法名(对象);    

方法：
sort(List<T>):
根据元素的自然顺序，将指定列表按升序排列
max(collection<T>):
返回集合的最大元素
reverse(List<T>):
反转List集合元素
shuffle(List<T>):
使用默认的随机源随机置换指定的列表

十四．内部类

内部类的概念与分类
1.成员内部类
2.局部内部类（内含匿名内部类）

（一）成员内部类

定义格式：

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

注意：内用外随意访问；外用内，需要内部类对象
使用：
1.间接方式：在外部类的方法当中，使用内部类，然后main只是调用外部类的方法
2.直接方式,公式：外部名称.内部名称 对象名 = new 外部名称（）.new 内部名称（）;

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

（二）局部内部类

定义：
如果一个类是定义在方法内部的，那么这就是局部内部类
格式：

修饰符 class 外部类名{
        修饰符 返回值类型 外部类方法名称（参数列表）{
                Class 局部类名称{
                    .........
                }
        }
}

小结一下类的修饰符：

Public > protected > (default) > private
定义一个类的时候，权限修饰规则：
1.外部类：public / (default) 
2.成员内部类：public / protected / (default) /private
3.局部内部类：什么都不写

注意：局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】（从java +8开始，只要局部变量事实不变，那么final关键字可以省略）

（三）匿名内部类

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

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

注意事项：
对格式”new 接口名称（）{…}进行解析”
1.new代表创建对象的动作
2.接口名称就是匿名内部类需要实现哪个接口
3.{…}这才是匿名内部类的内容
另外还要注意问题：
1.匿名内部类，在【创建对象的时候】，只能使用唯一一次。
2.匿名对象在【调用方法】的时候只能调用唯一一次
3.匿名内部类省略了【实现类/子类名称】，但是匿名对象省略了【对象名称】
强调：匿名内部类和匿名对象不是一回事！！！

十五．类与接口作为成员变量类型

持续更新！！！！