Java 7种类类型，新手必备_java的类型
今天给老婆整理了一下Java的几种类类型，希望她能对类的基本情况增加一些了解。
1、接口（interface）
接口是一个定义了方法规范（返回值、方法名、参数）的类，一般情况下不实现具体逻辑（在JDK1.8之后可以有默认实现）。因此，在实际开发过程当中，需要有另外一个类来进行具体实现。如java.lang包下的Runnable接口：
public interface Runnable {
public abstract void run();
}因为该接口没有默认实现，需要具体的实现类对其方法进行实现：
public class ChickenRun implements Runnable {
@Override
public void run() {
System.out.println("Run Run Run!!!");
}
}
public class DuckRun implements Runnable {
@Override
public void run() {
System.out.println("Run Run Run!!!");
}
}2、抽象类（abstract class）
抽象类是使用abstract声明的类，和interface一样，用于对方法进行抽象。接口和类的区别如下：
接口 | 抽象类 | |
是否能实例化 | 否 | 否 |
是否需要实现抽象方法 | 是 | 只需要实现抽象方法，不需要实现非抽象方法 |
是否拥有构造方法 | 否 | 是 |
接口中的定义常量类型 | public final，不可被修改 | 与普通类一样，可以有任意定义 |
抽象类一般使用方法：如1中所示，ChickRun和DuckRun都实现了Runnable接口，而且有相同的实现，若还有一个GooseRun等其他实现就需要重复N遍相同代码，因此可以使用抽象类来实现默认逻辑。其他ChickRun、DuckRun以及GooseRun等类只需要集成该抽象类即可，可解决代码重复。
public abstract class PoultryRun implements Runnable {
@Override
public void run() {
System.out.println("Run Run Run!!!");
}
}
public class ChickenRun extends PoultryRun {
}使用方法完全一样：
public static void main(String[] args) {
ChickenRun chickenRun = new ChickenRun();
chickenRun.run(); // 输出 Run Run Run!!!
}3、包装类
Java包装类是指对基本数据类型进行包装的类。如8个基本类型都有其包装类：
基本数据类型 | 包装类 |
char | Character |
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
boolean | Boolean |
包装类的作用：
a. java.util包中只处理对象，无法使用基本类型，如：
// 提示错误Type argument cannot be of primitive type（类型参数不能是基本类型）
Map map = new HashMap<>();
// 正确使用
Map map = new HashMap<>(); b. Collection 框架中的数据结构，例如ArrayList和Vector，只存储对象（引用类型）而不是基本数据类型。
// 提示错误Type argument cannot be of primitive type（类型参数不能是基本类型）
List list = new ArrayList<>();
// 正确使用
List list = new ArrayList<>(); c. 多线程同步加锁时需要使用对象，而不是基本数据类型。
// 提示错误Incompatible types. Found: 'int', required: 'java.lang.Object'
// 不兼容的类型。 发现:'int'，要求:'java.lang.Object'
int lock = 0;
synchronized (lock) {
}
// 正确使用
Integer lock = 0;
synchronized (lock) {
}3.1 自动装箱与拆箱
自动装箱：将基本类型自动转换为其相应包装类的对象称为自动装箱。例如 int 到 Integer、long 到 Long、double 到 Double 的转换等。
public void autoboxing() {
char ch = 'a';
// 自动装箱，将char类型自动转换成Character类型
Character a = ch;
List arrayList = new ArrayList<>();
// 由于ArrayList只支持存储对象，因此将25自动装箱成Integer类型
arrayList.add(25);
} 自动拆箱：自动装箱的逆过程。将包装类的对象自动转换为其相应的基本类型称为拆箱。例如 Integer 转换为 int，Long 转换为 long，Double 转换为 double等。
public void unBoxing() {
Character ch = 'a';
// 自动拆箱，Character类型自动转换成char类型
char a = ch;
ArrayList arrayList = new ArrayList<>();
arrayList.add(24);
// 自动拆箱，将ArrayList的Integer类型的元素自动转换成int类型
int num = arrayList.get(0);
} 4、内部类
内部类是定义在类内部的类。使用内部类可以更容易地理解每个类之间的关系并保持代码简单。另外，内部类可以指定public、private、protected访问级别，因此可以对类的外部隐藏其存在。如下：
public class OuterClass {
private int x = 10;
private int y = 20;
public int sum() {
return x + y;
}
public class InnerClass {
private int innerX = 30;
private int innerY = 40;
public int getOuterX() {
return x;
}
public int getOuterY() {
return y;
}
public int sumAll() {
return x + y + innerX + innerY;
}
}
}内部类的实例化：
public static void main(String[] args) {
// 首先实例化外部类
OuterClass outerClass = new OuterClass();
// 再利用外部类对象实例化内部类，是不是没这么用过~~~
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
// 输出100
System.out.println(innerClass.sumAll());
}静态内部类：
public class OuterClass {
private int x = 10;
private int y = 20;
public int sum() {
return x + y;
}
public static class InnerClass {
private int innerX = 30;
private int innerY = 40;
// 错误，无法访问外部类成员变量
public int getOuterX() {
return x;
}
// 错误，无法访问外部类成员变量
public int getOuterY() {
return y;
}
}
}静态内部类实例化：
public class OuterClass {
private int x = 10;
private int y = 20;
public int sum() {
return x + y;
}
public static class InnerClass {
private int innerX = 30;
private int innerY = 40;
public int sum() {
return innerX + innerY;
}
}
public static void main(String[] args) {
// 可以和普通类一样使用
InnerClass innerClass = new InnerClass();
// 输出70
System.out.println(innerClass.sum());
}
}5、匿名类
匿名类可以使代码更加简洁，如果类实例对象只需要使用一次，那么就可以使用匿名类。
public class AnonymousClass {
static class MyThread implements Runnable {
@Override
public void run() {
System.out.println("Run");
}
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.start();
}
}如上是未使用匿名类的代码，使用匿名类后如下：
public class AnonymousClass {
public static void main(String[] args) {
// Runnable即为匿名类
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Run");
}
}).start();
}
}使用匿名类后代码精简了许多，也不需要额外定义一个新的类（如上：MyThread），匿名类还可配合Java 8使用，使得代码更加精简。如下：
public class AnonymousClass {
public static void main(String[] args) {
// 缩减为一句话
new Thread(() -> System.out.println("Run")).start();
}
}6、final类
final类是一个被final修饰的类，如java.lang.String类。final类不可被继承。
为何要将类修饰为final？
以String类来举例子，假设String类可以被继承，那么每个人都有权限去重写它的方法。假设程序员A继承了String并重写了它的length()方法。
StringA s = "abc";
// 由于StringA重写了length()方法，可能输出为2
System.out.println(s.length());而程序员B也继承了String并重写了length()方法：
StringB s = "abc";
// 由于StringB重写了length()方法，可能输出为4
System.out.println(s.length());因此其他人在使用时会感到很困惑，每次使用length()方法时都得好好看看它的具体实现，每个人的实现还可能都不一样，容易导致混淆，造成不必要的问题。
因此在这些情况下可以将类声明为final，避免出现不必要的问题。
7、集合类
Java中的集合类相对复杂，下图即为集合类的整体继承关系图。
a. Iterable接口
实现了Iterable接口的所有类都可以使用Iterator进行遍历。
public static void main(String[] args) {
List list = new ArrayList<>();
list.add(1);
list.add(2);
// 使用Iterator进行遍历
Iterator it = list.iterator();
while (it.hasNext()) {
int str = it.next();
System.out.print(str);
}
} b. Collection接口
Collection接口定义了集合的基本操作，如add()，remove()，size()等。
c. List接口
List接口定义了列表的一些基本操作，如indexOf()，subList()，get()，set()等。
d. Queue接口
Queue接口定义了队列的一些基本操作，如poll()，peek()，offer()等。
e. Set接口
定义了Set的一些基本操作。
其他一些具体实现类暂不介绍。