一、面向对象基本概念

Java是一种面向对象的语言，其中「对象」就相当于是现实世界中的一个个具体的例子，而「类」就相当于是一个抽象的模板，将抽象的概念模板转化为具体的例子的过程就叫做「实例化」。

比如说人这个概念就是一个抽象化的「类」，而中国人、英国人、日本人、以色列人等就是由人这个「类」具象化而来的「对象」。再比如说电器这个概念就可以看作是一个抽象化的「类」，而手机、冰箱、洗衣机、电脑等就可以看作是由电器这个类具象化而产生的一个个具体「对象」。

总结：对象是具体的例子，类是抽象的模板。我们通过将同类事物所共有的特点抽取出来，进而产生了类这个概念。

面向对象的优点：有了类这个概念，我们就可以大大提高代码的复用性，也就是说，只要我们先制作好了某一类事物的模板，下次再想创建同类的事物的时候，只要调用这个类进行创建，而不用再从头开始一步步进行创建，从而省去了大量的重复步骤。

二、面向对象中的「继承」

波兰Stefan Banach数学家说过这样一句话：

数学家能找到定理之间的相似之处，优秀的数学家能看到这些证明之间的相似之处，卓越的数学家能看到数学理论之间的相似之处。而最顶级的数学家能看到这些相似之处的相似之处。

通过面向对象这个概念，我们知道了可以对同类事物进行抽象，从而创建出「类」这一概念，但是这就结束了吗？从上面波兰数学家的话中我们可以发现，我们将同类事物进行抽象的过程只是进行了「一次抽象」。而实际上，我们还可以继续下去，我们还可以对已抽象过的概念再抽象一次，也就是进行所谓的「二次抽象」。

这种二次抽象的过程，在Java这种面向对象的编程语言也有与之类似的设定，称之为「继承」。

举例来说：我们从中国人、日本人、美国人、英国人这些概念中抽象出了「人类」这一概念，但是我们还可以继续下去。我们也可以从喜鹊、鹦鹉、大雁、秃鹫这些概念中抽象出「鸟类」这一概念。

接下来，我们将抽象过程再继续下去，我们可以从「人类」和「鸟类」这两个概念中再抽象出「动物」这一概念。那么我们现在就可以说「动物」这个概念是对「人类」和「鸟类」进行的一次抽象，而「人类」和「鸟类」又是对其所代表的基本对象进行的一次抽象。那么综合起来，「动物」这个概念就是对「人类」和「鸟类」所代表的基本对象进行了二次抽象。

那么在Java语言中，如果我们对某一类事物进行了一次抽象，那么就称这种被抽象出来概念为：类（class）。当我们再对这种被抽象过的概念进行二次抽象之后，一个新的概念出现了，我们称之为：父类（superclass），此时被父类直接抽象的那部分概念就称之为：子类（subclass）。

三、接口理解

刚才已经谈到了面向对象中的「子类」和「父类」的概念，下面就来谈一下一个新的概念，叫做「接口（interface）」。

那么如何理解「接口」这个概念呢？我们在编写程序的时候，有时候会有一些想法，或者说「规矩」，我们希望自己编写的类能够遵守某些「规矩」。有时候，我们希望某个类中一定要有某些功能，比如说，我们创建了一个「汽车类」，那么我们就希望所有的「汽车类」在创建的时候能够遵守这样一些规矩：

1. 必须有品牌属性（Field）
2. 必须有车型属性（Field）
3. 必须有行驶功能（Method）
4. 必须有刹车功能（Method）

这些规矩就是我们在创建类的时候必须要遵守，那么我们就可以将这些指导类的创建的规矩放在一个新的框架中，这个框架在Java中就叫做「接口（interface）」，以后当我们想要创建一个符合这些规矩的类的时候，就需要先引用这些「接口」。

总结一下：现在我们在创建子类的时候，可以从更抽象的父类那里「继承」过来一些属性和功能。与此同时，我们也在创建类的时候，也可以让这个类必须「符合某些规矩」。所以从这个层面上来说，「父类」这个概念和「接口」这个概念是同一级别的概念，子类直接「继承」父类的属性和方法，而子类也要「符合」接口定下的规矩才能进行创建，这二者都是对最基本的对象进行了「二次抽象」。

四、接口八股文

1.接口的作用

为什么需要接口?接口和抽象类的区别?

接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。

接口和抽象类的区别?：
1、接口只能定义抽象方法不能实现方法，抽象类既可以定义抽象方法，也可以实现方法。
2、单继承，多实现。接口可以实现多个，只能继承一个抽象类。
3、接口强调的是功能，具有什么能力。抽象类强调的是所属关系。
4、接口中的所有成员变量 为public static final（默认，变量也是属于全局变量）， 静态不可修改，当然必须初始化。接口中的所有方法都是public abstract 公开抽象的（public可不写）。而且不能有构造方法。抽象类就比较自由了，和普通的类差不多，可以有抽象方法也可以没有，可以有正常的方法，也可以没有。

5.Interface是为了把程序模块进行固化的契约,是为了降低偶合，abstractclass是为了把相同的东西提取出来,即重用

接口是两个模块之间通信的标准，通信的规范。如果能把你要设计的模块之间的接口定义好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。大家在工作以后，做系统时往往就是使用“面向接口”的思想来设计系统。

接口和实现类不是父子关系，是实现规则的关系。比如：我定义一个接口 Runnable， Car 实现它就能在地上跑，Train 实现它也能在地上跑，飞机实现它也能在地上跑。就是说， 如果它是交通工具，就一定能跑，但是一定要实现 Runnable 接口。

2.如何定义和使用接口

声明格式：

[访问修饰符] interface 接口名 [extends 父接口 1，父接口 2…] {
    常量定义；
    方法定义；
}

定义接口的详细说明：

• 访问修饰符：只能是 public 或默认。
• 接口名：和类名采用相同命名机制。
• extends：接口可以多继承。
• 常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。
• 方法：接口中的方法只能是：public abstract。 省略的话，也是 public abstract。

要点

1. 子类通过 implements 来实现接口中的规范。
2. 接口不能创建实例，但是可用于声明引用变量类型。
3. 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是 public 的。
4. JDK1.8（不含 8）之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法。
5. JDK1.8（含 8）后，接口中包含普通的静态方法、默认方法。

4.接口中定义静态方法和默认方法(JDK8)

JDK8 新特性_默认方法

Java 8 及以上新版本，允许给接口添加一个非抽象的方法实现，只需要使用 default 关键字即可，这个特征又叫做默认方法（也称为扩展方法）。 默认方法和抽象方法的区别是抽象方法必须要被实现，默认方法不是。作为替代方式， 接口可以提供默认方法的实现，所有这个接口的实现类都可以得到默认方法。

public class Test {
     public static void main(String[] args) {
         A a = new Test_A();
         a.moren();
     }
}

interface A {
     default void moren(){
     	System.out.println("我是接口 A 中的默认方法！");
     }
}

class Test_A implements A {
     @Override
     public void moren() {
     	System.out.println("Test_A.moren");
     }
}

JDK8 新特性_静态方法

JAVA8 以后，我们也可以在接口中直接定义静态方法的实现。这个静态方法直接从属于接口（接口也是类，一种特殊的类），可以通过接口名调用。

如果子类中定义了相同名字的静态方法，那就是完全不同的方法了，直接从属于子类。 可以通过子类名直接调用。

public class Test {
     public static void main(String[] args) {
         A.staticMethod();
         Test_A.staticMethod();
     }
}

interface A {
     public static void staticMethod(){
     	System.out.println("A.staticMethod");
     }
}

class Test_A implements A {
     public static void staticMethod(){
     	System.out.println("Test_A.staticMethod");
     }
}

5.接口的多继承

接口支持多继承。和类的继承类似，子接口 extends 父接口，会获得父接口中的一切。

interface A {
	void testa();
}
interface B {
	void testb();
}

/**接口可以多继承：接口 C 继承接口 A 和 B*/
interface C extends A, B {
	void testc();
}

public class Test implements C {
	public void testc() {
	}
	public void testa() {
	}
	public void testb() {
	}
}