Java 抽象类和接口以及抽象类和接口的区别

抽象类和接口以及抽象类和接口的区别。
类到对象是实例化。对象到类是抽象。

抽象类：
1、什么是抽象类？
类和类之间具有共同特征，将这些共同特征提取出来，形成的就是抽象类。
类本身是不存在的，所以抽象类无法创建对象（无法实例化）。
2、抽象类属于什么类型？
抽象类也属于引用数据类型。
3、抽象类怎么定义？
语法：
[修饰符列表] abstract class 类名{
类体;
}
4、抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。
子类继承抽象类，子类可以实例化对象
5、final 和 abstract 不能联合使用，这两个关键字是对立的。
6、抽象类的子类可以是抽象类，也可以是非抽象类。
7、抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。
8、抽象类关联到一个概念：抽象方法。什么是抽象方法？
抽象方法表示没有实现的方法，没有方法体的方法。例如：
public abstract void doSome();
抽象方法特点是：
特点1：没有方法体，以分号结尾。
特点2：前面修饰符列表中有 abstract 关键字。
9、抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中。
10、重要结论：一个非抽象的类继承抽象类，必须将抽象类中的抽象方法实现了。
这是 java 语法上强行规定的，必须的，不然 java 编译器就会报错。
这里的覆盖或者说重写，也可以叫做实现，对抽象的实现。
例：
abstract class T2{
// T2 t2 = new T2();报错，抽象类有构造方法，但不能被实例化
public T2() {
}
}
分析：
Animal 是父类，并且是 抽象的。
Animal 这个抽象类中有一个抽象方法 move()。

Bird 是子类，并且是 非抽象的。
Bird 继承 Animal 之后，会将抽象方法继承过来。
Bird 必须将从 Animal 中继承过来的抽象方法实现了。

面向抽象编程，不要面向具体编程，降低程序的耦合度，提高程序的扩展力。这种编程思想符合 OCP 原则。
OCP 原则：Open Closed Principle 开闭原则。
定义：Software entities like classes, modules and functions should be open for extension but closed fo modifications.
（一个软件实体如类，模块和函数应该对扩展开发，对修改关闭。）

闭合指转一圈后回到起点，工程中的闭合指 指令、资料等 完整的工作程序（循环）后返回发出位置。

java语言中凡是没有方法体的方法都是抽象方法，对吗？
不对，错误的。
Oject 类中就有很多方法都没有方法体，都是以“;”结尾的，但他们都不是抽象方法，
例如：
public native int hashCode();
这个方法底层调用了 C++ 写的动态链接库程序。
前面修饰符列表中没有：abstract。有一个 native。表示调用 JVM 本地程序。

常量：值不能发生改变的变量。

接口的基础语法：
1、类和类之间叫做继承，类和接口之间叫做实现。
继承使用 extends 关键字完成。
实现使用 implements 关键字完成。
2、当一个非抽象的类实现接口时，必须将接口中所有的抽象方法全部实现（覆盖、重写）。

接口和接口之间支持多继承，那么一个类可以同时实现多个接口吗？
对于计算机来说，一个机箱上有多个接口，一个接口是接键盘的，一个接口是接鼠标的，一个接口是接电源的，
一个接口是接显示器的. . . . . .
例：
interface X{
}
interface Y{
}
interface Z extends X, Y{ // 接口和接口支持多继承
}

重点：一个类可以同时实现多个接口。
java 中类和类支持单继承。实际上单继承是为了简单而出现的，现实世界中存在多继承，
java 中的接口弥补了单继承带来的缺陷。
实现多个接口，其实就类似于多继承。实现接口时必须将接口中的方法全部实现。
例：
interface K{
}
interface M{
}
class E implements M{
}
M m = new E();
// 接口和接口之间在进行强制类型转换的时候，没有继承关系，也可以强转。
// 但是一定要注意，运行时可能会出现 ClassCastException 异常。
// 编译没问题，运行有问题。
K k = (K)m;

接口 A 和接口 B 虽然没有继承关系，但是写代码的时候，可以互转。编译器没意见。
但是运行时可能出现：ClassCastException 类型转换异常

之前有一个结论：
无论向上转型还是向下转型，两种类型之间必须有继承关系，没有继承关系编译器会报错。
（这句话不使用在接口方面。）
最终实际上和之前还是一样，需要加：instanceof 运算符进行判断。
向下转型养成好习惯。转型之前先 if + instanceof 进行判断。

继承和实现都存在的话，代码应该怎么写？
extends 关键字在前。
implements 关键字在后。
接口通常提取的是行为动作。

接口的基础语法：
1、接口也是一种引用数据类型。编译之后也是一个 class 字节码文件。
2、接口是完全抽象的。（抽象类是半抽象。）或者也可以说接口是特殊的抽象类。
3、接口怎么定义，语法是什么？
[修饰符列表] interface 接口名{}
4、接口支持多继承。接口不能实现接口。
5、接口中只有常量+抽象方法。
6、接口中所有的元素都是 public 修饰的。
7、接口中抽象方法的 public abstract 可以省略。
8、接口中常量的 public static final 可以省略。
9、接口中方法不能有方法体。
10、一个非抽象的类，实现接口的时候，必须将接口中所有方法加以实现。
11、一个类可以实现多个接口。
12、extends 和 implements 可以共存，extends 在前，implements 在后。
13、使用接口，写代码的时候，可以使用多态（父类型引用指向子类型对象）。
14、接口没有构造方法
例：
interface T{
// 报错
public T() {
}
}
例：
interface i {
void move();
}
// 报错，接口不能实现接口
interface j implements i{

}

接口在开发中的作用：
注意：接口在开发中的作用，类似于多态在开发中的作用。
多态：面向抽象编程，不要面向具体编程。降低程序的耦合度。提高程序的扩展力。

接口在开发中的作用？
接口是不是完全抽象的？是。
而我们以后正好要求面向抽象编程。
面向抽象编程这句话以后可以修改为：面向接口编程。
有了接口就有了插拔。可插拔表示扩展力很强。不是焊接死的。

主板和内存条之间又插槽，这个插槽就是接口，内存条坏了，可以重新买一个换下来。
这叫做高扩展性。（低耦合度。）

接口在现实世界中是不是到处都是呢？
螺栓和螺母之间有接口
灯泡和灯口之间有接口
笔记本电脑和键盘之间又接口（USB接口，USB接口是不是某个厂家制定的协议/规范。）
接口有什么用？扩展性好。可插拔。
接口是一个抽象的概念。

分析：
中午去饭馆吃饭，这个过程中有接口吗？
接口是抽象的。
菜单是一个接口。（菜单上有一个抽象的照片：西红柿炒鸡蛋）
谁面向接口调用。（顾客面向菜单点菜，调用接口。）
谁负责实现这个接口。（后台的厨师负责把西红柿炒鸡蛋做好！是接口的实现者。）
这个接口有什么用呢？
这个饭馆的菜单，让“顾客”和“后厨”解耦合了。
顾客不用找后厨，后厨不用找顾客。他们之间完全依靠这个抽象的菜单沟通。

记住：以后凡是能够使用 has a 来描述的，统一以属性的方法存在。
但凡满足 is a 的表示都可以设置为继承。

Cat is a Animal，但凡满足 is a 的表示可以设置为继承。
Customer has a FoodMenu，但凡是满足 has a 的表示都以属性的形式存在。

总结一句话：三个字“解耦合”
面向接口编程，可以降低程序的耦合度，提高程序的扩展力。符合OCP原则。
接口的使用离不开多态机制。（接口+多态才可以达到降低耦合度。）

接口可以解耦合，解开的是谁和谁的耦合！！!
任何一个接口都有调用者和实现者。接口可以将调用者和实现者解耦合。
调用者面向接口调用。实现者面向接口编写实现。

以后进行大项目的开发，一般都是将项目分离成一个模块一个模块的，模块和模块之间采用接口衔接。降低耦合度。

is a （继承）、has a（关联） 、like a（实现）
is a ：
Cat is a Animal（猫是一个动物）
凡是能够满足 is a 的表示“继承关系”
A extends B

has a：
I has a Pen（我有一支笔）
凡是能够满足 has a 关系的表示“关联关系”
关联关系通常以“属性”的形式存在
A{
B b;
}

like a ：
Cooker like a FoodMenu（厨师像一个菜单一样）
凡是能够满足 like a 关系的表示“实现关系”
实现关系通常是：类实现接口。
A implements B

抽象类和接口有什么区别？
在这里我们只说一下抽象类和接口在语法上的区别。
至于以后抽象类和接口应该怎么进行选择，通过后面的项目去体会/学习。

抽象类是半抽象的。
接口是完全抽象的。

抽象类中有构造方法。
接口中没有构造方法。

接口和接口之间支持多继承。
类和类之间只能单继承。

一个类可以同时实现多个接口。
一个抽象类只能继承一个类（单继承）。

接口中只允许出现常量和抽象方法。