java接口,接口的特性,接口实现多态,面向接口编程

时间:2023-03-08 17:38:17
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既是实现类也是子类
*/
}
} java接口,接口的特性,接口实现多态,面向接口编程

面向接口编程

接口表示一种约定(协议),约定(规范)了实现类应该具备(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 Realize2 implements InternalStroage{
public String big(){
return "4GB"; } }


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("华硕"); //最后得到了完整的电脑
}
} java接口,接口的特性,接口实现多态,面向接口编程

1.1.1.1 抽象类和接口的异同比较

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

相关文章