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一样，用于对方法进行抽象。接口和类的区别如下：

抽象类一般使用方法：如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个基本类型都有其包装类：

包装类的作用：

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()方法，可能输出为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<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的一些基本操作。

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