今天给老婆整理了一下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<int, long> map = new HashMap<>(); // 正确使用Map<Integer, Long> map = new HashMap<>();

b. Collection 框架中的数据结构，例如ArrayList和Vector，只存储对象（引用类型）而不是基本数据类型。

// 提示错误Type argument cannot be of primitive type（类型参数不能是基本类型）List<int> list = new ArrayList<>();// 正确使用List<Integer> 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<Integer> 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<Integer> 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()方法，可能输出为2System.out.println(s.length());

而程序员B也继承了String并重写了length()方法：

StringB s = "abc";// 由于StringB重写了length()方法，可能输出为4System.out.println(s.length());

因此其他人在使用时会感到很困惑，每次使用length()方法时都得好好看看它的具体实现，每个人的实现还可能都不一样，容易导致混淆，造成不必要的问题。

因此在这些情况下可以将类声明为final，避免出现不必要的问题。

7、集合类

Java中的集合类相对复杂，下图即为集合类的整体继承关系图。

a. Iterable接口

实现了Iterable接口的所有类都可以使用Iterator进行遍历。

public static void main(String[] args) {    List<Integer> list = new ArrayList<>();    list.add(1);    list.add(2);    // 使用Iterator进行遍历    Iterator<Integer> 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的一些基本操作。

其他一些具体实现类暂不介绍。