传记文学的特点⼗⼀、JAVA接⼝的定义和使⽤
接⼝的基本概念：
我们知道知道java中只⽀持单继承，但如果我们想定义⼀些功能，想让⼀个⼦类都继承实现，显然没办法做到，所有Java提供了接⼝这个概念，这样我们就可以⽤⼀个⼦类去实现多个接⼝。我们可以理解为接⼝就是特殊的抽象类
在java8后，接⼝可以包括数据成员，但是数据成员必须是常量，其值⼀旦被初始化后，是不允许修改的，这些数据成员通常为全局变量。
为了避免在接⼝中添加新⽅法后要修改所有的实现类，接⼝中允许定义默认⽅法（default⽅法）。
定义接⼝需要使⽤关键字interface
定义接⼝实例：
interface A{ //定义⼀个接⼝
public static final String MESSAGE="HelloWorld"; //全局常量
en拼音怎么读资料员工作内容public abstract void print(); //定义抽象⽅法
default public void otherprint(){ //定义可以带⽅法体的默认⽅法
System.out.println("默认⽅法");
}
}
*注意：接⼝中成员属性默认是public static final修饰，成员⽅法是public abstact修饰，所以上述定义可以简写
代码演⽰：
interface A{ //定义⼀个接⼝
String MESSAGE="HelloWorld"; //全局常量
void print(); //定义抽象⽅法
default void otherprint(){ //定义可以带⽅法体的默认⽅法
无极色System.out.println("默认⽅法");
}
}
接⼝使⽤原则：
1.接⼝必须有⼦类，⼦类依靠implements关键字可以同时实现多个接⼝；
2.接⼝的⼦类（如果不是抽象类）必须实现接⼝之中的全部抽象⽅法；
3.接⼝可以利⽤对象多态性，利⽤⼦类实现对象的实例化
4.接⼝和普通的类⼀样，本⾝也有数据成员和⽅法，但数据成员⼀定要初始赋值，并且此值不能再有修改，定义的⽅法可以有抽象⽅法和默认⽅法，抽象⽅法abstact关键字可以省略，默认⽅法需要带上default关键字，默认⽅法可以带有⽅法体。
5.默认⽅法的调⽤和普通⽅法的调⽤⼀样
接⼝的使⽤：
我们来举个例⼦，定义⼀个抽象类People，⼀个普通⼦类Student，两个接⼝。⼦类Student继承⽗类People，并实现接⼝Study，Write
代码演⽰：
package demo;
//构建⼀个抽象类People
abstract class People{
//⽗类属性私有化
private String name;
private int age;
//提供⽗类的构造器
public People(String name,int age){
this.name = name;
this.age = age;
}
//提供获取和设置属性的getter()/tter()⽅法
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void tName(String name) {
this.name = name;
}
public void tAge(int age) {
this.age = age;
}
//提供⼀个抽象⽅法
public abstract void talk();
}
//定义⼀个接⼝
interface Study{
//设置课程数量为3
int COURSENUM = 3;
/
/构建⼀个默认⽅法
default void stu(){
System.out.println("学⽣需要学习"+COURSENUM+"门课程");
}
}
//再定义⼀个接⼝
interface Write{
//定义⼀个抽象⽅法
void print();
}
//⼦类继承People，实现接⼝Study,Write
class Student extends People implements Study,Write{
//通过super关键字调⽤⽗类的构造器
public Student(String name, int age) {
public Student(String name, int age) {
super(name, age);
}
//实现⽗类的抽象⽅法
public void talk() {
System.out.println("我的名字叫"+Name()+"，今年"+Age()+"岁");
}
//实现Write接⼝的抽象⽅法
五香牛肉酱
public void print() {
System.out.println("学⽣会写作业");
}
}
public class InterfaceDemo{
public static void main(String[] args) {
//构建student对象
Student student = new Student("dodo", 22);
//调⽤⽗类的抽象⽅法
student.talk();
//调⽤接⼝Write中的抽象⽅法
student.print();
//调⽤接⼝Study中的默认⽅法
student.stu();
}
}
代码讲解：上述例⼦结合了抽象类和接⼝的知识，内容较多，同学们可以多看多敲⼀下，学习学习。
接⼝的实现：类名 implements 接⼝名，有多个接⼝名，⽤“，”隔开即可。
接⼝的作⽤——制定标准
接⼝师表尊，所谓的标准，指的是各⽅共同遵守⼀个守则，只有操作标准统⼀了，所有的参与者才可以按照统⼀的规则操作。 如电脑可以和各个设备连接，提供统⼀的USB接⼝，其他设备只能通过USB接⼝和电脑相连
代码实现：
package demo;
interface USB
{
public void work() ; // 拿到USB设备就表⽰要进⾏⼯作
}
class Print implements USB //实现类（接⼝类）
{ // 打印机实现了USB接⼝标准（对接⼝的⽅法实现）
public void work()
{
System.out.println("打印机⽤USB接⼝，连接，开始⼯作。") ;
}
}
class Flash implements USB //实现类（接⼝类）
{ // U盘实现了USB接⼝标准（对接⼝的⽅法实现）
public void work()
{
System.out.println("U盘使⽤USB接⼝，连接，开始⼯作。") ;
}
}阵地战
class Computer
{
public void plugin(USB usb) //plugin的意思是插件，参数为接收接⼝类
妇女参政论者
{
usb.work() ; // 按照固定的⽅式进⾏⼯作
}
}
public class InterfaceStandards { public static void main(String args[]) { Computer computer = new Computer() ;
computer.plugin(new Print()) ; //实例化接⼝类， 在电脑上使⽤打印机 computer.plugin(new Flash()) ; //实例化接⼝类， 在电脑上使⽤U盘 }}
代码讲解：上述例⼦，就给我们展⽰了接⼝制定标准的作⽤，怎么指定的呢？看下⾯代码
class Computer
{
public void plugin(USB usb) //plugin的意思是插件，参数为接收接⼝类
{
usb.work() ; // 按照固定的⽅式进⾏⼯作
}
}
我们可以看到，Computer类⾥⾯定义了⼀个⽅法plugin()，它的参数内写的是USB usb，即表⽰plugin()⽅法⾥，接收的是⼀个usb对象，⽽打印机和U盘对象可以通过向上转型当参数，传⼊⽅法⾥。我们来重新写⼀个main⽅法帮助⼤家理解
代码演⽰：
public class InterfaceStandards
{
public static void main(String args[])
肥的成语{
Computer computer = new Computer() ;
USB usb = new Print();
computer.plugin(usb) ; //实例化接⼝类，在电脑上使⽤打印机
usb = new Flash();
computer.plugin(usb) ; //实例化接⼝类，在电脑上使⽤U盘
}
}
代码讲解：我们修改了主函数后，发现，使⽤了两次的向上转型给了USB，虽然使⽤的都是usb对象，但赋值的⼦类对象不⼀样，实现的⽅法体也不同，这就很像现实⽣活，⽆论我使⽤的是打印机，还是U盘，我都是通过USB接⼝和电脑连接的，这就是接⼝的作⽤之⼀——制定标准
我们来个图继续帮助⼤家理解⼀下：
上⾯的图：我们学习前⾯的章节多态可以知道对象的多态可以通过动态绑定来实现，即使⽤向上转型，我们知道类，数组，接⼝都是引⽤类型变量，什么是引⽤类型变量？引⽤类型变量都会有⼀个地址的概念，即指向性的概念，当USB usb = new Print()，此时usb对象是指向new Print()的，当usb = new Flash()后，这时候usb变量就会指向new Flash()，我们会说这是⼦类对象赋值给了⽗类对象usb，⽽在内存中，我们应该说，usb指向了new Flash();
这⾥我给⼤家推荐⼀个介绍堆和栈概念的博客，感兴趣的同学可以点击看⼀下
接⼝的作⽤——⼯⼚模式
⾸先我们来认识⼀下什么是⼯⼚模式？⼯⼚模式是为了解耦：把对象的创建和使⽤的过程分开。就是Class A 想调⽤ Class B ，那么A只是调⽤B的⽅法，⽽⾄于B的实例化，就交给⼯⼚类。
其次，⼯⼚模式可以降低代码重复。如果创建对象B的过程都很复杂，需要⼀定的代码量，⽽且很多地⽅都要⽤到，那么就会有很多的重复代码。我们可以这些创建对象B的代码放到⼯⼚⾥统⼀管理。既减少了重复代码，也⽅便以后对B的创建过程的修改维护。
由于创建过程都由⼯⼚统⼀管理，所以发⽣业务逻辑变化，不需要找到所有需要创建B的地⽅去逐个修正，只需要在⼯⼚⾥修改即可，降低维护成本。同理，想把所有调⽤B的地⽅改成B的⼦类C，只需要在对应⽣产B的⼯⼚中或者⼯⼚的⽅法中修改其⽣产的对象为C即可，⽽不需要找到所有的new B（）改为newC()。
代码演⽰：
