Java接口的艺术：探索接口特性与面向接口编程

在Java的世界里，接口（Interface）是一种强大的抽象机制，它定义了一组方法规范，但不实现这些方法。接口在Java编程中扮演着至关重要的角色，特别是在实现多态和面向接口编程（Interface-Oriented Programming, IOP）方面。本文将深入探讨Java接口的特性、接口实现多态的方式，以及面向接口编程的好处。

接口的特性

1. 完全抽象：接口中的方法默认都是抽象的，它不能包含实现（除非是默认方法或静态方法）。
2. 多继承：Java不允许类继承多个类，但允许一个类实现多个接口，从而实现多继承的特性。
3. 全局访问：接口中的所有方法默认都是public的，它们隐式地定义为public abstract。
4. 类型检查：接口可以作为引用类型，用于引用对象，提供了一种类型检查的机制。
5. 默认方法：从Java 8开始，接口可以包含默认方法，即带有实现的方法。
6. 静态方法：接口也可以包含静态方法，这些方法可以在不实例化接口的情况下直接调用。

package cn.zy.cellphone;
/**接口是一种引用数据类型。使用interface声明接口，形式* 形式:public interface 接口名称{}* 接口不能拥有构造方法，不能用于创建对象*接口可以多继承。一个接口可以继承多个其他接口*列如：public interface Broadcast extends Network，Picture{}*Broadcast接口就具备了A、B接口中定义的抽象方法。*/
public interface Broadcast {/**接口中可以声明属性。接口中定义的所有变量都是static final类型的。* public static final String version = "1.0";public int count = 10; // 默认是static final类型一般很少在接口中声明属性。*/

package cn.zy.cellphone;public interface Picture {
public void picture();//照相
}

package cn.zy.cellphone;public interface Network {
public void network();//网络
}

package cn.zy.cellphone;
/**一个类只能继承一个父类，同时实现多个接口。继承在前，实现在后。* public class Photo2 extends Photo implements Network,Picture,Broadcast {}* 实现类实现接口，必须实现接口中定义的抽象方法。*方法即行为，表示一种功能,接口定义了一套功能，实现类必须实现这些功能 –> 实现类的能力得到拓展。*/
//实现类（子类）
public class Photo2 extends Photo implements Network,Picture,Broadcast {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}public Photo2(String brand, String type, String name) {super(brand, type);this.setName (name);} /**接口中定义的一些系列方法表示的是一种种的能力。接口让实现类实现这些能力，实现类的能力得到拓展和升级。实现类根据自身特性实现接口中定义的方法。* 特殊情况:如果一个抽象父类定义了和接口同名的抽象方法，实现类实现的是抽象父类的抽象方法。*/public void broadcast() {System.out.println(this.getName()+"的手机可以播放");}public void picture() {System.out.println(this.getName()+super.getBrand()+super.getType()+"的手机可以照相");}public void network() {System.out.println(this.getName()+super.getBrand()+super.getType()+"的手机可以播放上网");    }/**实现类（子类）Photo2 手机原本只有下面几个功能，通过接口增加了上面几个功能* 实现类实现接口，必须实现接口中定义的抽象方法。*方法即行为，表示一种功能,接口定义了一套功能，实现类必须实现这些功能 –> 实现类的能力得到拓展。*/public void sendInfo() {System.out.println(super.getBrand()+super.getType()+"的手机发信息");            }public void call() {System.out.println(super.getBrand()+super.getType()+"的手机可以打电话");                }public void info() {System.out.println(super.getBrand()+super.getType()+"的手机可以发短信");}
}

package cn.zy.cellphone;
//实现类（子类）
public  class Photo1 extends Photo implements Broadcast {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}public Photo1() {super();
}public Photo1(String brand, String type,String name) {super(brand,type);this.setName(name);
}public void broadcast() {System.out.println(this.getName()+"的手机可以播放");
}public  void sendInfo(){System.out.println(super.getBrand()+super.getType()+"的手机发信息");}public void call(){System.out.println(super.getBrand()+super.getType()+"的手机可以打电话");}public void info(){System.out.println(super.getBrand()+super.getType()+"的手机可以发短信");}}

package cn.zy.cellphone;
//父类
public abstract class Photo {private String brand;private String type;public String getBrand() {return brand;}public void setBrand(String brand) {this.brand = brand;}public String getType() {return type;}public void setType(String type) {this.type = type;}public Photo() {super();}public Photo(String brand, String type) {super();this.brand = brand;this.type = type;}public abstract void sendInfo();public abstract void call();public abstract void info();
}

package cn.zy.cellphone;
//执行类
public class Test {
public static void main(String[] args) {// 同一引用类型Broadcast broadcast1=new Photo1("诺基亚","a01","张三");broadcast1.broadcast();Photo photo=new Photo1("诺基亚","a01","张三");photo.sendInfo();photo.call();photo.info();// 同一引用类型Broadcast broadcast2=new Photo1("苹果X","11S","李四"); broadcast2.broadcast();// 实例不同， 对同一方法的执行结果不同Picture picture1=new Photo2("苹果X","11S","李四");picture1.picture();Network network1=new Photo2("苹果X","11S","李四");network1.network();//多态Photo photo1=new Photo1("苹果X","11S","李四");photo1.sendInfo();photo1.call();photo1.info();/*** 接口实现多态: 接口类型 引用 实现类对象继 承实现多态: 父类类型 引用 子类对象接口定义的方法被实现类实现，通过接口引用实现类时，调用接口中的方法时，执行的是实现类实现的方法。实现类对象具备接口中定义的能力 是一种has a 关系子类对象是一种父类类型 是一种is a 关系                       现在的Photo1同Photo2既是实现类也是子类*/
}
}

面向接口编程
接口表示一种约定 (协议), 约定 (规范) 了实现类应该具备 (has a) 的能力。

理解:

=> 实现类必须实现接口中所有的方法，所以接口规范了实现类的行为

=> 接口约定了实现类应该具备的行为。

面向接口编程

所谓面向接口编程，在程序设计时，只关心实现类具备什么能力，而不关心实现类如何实现这个能力。面向接口编程时，面向接口的约定而不考虑接口的具体实现。

也就是说，面向接口编程时，接口的定义方只关系实现类是否具备接口所定义的能力，而实现类如何被的该能力接口定义方一点都不关心

//接口实现多态 电脑类（通过接口把3种零件组成电脑，而且零件随时可以更换）（cpu接口  4Hz  5Hz  。。。。（随时更换大小不同的cpu）  ）
                                                            （硬盘接口  3000GB  4000Gb（随时更换大小不同的硬盘））

（内存接口  30GB  40Gb（随时更换大小不同的内存））

package cn.computer;
//电脑
public class Computer {private Cpu cpu;                       //  预留cpu接口private Caliche caliche;                 // 预留硬盘接口private InternalStroage internalStroage;   //预留内存接口
public Cpu getCpu() {return cpu;
}
public void setCpu(Cpu cpu) {this.cpu = cpu;
}
public Caliche getCaliche() {return caliche;
}
public void setCaliche(Caliche caliche) {this.caliche = caliche;
}
public InternalStroage getInternalStroage() {return internalStroage;
}
public void setInternalStroage(InternalStroage internalStroage) {this.internalStroage = internalStroage;
}
public Computer() {super();
}
public Computer(Cpu cpu, Caliche caliche, InternalStroage internalStroage) {super();this.cpu = cpu;                         this.caliche = caliche;                    this.internalStroage = internalStroage;       
}//把各个部件通过接口组装成一个完整的电脑
public void print(String name) {System.out.println(name+"计算机");System.out.println("cpu："+getCpu().Hz());System.out.println("硬盘容量："+getCaliche().big2());System.out.println("内存容量："+this.getInternalStroage().big());
}}

package cn.computer;
//cpu接口
public interface Cpu {public String Hz();  //这是接口实现多态的形式：  public 你要返回的变量类型   方法名（）}

package cn.computer;
//实现类
public class Realize1 implements Cpu{public String Hz(){             // public 你要返回的变量类型   方法名（）return "3.8GHz";               //返回值}
}

package cn.computer;
//内存接口
public interface InternalStroage {public String big();
}

package cn.computer;
//实现类
public class Realize2 implements InternalStroage{public String big(){return "4GB";}}

package cn.computer;
//硬盘接口
public interface Caliche {public String big2();
}

package cn.computer;public class Test {
public static void main(String[] args) {Cpu cpu=new Realize1();     //把一种3.8Hz的cpu赋予给cpu接口Caliche caliche=new Realize3();   //把3000GB的硬盘赋予给硬盘接口InternalStroage internalStroage=new Realize2();     //把4GB的内存赋予给内存接口Computer computer=new Computer(cpu,caliche,internalStroage);    //把cpu，硬盘，内存给电脑类组合（地址）computer.print("华硕");                 //最后得到了完整的电脑}
}

抽象类和接口的异同比较

抽象类和接口都是引用数据类型，他们都不能创建对象。
他们都可以定义抽象方法，都可以实现多态。但是抽象类可以定义非抽象方法，而接口中定义的都是抽象方法。
抽象类和接口都具有传递性。抽象类是单根性（单继承），而接口是多继承。
在概念上，都可以重写抽象方法。子类重写抽象类，实现类实现接口
抽象类和子类解决的是模块内的问题（代码重用 , 重写 , 多态）而接口解决的是模块间的问题 => 高内聚，低耦合。接口可以用解耦模块。

接口实现多态

多态是面向对象编程的核心特性之一，它允许使用父类型来引用子类型的对象，并在运行时确定调用哪个子类型的方法是多态的关键。接口在实现多态中起到了桥梁的作用：

1. 通过接口引用不同类型的实现：可以创建一个接口类型的引用，指向实现了该接口的不同类的对象。
2. 方法覆盖：当接口的实现类覆盖接口中的方法时，就可以在运行时根据对象的实际类型调用相应的方法。
3. 动态绑定：Java虚拟机（JVM）在运行时根据对象的实际类型来动态绑定方法，这就是多态的实现机制。

面向接口编程的好处

面向接口编程是一种设计原则，它强调使用接口而不是具体的类来编程。这种方式带来了许多好处：

1. 解耦合：面向接口编程有助于降低系统各部分之间的耦合度，提高模块化。
2. 灵活性：通过接口，可以轻松替换实现，而不影响使用接口的代码。
3. 扩展性：新增实现类不会影响现有的代码，提高了系统的可扩展性。
4. 代码重用：接口定义了规范，不同的实现可以共享同一接口，从而实现代码重用。
5. 易于测试：面向接口编程使得编写单元测试更加容易，可以通过mock接口来测试代码。

实践面向接口编程

1. 定义清晰的接口：根据业务需求定义接口，而不是根据实现细节。
2. 优先使用接口：在编写代码时，优先考虑使用接口作为参数类型、返回类型和字段类型。
3. 实现类遵循接口：实现类应该严格遵循接口定义，不添加额外的方法。
4. 利用接口实现多态：通过接口来实现多态，使得代码更加灵活和可扩展。

结语

Java接口是实现多态和面向接口编程的强大工具。通过理解和运用接口的特性，Java程序员可以编写出更加灵活、可扩展和可维护的代码。面向接口编程不仅是一种技术实践，更是一种编程哲学，它引导我们关注抽象和规范，而不是具体的实现细节。掌握这些概念和技术，将使你的Java编程之路更加宽广。