将自己学习的Java基础整理出来，方便复习和记忆~~

一、Java的历史

1、Java开发分成了3个方向

Java SE：主要用于桌面程序的开发，学习Java EE和Java ME的基础

Java EE：主要用于网页程序的开发

Java ME：主要用于嵌入式系统程序的开发

2、Java SE平台中的lib软件包

Java.lang 包——语言核心包

java.util 包——Java语言工具包

java.text 包——格式化

java.sql 包——JDBC

java.io 包——做输入输出的

java.net 包——做网络

第二章、Java语言基础

1、标识符和关键字

1.标识符是一个名字，用来标识类名、变量名、方法名、数组名和文件名的有效字符序列。

2.命名规则：

(a)由字母、数字、下划线和美元符号组成，第一个字符不能为数字。非法的标识符：7word/5fox

(b)区分大小写

3 数据类型

基本数据类型有8种，6种是数值型、另外2种是字符型和布尔型

（1）整数类型

注：使用byte关键字来定义byte型变量，需要注意以免数据溢出产生错误。

（2）浮点型

float型即单精度浮点型，使用float关键字来定义float型变量，赋值时在结尾处必须添加F或者f，如果不加，系统自动将其定位为double型变量。

double型即双精度浮点型，使用double关键字来定义double型变量。

（3）字符类型

char 型即字符类型，使用char关键字进行声明，用于存储单个字符，定义字符型变量时，要用单引号括起来。字符串类型，需要用双引号进行声明。

char 'a'; //定义一个字符

char "abcd"; //定义一个字符串

（4）数据类型在内存中的存储

a.基本数据类型：不存在“引用”的概念，直接存储在内存中的内存栈中；

b.引用数据类型：引用类型继承于Object类，使用Java内存堆和内存栈来存储，“引用“存储在内存栈中，对象本身的值存储在内存堆上的。

4 变量和常量

（1）变量有效范围

a.成员变量

在类体中定义的变量被称为成员变量，成员变量在整个类中都有效，类的成员变量又可以分为静态变量和实例变量两种。静态变量可以跨类。直接以“类名.静态变量”的方式在其他类内使用。

int x=1; //定义实例变量

static int y=100; //定义静态变量

b.局部变量

在类的方法体中定义的变量。局部变量的生命周期取决于方法，当方法被调用时，Java虚拟机为方法中的局部变量分配内存空间，当该方法调用结束后，则会释放方法中的局部变量所占用的空间。

注：局部变量可以和成员变量名称相同，局部变量的优先级较高。

5 运算符

 

第三章、数组

数组是最为常见的一种数据结构，是相同类型的，用一个标识符封装到一起的基本类型数据序列或对象序列。可以用一个统一的数组名和下标来唯一确定数组中的元素。实质上数组是一个简单的线性序列，因此数组访问起来很快。

1、概述

数组是具有相同类型的一组数据的集合。

数组可以分为一维数组、二维数组、多维数组。

数组在Java中是一个对象，数组实例使用new操作符创建。

特点：

（1）数组索引的起始位0，负数索引在数组中是无效的，会抛出ArrayIndexOutOfBoundException异常。

（2）数组存储在Java堆的连续内存空间。

（3）数组是一个固定长度的数据结构，一旦声明，不能改变数组的长度。

（4）如果没有明确的初始化元素，那么数组就会用默认的类型值初始化。整形数组的初始化为0，boolean类型的值是false，对象数组是null.

2、一维数组及多维数组

2.1 创建一维数组

（1）声明数组，必须首先定义数组变量所属的类型，即声明数组。

数组元素类型 数组名称[]; // int arr[];

数组元素类型[] 数组名字; //String []str;

//单个[]表示是一维数组;

（2）分配内存。要想真正的使用数组还要为其分配内存空间，且分配的内存空间时必须要指明数组的长度。数组作为对象允许使用new关键字进行内存分配。

语法：

数组名 = new 数组元素类型[元素个数]; //arr = new int[10]; 数组中各个元素都为0；

//表示为已经创建好的数组arr的分配长度为10的内存空间。

（3）声明和分配空间同时进行

数组元素类型[] 数组名= new 数组元素类型[元素个数]; //int[] month = new int[12];

2.2 初始化一维数组

int[] arr=new int[]{1,2,3,4,5} //第一种

char arr2[]={a,b,c,d} //第二种

2.3 二维数组

（1）创建

数组元素类型 数组名称[][]; //int arr[][];

数组元素类型[][] 数组名称; //int[][] arr;

二维数组在声明时没有分配内存空间，同样要使用关键字new来分配内存，然后才可以访问每个元素。

a=new int[2][4]; //创建2行4列的数组

3、数组的基本操作

（1） 遍历数组

遍历数组就是获取数组中的每个元素，通常遍历数组都是使用for循环来是实现的。

（2）对数组进行排序

通过Arrays类的静态sort()方法可实现对数组排序。

注：具体数组的操作，可以查看【笔记5-数组操作】

 

第四章 类和对象

1 面向对象的概述

面向对象（Object Oriented）是一种程序设计规范，其基本思想是使用对象、类、继承、封装、多态等基本概念来进行程序设计。从现实世界中客观事物（即对象）出发来构造软件系统，并且在系统构造中尽可能运用人类的自然思维方式。

类实际上就是封装对象和属性的载体，而对象是类抽象出来的一个实例。通过实体对象来解决一些实际问题。在Java语言中，类中对象的行为是以方法的形式定义的，对象的属性是以成员变量的形式定义的，而类包括对象的成员变量和方法。

面向对象的特点：

（1）封装：

定义：封装是面向对象的核心思想，将对象的属性和行为封装起来，而将对象的属性和行为封装起来的载体就是类，类通常对客户隐藏其实现细节，只保留有限的接口和方法与外界进行交互，这就是封装的思想。

优点：采用封装的思想保证了类内部数据结构的完整，应用该类的用户不能轻易直接操纵此数据结构，避免外界对对象内部属性的破坏。

实现：通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。

（2）继承：

定义：继承思想可以缩短软件开发的时间，复用那些已经定义好的类可以提高系统性能，减少系统在使用过程中出现错误的几率。

优点：继承性主要利用特定对象之间的共有属性。

实现：通过super来实现对父类成员的访问。

（3）多态：

指相同的消息使得不同的类做出不同的响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）

具体的实现：子类child 继承父类 Father，可以便携与一个指向子类的父类类型引用，该引用既可以处理父类father 对象，也可以处理子类 Child 对象，当相同的消息发送给子类或者父类对象时，该对象就会根据自己所属的引用而执行不同的行为，这就是多态。

多态分为编译时多态和运行时多态。编译时多态 主要是指方法的重写，根据参数列表的不同来区分不同的函数，通过编辑之后会变成两个不同的函数。运行时多态是动态的，通过动态绑定来实现的的。

实现多态的技术：动态绑定，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

必要条件：

a.要有继承；b.要有重写；c.向上转型，父类引用指向子类对象（这样才能调用调用父类的方法和子类的方法）。

多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载。

2、类

定义：类是具有相同属性和方法的一组对象的集合。其内部包括属性和方法两个主要部分。

（1）类的构造方法

构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的，每当类实例化一个对象时，类都会自动调用构造方法。

构造方法的特点：

a.构造方法没有返回值，连void也没有

b.构造方法的名称要与本类的名称相同。

c.构造方法的调用是在创建一个对象时使用new 操作符进行的，构造方法的作用是初始化对象（执行哪些方法，初始化哪些属性）。

d.不能被static、final、abstract和synchronized修饰，不能被子类继承。可以通过重载构造方法来表达对象的初始化行为。

e.子类可以通过super语句调用父类的构造方法。

注：如果在类中定义的构造方法都不是无参的构造方法，则编译器不会为类设置一个默认的无参构造方法。

语法：

（2）类的主方法

主方法是类的入口点，定义了程序从何处开始，主方法提供对程序流向的控制，

语法格式：

public static void main(String[] args){

//主方法体;

}

特性：

a.主方法是静态的，要直接在主方法中调用其他方法，则该方法必须也是静态的。

b.主方法没有返回值

c.由JVM调用主方法，我们负责启动JVM

（3）成员方法

使用成员方法对应于类对象的行为。

【语法格式】：

权限修饰符 返回值类型 方法体(参数类型 参数名){

//方法体

return 返回值；

}

注：

成员方法的参数：（1）有参数，参数可以是对象也可以是基本数据类型的变量，（2）无参数

成员方法的返回值：同时成员方法有返回值和不返回值的选择。（1）有返回值需要使用return关键字，使用这个关键字后，方法的执行将被终止。（2）无返回值可以使用void关键字表示。（3）返回值可以是计算结果，也可以是其他想要的数值、对象，返回值类型要与方法返回的值类型一致。

注：如果一个方法中含有与成员变量相同的名称的局部变量，则对这个变量的访问以局部变量进行访问。

（4）局部变量

在成员方法中定义的一个变量，那么这个变量被称为局部变量。

作用范围：有效范围从该变量的声明开始到该变量的结束为止。

（5）权限修饰符

权限修饰符主要包括private、public和protected，修饰符控制着对类和类的成员变量以及成员方法的访问。

当类声明时不使用public、private、protected修饰符设置类的权限，则这个类预设为包存取范围，即只有一个包中的类可以调用这个类的成员变量或成员方法。

（6）this 关键字

this引用就是对一个对象的引用，使用this关键字隐式地用于引用对象的成员变量和方法。

this除了可以调用成员变量或成员方法之外，还可以作为方法的返回值。

在这个方法中，方法的返回值为Book类，所以方法中使用return this这种形式将Book类的对象进行返回。

一个类中定义两个构造函数，在一个构造函数中通过 this 这个引用来调用另一个构造函数，这样应该可以实现。

总结

1） this 关键字是类内部当中对自己的一个引用，可以方便类中方法访问自己的属性；

 2）可以返回对象的自己这个类的引用，同时还可以在一个构造函数当中调用另一个构造函数。

（7）方法的重载

方法重载是让类以统一的方式处理不同数据类型的手段。

一个类中可以创建多个方法，具有相同的名字，但具有不同的参数和不同的定义。

（8）方法的重写

子类对父类的方法进行重新编写，如果在子类中的方法与其父类有相同的方法名、返回类型和参数表，就被称为方法的重写。

3 对象

对象是由类抽象出来的，对象可以操作类的属性和方法解决相应的问题。

（1）对象的创建——使用new操作符调用构造方法创建对象。

Test test = new Test();

Test test = new Test("a");

每个对象都是相互独立的，在内存中占据独立的内存地址，并且每个对象都具有自己的声明周期，当一个对象的声明周期结束时，对象变成了垃圾，由Java虚拟机自带的垃圾回收机制处理，不能再被使用。

如果希望成员变量不被其中任何一个对象改变，可以使用static关键字（一个被声明为static的成员变量的值可以被本类或其他类的对象共享）

（2）匿名对象

没有被其他对象所引用，使用一次就变成了垃圾

（3）对象的销毁

每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址将会被回收，Java语言拥有一套完整的垃圾回收机制，垃圾回收器将回收无用的占用内存的资源。

以下两种情况会被Java虚拟机视为垃圾：

a:对象的引用超过其作用范围，则这个对象将被视为垃圾；

b:将对象赋值为null

垃圾回收机制只能回收那些由new 操作符创建的对象，如果某些对象不是通过new操作符在内存中获取一块内存区域，这种对象可能不被垃圾回收机制所识别，所以Java语言中提供了一个finalize()方法，这个方法是Object类的方法。如果在类中定义了finalize()方法，在垃圾回收时首先调用该方法，并且在下一次垃圾回收动作发生时，才能真正回收对象占用的内存。

Java提供了System.gc()方法强制启动垃圾回收器，告知垃圾回收器来清理。

4、static修饰符的特点

（1）修饰方法

无需本类的对象即可调用此方法。调用一个静态方法就是“类名.方法名”。一般来说，静态方法常常为应用程序中的其他类提供一些实用工具。

静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。如：  如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。如：  2、 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量，3、 静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。4、在静态方法中不能使用this关键字

（2）静态变量

声明为static的变量实质上就是全局变量。声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。所有此类实例共享此静态变量，也就是在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间。

（3）静态类

通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。

 

（4）静态代码块

Java 中的 static 使用之静态初始化块 Java 中可以通过初始化块进行数据赋值。如：  在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。如果使用 static 修饰初始化块，就称为静态初始化块。 需要特别注意：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。

（5）static 和final 一块用表示什么？

static final 用来修饰成员变量和成员方法。可以理解为“全局常量”。

对于变量，表示一旦给值就不可修改，并且通过类名可以访问；

对于方法，表示不可覆盖，并且可以通过类名直接访问。

5、package 关键字

Java的包机制，提供了类的多层命名空间，用于解决类的命名冲突、类文件管理等问题。Java允许将一组功能相关的类放在同一个package下，从而组成逻辑上的类库单元。如果希望把一个类放在指定的包结构下，放置如下格式的代码： package packagename;

一旦在Java源文件中使用了这个语句，就意味着该源文件里定义的所有类都属于这个包。位于包中的每个类的完整类名都应该是包名和类名的组合。

（1）包名

域名.项目名.模块名.组件名

（2）如何访问

（3）import 关键字

向某个Java文件导入指定包层次下的某个类或全部类

（4）常用包

java.lang:包含了Java语言的核心类，如String、System和Tread类等；

java.util:包含了Java的大量工具类/接口和集合框架类/接口，例如Array和List、Set等

java.net:Java网络编程相关的类/接口。

java.io:包含Java输入、输出相关的类、接口；

java.text:包含Java格式化相关的类；

java.sql:包含一些Java进行JDBC数据库编程相关的类、接口；

java.awt:包含了抽象窗口工具集的相关类、接口，主要用于构建图形用户界面（GUI）程序；

java.swing:包含了Swing图形用户界面编程的相关类、接口，可用于构建平台无关的CUI程序。

 

第五章 接口、继承和多态

1 接口的使用

Java语言只支持单重继承，不支持多继承，即一个类只能有一个父类，Java语言提供了接口来实现类的多重继承功能。

1.1 、接口的定义

（1）定义：接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因为这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为或功能。

（2）语法格式：

[修饰符] interface 接口名 [extends 父接口名列表]{

[public][static][final] 变量;

[public][abstract] 方法;

}

（3）特点

a.接口中的成员变量默认是public static final类型的，必须被显示初始化，即接口中的成员变量为常量。

b.方法默认是public、static、final类型的，没有方法体，不能被实例化。

c.接口中没有构造方法，不能被实例化；

d.一个接口不能实现（implements）另一个接口，但它可以继承多个其他的接口。

e.接口必须通过类来实现它的抽象方法。

f.当类实现了某个Java接口时，它必须实现接口中的所有抽象方法，否则这个类必须声明为抽象类。

g.一个类只能继承一个直接的父类，但可以实现多个接口，间接的实现了多继承。

h.接口中的每一个方法也是隐式抽象的，声明时同样不需要 abstract 关键字；

（4）extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承，JAVA中不支持多重继承，但是可以用接口来实现，这样就要用到implements，继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了。

1.2 接口与类的相似点

（1）一个接口可以有几个方法；

（2）接口文件保存在.java文件中，文件名使用接口名；

（3）接口的字节码文件保存在.class 结尾的文件中；

（4）接口相应的字节码文件必须与包名称相匹配的目录结构中；

1.3 接口与类的区别

（1）接口不能用于实例化对象；

（2）接口没有构造方法；

（3）接口中不能包含成员变量，除了 static 和final 变量；

（4）接口不是被类继承了，而是要被类实现；

（5）接口支持多重继承；

 

2 类的继承

继承：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，name多个类无需再定义这些属性和行为，只要继承那个类即可。扩充了类的功能。继承的作用在于代码的复用。

合成：在新类里创建原有的对象称为合成。这种方式可以重复利用现有的代码而不更改它的形式。

好处：（1）提高代码的复用性；（2）让类与类产生了关系，是多态的前提。

2.1、继承的实现

继承通过extends关键字来实现，显式地指明其父类。

（1）基本格式

[修饰符] class 子类名 extends 父类名{

//TODO

}

2.2 继承的注意点

（1）子类拥有父类非private的属性和方法；

（2）子类可以拥有自己的属性和方法，即子类可以对父类进行扩展；

（3）子类可以用自己的方式实现父类的方法。

2.3 继承关键字

（1）extends 关键字

类的继承是单一继承，一个子类只能拥有一个父类，所以extends只能集成一个类。

（2）implement 关键字

使用implement关键字可以变相的使Java 具有多重继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口与接口之间采用逗号分隔）

（3）super和this关键字

super：对父类成员的引用；

this：指向自己的引用；

（4）final 关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；

用于修饰方法，该方法不能被子类重写；

修饰变量，不能被修改；

2.4 、继承中的重写

（1）父类和子类之间的多态性，对父类的函数进行重新定义，如果在子类中定义某方法与其父类有相同的名称和参数，我们就说该方法被重写（overriding）。子类可继承父类中的方法，而不需要重新编写相同的方法，但有时子类并不想原封不动地继承父类的方法，而是想做一定的修改，这就需要采用方法的重写。

（2）若子类中的方法与父类中的某一个方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。如需要父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。

 

2.5、使用super关键字

子类可以继承父类的非私有成员变量和成员方法（不是以private关键字修饰的）作为自己的成员变量和成员方法。但是，如果子类声明的成员变量与父类的成员变量同名，则子类不能继承父类的成员变量，称子类的成员变量隐藏了父类的成员变量。如果子类中声明的成员方法与父类的成员方法同名，并且方法的返回值及参数个数和类型也相同，则子类不能继承父类的成员方法，称子类的成员方法重写了父类的成员方法。

如果想在子类中访问父类中被隐藏的成员方法或变量，可以使用super关键字。

（1）调用父类的构造方法。

子类可以调用父类声明的构造方法，但是必须在子类的构造方法中使用super关键字来调用。

super([参数列表]);

（2）操作被隐藏的成员变量和被重写的成员方法

super.成员变量名;

super.成员方法名([参数列表]);

2.6 构造器

对于构造器而言，只能够被调用，而不能被继承。调用父类的构造方法使用super()即可。

示例：

执行结果：

通过这个示例可以看出，构建过程是从父类“向外”扩散的，也就是从父类开始向子类一级一级地完成构建，而且我们并没有显示的引用父类的构造器。这就是Java的独特之处：编辑器默认给子类调用父类的构造器。

前提：父类有默认的构造器就可以调用，但是父类没有默认的构造器，需要显示地使用super()来调用父类的构造器。

2.7 protected关键字

（1）protected关键字

设置变量和方法为protected，对于任何继承与此类的子类而言或者其他任何位于同一个包中的类而言，他却是可以访问的。

2.8 向上转型

在继承中是is -a 的相互关系，猫继承动物，可以说猫是动物，或者说猫是动物的一种，将猫看做动物就是向上转型。如下：

将子类转换成父类，在继承关系上面是向上移动的，所以一般称之为向上转型。由于向上转型是从一个专用类型向通用类型转换，所以它总是安全的，唯一发生变化的可能就是属性和方法的丢失。

 

3、多态

3.1、什么是多态

（1）定义：指允许不同类的对象对同一消息做出响应，即同一消息可以根据发送对象的不同而采用不同的行为方式。（发送消息就是方法调用）

通常使用方法的重载（Overloading）和重写（Overriding）实现类的多态性。

方法的重载：在一个类中出现多个方法名相同，但是参数个数或参数类型不同的方法。

（2）实现多态的技术：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

（3）多态的作用：消除类型之间的耦合关系。

（4）多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载。

3.2、多态的实现条件

（1）要有继承；（2）要有重写；（3）向上转型——父类引用指向子类对象

3.3、多态的好处

(1)可替换性；（2）可扩充性；（3）接口性；（4）灵活性；（5）简化性；

3.4、总结

 Wine a = new JNC();、

这里定义了一个Wine 类型的a,它指向JNC对象实例，由于JNC是集成于Wine，所以JNC可以自动向上转型为Wine，所以a 是可以指向JNC 实例对象的。这样做存在一个非常大的好处，在继承中我们知道子类是父类的扩展，可以提供比父类更加强大的功能，如果定义了一个指向子类的父类引用类型，那么它除了能够引用父类的共性外，还可以使用子类强大的功能。

总结：

指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，若子类重写了父类中的某些方法，在调用该些方法的时候，必定是子类中定义的这些方法（动态连接、动态调用）。

 

第六章 类的高级特性

1 抽象类

1、抽象类

如果一个类中没有包含足够的信息来描绘一个具体的对象，这个类就是抽象类。抽象类主要用来类型隐藏。可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式，这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为这个抽象类的所有派生类。

接口和抽象类中的所有抽象方法不能有具体实现，而应在它们的子类中实现所有的抽象方法（要有函数体，哪怕{}里是空的），每个子类都可根据自己的需要来实现抽象方法。

所谓抽象类就是只声明方法的存在而不去具体实现的类。抽象类不能被实例化。定义抽象类时，要在class关键字前面加上abstract关键字。

语法格式：

abstract class 类名{

类体

}

2、抽象方法

在抽象类中创建的，没有实际意义的，必须要子类重写的方法称为抽象方法。抽象方法只有方法的声明，而没有方法的实现，用abstract关键字进行修饰。

声明一个抽象方法的格式为：abstract <方法返回值类型> 方法名(参数列表);

public abstract void harvest(); //收获的方法

注：抽象方法不能使用private、或static关键字进行修饰。

包含抽象方法的类必须被声明为抽象类。

3、抽象类的使用规则

（1）抽象方法必须为public 或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下为public；

（2）抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；

（3）抽象类必须有子类，使用extends 继承，一个子类只能继承一个抽象类；

（4）子类（如果不是抽象类）则必须覆写抽象类中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为abstract类）。

 

2 内部类

如果在一个类中再定义一个类，就将在类中再定义的那个类称为内部类。内部类可分为成员内部类、局部内部类以及匿名内部类。

 

第七章 Java集合类

1 集合类概述

Java语言的Java.util 包中提供了一些集合类，这些集合类又被称为容器。

数组的长度是固定的，集合的长度是可变的；数组用来存放基本类型的数据，集合用来存放对象的引用。常用的集合有List集合、Set集合、Map集合，集中List与Set实现了Collection接口。各接口还提供了不同的实现类。

2 集合类接口的常用方法

Collection接口是层次结构中的根接口。构成Collection的单位，被称之为元素。Collection接口通常不能直接使用，但该接口提供了添加和删除元素、管理数据的方法。由于List接口与Set接口都实现了Collection接口，因此这些方法对List集合与Set集合是通用的。

1、List 接口的常用方法