System class contains several useful class fields
* and methods. It cannot be instantiated.
*
* Among the facilities provided by the System class
* are standard input, standard output, and error output streams;
* access to externally defined properties and environment
* variables; a means of loading files and libraries; and a utility
* method for quickly copying a portion of an array.
*
* @author unascribed
* @since JDK1.0
*/
public final class System {
...
}
```
可以看到它是属于`java.lang`这个包下的类，并且这个类也导入了很多其他包中的类在进行使用。那么，为什么我们在使用这个类时，没有导入呢？实际上Java中会默认导入`java.lang`这个包下的所有类，因此我们不需要手动指定。
IDEA非常智能，我们在使用项目中定义的类时，会自动帮我们将导入补全，所以说代码写起来非常高效。
注意，在不同包下的类，即使类名相同，也是不同的两个类：
```java
package com.test.entity;
public class String { //我们在自己的包中也建一个名为String的类
}
```
当我们在使用时：
由于默认导入了系统自带的String类，并且也导入了我们自己定义的String类，那么此时就出现了歧义，编译器不知道到底我们想用的是哪一个String类，所以说我们需要明确指定：
```java
public class Main {
public static void main(java.lang.String[] args) { //主方法的String参数是java.lang包下的，我们需要明确指定一下，只需要在类名前面添加包名就行了
com.test.entity.String string = new com.test.entity.String();
}
}
```
我们只需要在类名前面把完整的包名也给写上，就可以表示这个是哪一个包里的类了，当然，如果没有出现歧义，默认情况下包名是可以省略的，可写可不写。
可能各位小伙伴会发现一个问题，为什么对象的属性访问不了了？
编译器说name属性在这个类中不是public，无法在外部进行访问，这是什么情况呢？这里我们就要介绍的到Java的访问权限控制了。
### 访问权限控制
实际上Java中是有访问权限控制的，就是我们个人的隐私的一样，我不允许别人随便来查看我们的隐私，只有我们自己同意的情况下，才能告诉别人我们的名字、年龄等隐私信息。
所以说Java中引入了访问权限控制（可见性），我们可以为成员变量、成员方法、静态变量、静态方法甚至是类指定访问权限，不同的访问权限，有着不同程度的访问限制：
* `private` - 私有，标记为私有的内容无法被除当前类以外的任何位置访问。
* `什么都不写` - 默认，默认情况下，只能被类本身和同包中的其他类访问。
* `protected` - 受保护，标记为受保护的内容可以能被类本身和同包中的其他类访问，也可以被子类访问（子类我们会在下一章介绍）
* `public` - 公共，标记为公共的内容，允许在任何地方被访问。
这四种访问权限，总结如下表：
| | 当前类 | 同一个包下的类 | 不同包下的子类 | 不同包下的类 |
| :-------: | :----: | :------------: | :------------: | :----------: |
| public | ✅ | ✅ | ✅ | ✅ |
| protected | ✅ | ✅ | ✅ | ❌ |
| 默认 | ✅ | ✅ | ❌ | ❌ |
| private | ✅ | ❌ | ❌ | ❌ |
比如我们刚刚出现的情况，就是因为是默认的访问权限，所以说在当前包以外的其他包中无法访问，但是我们可以提升它的访问权限，来使得外部也可以访问：
```java
public class Person {
public String name; //在name变量前添加public关键字，将其可见性提升为公共等级
int age;
String sex;
}
```
这样我们就可以在外部正常使用这个属性了：
```java
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name); //正常访问到成员变量
}
```
实际上如果各位小伙伴观察仔细的话，会发现我们创建出来的类自带的访问等级就是`public`：
```java
package com.test.entity;
public class Person { //class前面有public关键字
}
```
也就是说这个类实际上可以在任何地方使用，但是我们也可以将其修改为默认的访问等级：
```java
package com.test.entity;
class Person { //去掉public变成默认等级
}
```
如果是默认等级的话，那么在外部同样是无法访问的：
但是注意，我们创建的普通类不能是`protected`或是`private`权限，因为我们目前所使用的普通类要么就是只给当前的包内使用，要么就是给外面都用，如果是`private`谁都不能用，那这个类定义出来干嘛呢？
如果某个类中存在静态方法或是静态变量，那么我们可以通过静态导入的方式将其中的静态方法或是静态变量直接导入使用，但是同样需要有访问权限的情况下才可以：
```java
public class Person {
String name;
int age;
String sex;
public static void test(){
System.out.println("我是静态方法！");
}
}
```
我们来尝试一下静态导入：
```java
import static com.test.entity.Person.test; //静态导入test方法
public class Main {
public static void main(String[] args) {
test(); //直接使用就可以，就像在这个类定义的方法一样
}
}
```
至此，有关包相关的内容，我们就讲解到这里。
***
## 封装、继承和多态
封装、继承和多态是面向对象编程的三大特性。
> 封装，把对象的属性和方法结合成一个独立的整体，隐藏实现细节，并提供对外访问的接口。
>
> 继承，从已知的一个类中派生出一个新的类，叫子类。子类实现了父类所有非私有化的属性和方法，并根据实际需求扩展出新的行为。
>
> 多态，多个不同的对象对同一消息作出响应，同一消息根据不同的对象而采用各种不同的方法。
正是这三大特性，让我们的Java程序更加生动形象。
### 类的封装
封装的目的是为了保证变量的安全性，使用者不必在意具体实现细节，而只是通过外部接口即可访问类的成员，如果不进行封装，类中的实例变量可以直接查看和修改，可能给整个代码带来不好的影响，因此在编写类时一般将成员变量私有化，外部类需要使用Getter和Setter方法来查看和设置变量。
我们可以将之前的类进行改进：
```java
public class Person {
private String name; //现在类的属性只能被自己直接访问
private int age;
private String sex;
public Person(String name, int age, String sex) { //构造方法也要声明为公共，否则对象都构造不了
this.name = name;
this.age = age;
this.sex = sex;
}
public String getName() {
return name; //想要知道这个对象的名字，必须通过getName()方法来获取，并且得到的只是名字值，外部无法修改
}
public String getSex() {
return sex;
}
public int getAge() {
return age;
}
}
```
我们可以来试一下：
```java
public static void main(String[] args) {
Person person = new Person("小明", 18, "男");
System.out.println(person.getName()); //只能通过调用getName()方法来获取名字
}
```
也就是说，外部现在只能通过调用我定义的方法来获取成员属性，而我们可以在这个方法中进行一些额外的操作，比如小明可以修改名字，但是名字中不能包含"小"这个字：
```java
public void setName(String name) {
if(name.contains("小")) return;
this.name = name;
}
```
我们甚至还可以将构造方法改成私有的，需要通过我们的内部的方式来构造对象：
```java
public class Person {
private String name;
private int age;
private String sex;
private Person(){} //不允许外部使用new关键字创建对象
public static Person getInstance() { //而是需要使用我们的独特方法来生成对象并返回
return new Person();
}
}
```
通过这种方式，我们可以实现单例模式：
> ```java
> public class Test {
> private static Test instance;
>
> private Test(){}
>
> public static Test getInstance() {
> if(instance == null)
> instance = new Test();
> return instance;
> }
> }
> ```
>
> 单例模式就是全局只能使用这一个对象，不能创建更多的对象，我们就可以封装成这样，关于单例模式的详细介绍，还请各位小伙伴在《Java设计模式》视频教程中再进行学习。
封装思想其实就是把实现细节给隐藏了，外部只需知道这个方法是什么作用，而无需关心实现，要用什么由类自己来做，不需要外面来操作类内部的东西去完成，封装就是通过访问权限控制来实现的。
### 类的继承
前面我们介绍了类的封装，我们接着来看一个非常重要特性：继承。
在定义不同类的时候存在一些相同属性，为了方便使用可以将这些共同属性抽象成一个父类，在定义其他子类时可以继承自该父类，减少代码的重复定义，子类可以使用父类中**非私有**的成员。
比如说我们一开始使用的人类，那么实际上人类根据职业划分，所掌握的技能也会不同，比如画家会画画，歌手会唱，舞者会跳，Rapper会rap，运动员会篮球，我们可以将人类这个大类根据职业进一步地细分出来：
实际上这些划分出来的类，本质上还是人类，也就是说人类具有的属性，这些划分出来的类同样具有，但是，这些划分出来的类同时也会拥有他们自己独特的技能。在Java中，我们可以创建一个类的子类来实现上面的这种效果：
```java
public class Person { //先定义一个父类
String name;
int age;
String sex;
}
```
接着我们可以创建各种各样的子类，想要继承一个类，我们只需要使用`extends`关键字即可：
```java
public class Worker extends Person{ //工人类
}
```
```java
public class Student extends Person{ //学生类
}
```
类的继承可以不断向下，但是同时只能继承一个类，同时，标记为`final`的类不允许被继承：
```java
public final class Person { //class前面添加final关键字表示这个类已经是最终形态，不能继承
}
```
当一个类继承另一个类时，属性会被继承，可以直接访问父类中定义的属性，除非父类中将属性的访问权限修改为`private`，那么子类将无法访问（但是依然是继承了这个属性的）：
```java
public class Student extends Person{
public void study(){
System.out.println("我的名字是 "+name+"，我在学习！"); //可以直接访问父类中定义的name属性
}
}
```
同样的，在父类中定义的方法同样会被子类继承：
```java
public class Person {
String name;
int age;
String sex;
public void hello(){
System.out.println("我叫 "+name+"，今年 "+age+" 岁了!");
}
}
```
子类直接获得了此方法，当我们创建一个子类对象时就可以直接使用这个方法：
```java
public static void main(String[] args) {
Student student = new Student();
student.study(); //子类不仅有自己的独特技能
student.hello(); //还继承了父类的全部技能
}
```
是不是感觉非常人性化，子类继承了父类的全部能力，同时还可以扩展自己的独特能力，就像一句话说的： 龙生龙凤生凤，老鼠儿子会打洞。
如果父类存在一个有参构造方法，子类必须在构造方法中调用：
```java
public class Person {
protected String name; //因为子类需要用这些属性，所以说我们就将这些变成protected，外部不允许访问
protected int age;
protected String sex;
protected String profession;
//构造方法也改成protected，只能子类用
protected Person(String name, int age, String sex, String profession) {
this.name = name;
this.age = age;
this.sex = sex;
this.profession = profession;
}
public void hello(){
System.out.println("["+profession+"] 我叫 "+name+"，今年 "+age+" 岁了!");
}
}
```
可以看到，此时两个子类都报错了：
因为子类在构造时，不仅要初始化子类的属性，还需要初始化父类的属性，所以说在默认情况下，子类其实是调用了父类的构造方法的，只是在无参的情况下可以省略，但是现在父类构造方法需要参数，那么我们就需要手动指定了：
既然现在父类需要三个参数才能构造，那么子类需要按照同样的方式调用父类的构造方法：
```java
public class Student extends Person{
public Student(String name, int age, String sex) { //因为学生职业已经确定，所以说学生直接填写就可以了
super(name, age, sex, "学生"); //使用super代表父类，父类的构造方法就是super()
}
public void study(){
System.out.println("我的名字是 "+name+"，我在学习！");
}
}
```
```java
public class Worker extends Person{
public Worker(String name, int age, String sex) {
super(name, age, sex, "工人"); //父类构造调用必须在最前面
System.out.println("工人构造成功！"); //注意，在调用父类构造方法之前，不允许执行任何代码，只能在之后执行
}
}
```
我们在使用子类时，可以将其当做父类来使用：
```java
public static void main(String[] args) {
Person person = new Student("小明", 18, "男"); //这里使用父类类型的变量，去引用一个子类对象（向上转型）
person.hello(); //父类对象的引用相当于当做父类来使用，只能访问父类对象的内容
}
```
虽然我们这里使用的是父类类型引用的对象，但是这并不代表子类就彻底变成父类了，这里仅仅只是当做父类使用而已。
我们也可以使用强制类型转换，将一个被当做父类使用的子类对象，转换回子类：
```java
public static void main(String[] args) {
Person person = new Student("小明", 18, "男");
Student student = (Student) person; //使用强制类型转换（向下转型）
student.study();
}
```
但是注意，这种方式只适用于这个对象本身就是对应的子类才可以，如果本身都不是这个子类，或者说就是父类，那么会出现问题：
```java
public static void main(String[] args) {
Person person = new Worker("小明", 18, "男"); //实际创建的是Work类型的对象
Student student = (Student) person;
student.study();
}
```
此时直接出现了类型转换异常，因为本身不是这个类型，强转也没用。
那么如果我们想要判断一下某个变量所引用的对象到底是什么类，那么该怎么办呢？
```java
public static void main(String[] args) {
Person person = new Student("小明", 18, "男");
if(person instanceof Student) { //我们可以使用instanceof关键字来对类型进行判断
System.out.println("对象是 Student 类型的");
}
if(person instanceof Person) {
System.out.println("对象是 Person 类型的");
}
}
```
如果变量所引用的对象是对应类型或是对应类型的子类，那么`instanceof`都会返回`true`，否则返回`false`。
最后我们需要来特别说明一下，子类是可以定义和父类同名的属性的：
```java
public class Worker extends Person{
protected String name; //子类中同样可以定义name属性
public Worker(String name, int age, String sex) {
super(name, age, sex, "工人");
}
}
```
此时父类的name属性和子类的name属性是同时存在的，那么当我们在子类中直接使用时：
```java
public void work(){
System.out.println("我是 "+name+"，我在工作！"); //这里的name，依然是作用域最近的哪一个，也就是在当前子类中定义的name属性，而不是父类的name属性
}
```
所以说，我们在使用时，实际上这里得到的结果为`null`：
那么，在子类存在同名变量的情况下，怎么去访问父类的呢？我们同样可以使用`super`关键字来表示父类：
```java
public void work(){
System.out.println("我是 "+super.name+"，我在工作！"); //这里使用super.name来表示需要的是父类的name变量
}
```
这样得到的结果就不一样了：
但是注意，没有`super.super`这种用法，也就是说如果存在多级继承的话，那么最多只能通过这种方法访问到父类的属性（包括继承下来的属性）
### 顶层Object类
实际上所有类都默认继承自Object类，除非手动指定继承的类型，但是依然改变不了最顶层的父类是Object类。所有类都包含Object类中的方法，比如：
我们发现，除了我们自己在类中编写的方法之外，还可以调用一些其他的方法，那么这些方法不可能无缘无故地出现，肯定同样是因为继承得到的，那么这些方法是继承谁得到的呢？
```java
public class Person extends Object{
//除非我们手动指定要继承的类是什么，实际上默认情况下所有的类都是继承自Object的，只是可以省略
}
```
所以说我们的继承结构差不多就是：
既然所有的类都默认继承自Object，我们来看看这个类里面有哪些内容：
```java
public class Object {
private static native void registerNatives(); //标记为native的方法是本地方法，底层是由C++实现的
static {
registerNatives(); //这个类在初始化时会对类中其他本地方法进行注册，本地方法不是我们SE中需要学习的内容，我们会在JVM篇视频教程中进行介绍
}
//获取当前的类型Class对象，这个我们会在最后一章的反射中进行讲解，目前暂时不会用到
public final native Class getClass();
//获取对象的哈希值，我们会在第五章集合类中使用到，目前各位小伙伴就暂时理解为会返回对象存放的内存地址
public native int hashCode();
//判断当前对象和给定对象是否相等，默认实现是直接用等号判断，也就是直接判断是否为同一个对象
public boolean equals(Object obj) {
return (this == obj);
}
//克隆当前对象，可以将复制一个完全一样的对象出来，包括对象的各个属性
protected native Object clone() throws CloneNotSupportedException;
//将当前对象转换为String的形式，默认情况下格式为 完整类名@十六进制哈希值
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
//唤醒一个等待当前对象锁的线程，有关锁的内容，我们会在第六章多线程部分中讲解，目前暂时不会用到
public final native void notify();
//唤醒所有等待当前对象锁的线程，同上
public final native void notifyAll();
//使得持有当前对象锁的线程进入等待状态，同上
public final native void wait(long timeout) throws InterruptedException;
//同上
public final void wait(long timeout, int nanos) throws InterruptedException {
...
}
//同上
public final void wait() throws InterruptedException {
...
}
//当对象被判定为已经不再使用的“垃圾”时，在回收之前，会由JVM来调用一次此方法进行资源释放之类的操作，这同样不是SE中需要学习的内容，这个方法我们会在JVM篇视频教程中详细介绍，目前暂时不会用到
protected void finalize() throws Throwable { }
}
```
这里我们可以尝试调用一下Object为我们提供的`toString()`方法：
```java
public static void main(String[] args) {
Person person = new Student("小明", 18, "男");
String str = person.toString();
System.out.println(str);
}
```
这里就是按照上面说的格式进行打印：
当然，我们直接可以给`println`传入一个Object类型的对象：
```java
public void println(Object x) {
String s = String.valueOf(x); //这里同样会调用对象的toString方法，所以说跟上面效果是一样的
synchronized (this) {
print(s);
newLine();
}
}
```
有小伙伴肯定会好奇，这里不是接受的一个Object类型的值的，为什么任意类型都可以传入呢？因为所有类型都是继承自Object，如果方法接受的参数是一个引用类型的值，那只要是这个类的对象或是这个类的子类的对象，都可以作为参数传入。
我们也可以试试看默认提供的`equals`方法：
```java
public static void main(String[] args) {
Person p1 = new Student("小明", 18, "男");
Person p2 = new Student("小明", 18, "男");
System.out.println(p1.equals(p2));
}
```
因为默认比较的是两个对象是否为同一个对象，所以说这里得到的肯定是false，但是有些情况下，实际上我们所希望的情况是如果名字、年龄、性别都完全相同，那么这肯定是同一个人，但是这里却做不到这样的判断，我们需要修改一下`equals`方法的默认实现来完成，这就要用到方法的重写了。
### 方法的重写
注意，方法的重写不同于之前的方法重载，不要搞混了，方法的重载是为某个方法提供更多种类，而方法的重写是覆盖原有的方法实现，比如我们现在不希望使用Object类中提供的`equals`方法，那么我们就可以将其重写了：
```java
public class Person{
...
@Override //重写方法可以添加 @Override 注解，有关注解我们会在最后一章进行介绍，这个注解默认情况下可以省略
public boolean equals(Object obj) { //重写方法要求与父类的定义完全一致
if(obj == null) return false; //如果传入的对象为null，那肯定不相等
if(obj instanceof Person) { //只有是当前类型的对象，才能进行比较，要是都不是这个类型还比什么
Person person = (Person) obj; //先转换为当前类型，接着我们对三个属性挨个进行比较
return this.name.equals(person.name) && //字符串内容的比较，不能使用==，必须使用equals方法
this.age == person.age && //基本类型的比较跟之前一样，直接==
this.sex.equals(person.sex);
}
return false;
}
}
```
在重写Object提供的`equals`方法之后，就会按照我们的方式进行判断了：
```java
public static void main(String[] args) {
Person p1 = new Student("小明", 18, "男");
Person p2 = new Student("小明", 18, "男");
System.out.println(p1.equals(p2)); //此时由于三个属性完全一致，所以说判断结果为真，即使是两个不同的对象
}
```
有时候为了方便查看对象的各个属性，我们可以将Object类提供的`toString`方法重写了：
```java
@Override
public String toString() { //使用IDEA可以快速生成
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
", profession='" + profession + '\'' +
'}';
}
```
这样，我们直接打印对象时，就会打印出对象的各个属性值了：
```java
public static void main(String[] args) {
Person person = new Student("小明", 18, "男");
System.out.println(person);
}
```
注意，静态方法不支持重写，因为它是属于类本身的，但是它可以被继承。
基于这种方法可以重写的特性，对于一个类定义的行为，不同的子类可以出现不同的行为，比如考试，学生考试可以得到A，而工人去考试只能得到D：
```java
public class Person {
...
public void exam(){
System.out.println("我是考试方法");
}
...
}
```
```java
public class Student extends Person{
...
@Override
public void exam() {
System.out.println("我是学生，我就是小镇做题家，拿个 A 轻轻松松");
}
}
```
```java
public class Worker extends Person{
...
@Override
public void exam() {
System.out.println("我是工人，做题我并不擅长，只能得到 D");
}
}
```
这样，不同的子类，对于同一个方法会产生不同的结果：
```java
public static void main(String[] args) {
Person person = new Student("小明", 18, "男");
person.exam();
person = new Worker("小强", 18, "男");
person.exam();
}
```
这其实就是面向对象编程中多态特性的一种体现。
注意，我们如果不希望子类重写某个方法，我们可以在方法前添加`final`关键字，表示这个方法已经是最终形态：
```java
public final void exam(){
System.out.println("我是考试方法");
}
```
或者，如果父类中方法的可见性为`private`，那么子类同样无法访问，也就不能重写，但是可以定义同名方法：
虽然这里可以编译通过，但是并不是对父类方法的重写，仅仅是子类自己创建的一个新方法。
还有，我们在重写父类方法时，如果希望调用父类原本的方法实现，那么同样可以使用`super`关键字：
```java
@Override
public void exam() {
super.exam(); //调用父类的实现
System.out.println("我是工人，做题我并不擅长，只能得到 D");
}
```
然后就是访问权限的问题，子类在重写父类方法时，不能降低父类方法中的可见性：
```java
public void exam(){
System.out.println("我是考试方法");
}
```
因为子类实际上可以当做父类使用，如果子类的访问权限比父类还低，那么在被当做父类使用时，就可能出现无视访问权限调用的情况，这样肯定是不行的，但是相反的，我们可以在子类中提升权限：
```java
protected void exam(){
System.out.println("我是考试方法");
}
```
```java
@Override
public void exam() { //将可见性提升为public
System.out.println("我是工人，做题我并不擅长，只能得到 D");
}
```
可以看到作为子类时就可以正常调用，但是如果将其作为父类使用，因为访问权限不足所有就无法使用，总之，子类重写的方法权限不能比父类还低。
### 抽象类
在我们学习了类的继承之后，实际上我们会发现，越是处于顶层定义的类，实际上可以进一步地进行抽象，比如我们前面编写的考试方法：
```java
protected void exam(){
System.out.println("我是考试方法");
}
```
这个方法再子类中一定会被重写，所以说除非子类中调用父类的实现，否则一般情况下永远都不会被调用，就像我们说一个人会不会考试一样，实际上人怎么考试是一个抽象的概念，而学生怎么考试和工人怎么考试，才是具体的一个实现，所以说，我们可以将人类进行进一步的抽象，让某些方法完全由子类来实现，父类中不需要提供实现。
要实现这样的操作，我们可以将人类变成抽象类，抽象类比类还要抽象：
```java
public abstract class Person { //通过添加abstract关键字，表示这个类是一个抽象类
protected String name; //大体内容其实普通类差不多
protected int age;
protected String sex;
protected String profession;
protected Person(String name, int age, String sex, String profession) {
this.name = name;
this.age = age;
this.sex = sex;
this.profession = profession;
}
public abstract void exam(); //抽象类中可以具有抽象方法，也就是说这个方法只有定义，没有方法体
}
```
而具体的实现，需要由子类来完成，而且如果是子类，必须要实现抽象类中所有抽象方法：
```java
public class Worker extends Person{
public Worker(String name, int age, String sex) {
super(name, age, sex, "工人");
}
@Override
public void exam() { //子类必须要实现抽象类所有的抽象方法，这是强制要求的，否则会无法通过编译
System.out.println("我是工人，做题我并不擅长，只能得到 D");
}
}
```
抽象类由于不是具体的类定义（它是类的抽象）可能会存在某些方法没有实现，因此无法直接通过new关键字来直接创建对象：
要使用抽象类，我们只能去创建它的子类对象。
抽象类一般只用作继承使用，当然，抽象类的子类也可以是一个抽象类：
```java
public abstract class Student extends Person{ //如果抽象类的子类也是抽象类，那么可以不用实现父类中的抽象方法
public Student(String name, int age, String sex) {
super(name, age, sex, "学生");
}
@Override //抽象类中并不是只能有抽象方法，抽象类中也可以有正常方法的实现
public void exam() {
System.out.println("我是学生，我就是小镇做题家，拿个 A 轻轻松松");
}
}
```
注意，抽象方法的访问权限不能为`private`：
因为抽象方法一定要由子类实现，如果子类都访问不了，那么还有什么意义呢？所以说不能为私有。
### 接口
接口甚至比抽象类还抽象，他只代表某个确切的功能！也就是只包含方法的定义，甚至都不是一个类！接口一般只代表某些功能的抽象，接口包含了一些列方法的定义，类可以实现这个接口，表示类支持接口代表的功能（类似于一个插件，只能作为一个附属功能加在主体上，同时具体实现还需要由主体来实现）
咋一看，这啥意思啊，什么叫支持接口代表的功能？实际上接口的目标就是将类所具有某些的行为抽象出来。
比如说，对于人类的不同子类，学生和老师来说，他们都具有学习这个能力，既然都有，那么我们就可以将学习这个能力，抽象成接口来进行使用，只要是实现这个接口的类，都有学习的能力：
```java
public interface Study { //使用interface表示这是一个接口
void study(); //接口中只能定义访问权限为public抽象方法，其中public和abstract关键字可以省略
}
```
我们可以让类实现这个接口：
```java
public class Student extends Person implements Study { //使用implements关键字来实现接口
public Student(String name, int age, String sex) {
super(name, age, sex, "学生");
}
@Override
public void study() { //实现接口时，同样需要将接口中所有的抽象方法全部实现
System.out.println("我会学习！");
}
}
```
```java
public class Teacher extends Person implements Study {
protected Teacher(String name, int age, String sex) {
super(name, age, sex, "教师");
}
@Override
public void study() {
System.out.println("我会加倍学习！");
}
}
```
接口不同于继承，接口可以同时实现多个：
```java
public class Student extends Person implements Study, A, B, C { //多个接口的实现使用逗号隔开
}
```
所以说有些人说接口其实就是Java中的多继承，但是我个人认为这种说法是错的，实际上实现接口更像是一个类的功能列表，作为附加功能存在，一个类可以附加很多个功能，接口的使用和继承的概念有一定的出入，顶多说是多继承的一种替代方案。
接口跟抽象类一样，不能直接创建对象，但是我们也可以将接口实现类的对象以接口的形式去使用：
当做接口使用时，只有接口中定义的方法和Object类的方法，无法使用类本身的方法和父类的方法。
接口同样支持向下转型：
```java
public static void main(String[] args) {
Study study = new Teacher("小王", 27, "男");
if(study instanceof Teacher) { //直接判断引用的对象是不是Teacher类型
Teacher teacher = (Teacher) study; //强制类型转换
teacher.study();
}
}
```
这里的使用其实跟之前的父类是差不多的。
从Java8开始，接口中可以存在方法的默认实现：
```java
public interface Study {
void study();
default void test() { //使用default关键字为接口中的方法添加默认实现
System.out.println("我是默认实现");
}
}
```
如果方法在接口中存在默认实现，那么实现类中不强制要求进行实现。
接口不同于类，接口中不允许存在成员变量和成员方法，但是可以存在静态变量和静态方法，在接口中定义的变量只能是：
```java
public interface Study {
public static final int a = 10; //接口中定义的静态变量只能是public static final的
public static void test(){ //接口中定义的静态方法也只能是public的
System.out.println("我是静态方法");
}
void study();
}
```
跟普通的类一样，我们可以直接通过接口名.的方式使用静态内容：
```java
public static void main(String[] args) {
System.out.println(Study.a);
Study.test();
}
```
接口是可以继承自其他接口的：
```java
public interface A exetnds B {
}
```
并且接口没有继承数量限制，接口支持多继承：
```java
public interface A exetnds B, C, D {
}
```
接口的继承相当于是对接口功能的融合罢了。
最后我们来介绍一下Object类中提供的克隆方法，为啥要留到这里才来讲呢？因为它需要实现接口才可以使用：
```java
package java.lang;
public interface Cloneable { //这个接口中什么都没定义
}
```
实现接口后，我们还需要将克隆方法的可见性提升一下，不然还用不了：
```java
public class Student extends Person implements Study, Cloneable { //首先实现Cloneable接口，表示这个类具有克隆的功能
public Student(String name, int age, String sex) {
super(name, age, sex, "学生");
}
@Override
public Object clone() throws CloneNotSupportedException { //提升clone方法的访问权限
return super.clone(); //因为底层是C++实现，我们直接调用父类的实现就可以了
}
@Override
public void study() {
System.out.println("我会学习！");
}
}
```
接着我们来尝试一下，看看是不是会得到一个一模一样的对象：
```java
public static void main(String[] args) throws CloneNotSupportedException { //这里向上抛出一下异常，还没学异常，所以说照着写就行了
Student student = new Student("小明", 18, "男");
Student clone = (Student) student.clone(); //调用clone方法，得到一个克隆的对象
System.out.println(student);
System.out.println(clone);
System.out.println(student == clone);
}
```
可以发现，原对象和克隆对象，是两个不同的对象，但是他们的各种属性都是完全一样的：
通过实现接口，我们就可以很轻松地完成对象的克隆了，在我们之后的学习中，还会经常遇到接口的使用。
**注意：**以下内容为选学内容，在设计模式篇视频教程中有详细介绍。
> 克隆操作可以完全复制一个对象的所有属性，但是像这样的拷贝操作其实也分为浅拷贝和深拷贝。
>
> * **浅拷贝：**对于类中基本数据类型，会直接复制值给拷贝对象；对于引用类型，只会复制对象的地址，而实际上指向的还是原来的那个对象，拷贝个基莫。
> * **深拷贝：**无论是基本类型还是引用类型，深拷贝会将引用类型的所有内容，全部拷贝为一个新的对象，包括对象内部的所有成员变量，也会进行拷贝。
>
> 那么clone方法出来的克隆对象，是深拷贝的结果还是浅拷贝的结果呢？
>
> ```java
> public static void main(String[] args) throws CloneNotSupportedException {
> Student student = new Student("小明", 18, "男");
> Student clone = (Student) student.clone();
> System.out.println(student.name == clone.name);
> }
> ```
>
> 
>
> 可以看到，虽然Student对象成功拷贝，但是其内层对象并没有进行拷贝，依然只是对象引用的复制，所以Java为我们提供的`clone`方法只会进行浅拷贝。
***
## 枚举类
假设现在我们想给小明添加一个状态（跑步、学习、睡觉），外部可以实时获取小明的状态：
```java
public class Student extends Person implements Study {
private String status; //状态，可以是跑步、学习、睡觉这三个之中的其中一种
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
}
```
但是这样会出现一个问题，如果我们仅仅是存储字符串，似乎外部可以不按照我们规则，传入一些其他的字符串。这显然是不够严谨的，有没有一种办法，能够更好地去实现这样的状态标记呢？我们希望开发者拿到使用的就是我们预先定义好的状态，所以，我们可以使用枚举类来完成：
```java
public enum Status { //enum表示这是一个枚举类，枚举类的语法稍微有一些不一样
RUNNING, STUDY, SLEEP; //直接写每个状态的名字即可，最后面分号可以不打，但是推荐打上
}
```
使用枚举类也非常方便，就像使用普通类型那样：
```java
private Status status; //类型变成刚刚定义的枚举类
public Status getStatus() {
return status;
}
public void setStatus(Status status) {
this.status = status;
}
```
这样，别人在使用时，就能很清楚地知道我们支持哪些了：
枚举类型使用起来就非常方便了，其实枚举类型的本质就是一个普通的类，但是它继承自`Enum`类，我们定义的每一个状态其实就是一个`public static final`的Status类型成员变量：
```java
//这里使用javap命令对class文件进行反编译得到 Compiled from "Status.java"
public final class com.test.Status extends java.lang.Enum