对面向接口编程的一点理解

合集下载

详解Java中的面向接口编程

详解Java中的面向接口编程

详解Java中的面向接口编程在Java编程中,面向接口编程是一种重要的编程思想和实践方式。

通过面向接口编程,我们可以实现代码的灵活性、可扩展性和可维护性。

本文将详细介绍Java中的面向接口编程,并探讨其优势和应用。

一、什么是接口?在Java中,接口是一种定义了一组方法的抽象类型。

接口可以看作是一种契约,规定了类应该具有的行为。

通过实现接口,类可以拥有接口定义的方法,并提供自己的实现。

在接口中,我们只定义方法的签名,而不包含具体的实现。

这使得接口成为一种非常灵活的编程工具,可以在不改变接口定义的情况下,实现不同的具体逻辑。

二、为什么要使用面向接口编程?1. 提高代码的灵活性通过面向接口编程,我们可以将程序的依赖关系从具体的实现类解耦,而是依赖于接口。

这样,当需要替换具体的实现类时,只需要修改依赖的接口即可,而不需要修改大量的代码。

这样可以提高代码的灵活性和可维护性。

2. 实现多态面向接口编程可以实现多态。

多态是指在父类或接口类型的引用变量中,可以指向不同子类或实现类的实例。

通过多态,我们可以编写通用的代码,而不需要考虑具体的实现类。

这样可以提高代码的复用性和扩展性。

3. 规范化编程接口定义了类应该具有的行为,通过面向接口编程,我们可以规范化编程。

当多个类实现同一个接口时,它们必须提供相同的方法,这样可以提高代码的一致性和可读性。

三、如何使用面向接口编程?1. 定义接口在使用面向接口编程之前,首先需要定义接口。

接口的定义使用`interface`关键字,例如:```javapublic interface Animal {void eat();void sleep();}```在上面的例子中,我们定义了一个`Animal`接口,规定了`eat()`和`sleep()`两个方法。

2. 实现接口接口只定义了方法的签名,不包含具体的实现。

因此,我们需要通过实现接口来提供具体的逻辑。

实现接口使用`implements`关键字,例如:```javapublic class Cat implements Animal {@Overridepublic void eat() {System.out.println("Cat is eating.");}@Overridepublic void sleep() {System.out.println("Cat is sleeping.");}}```在上面的例子中,我们定义了一个`Cat`类,实现了`Animal`接口,并提供了`eat()`和`sleep()`方法的具体实现。

面向对象编程的理解

面向对象编程的理解

面向对象编程的理解
面向对象编程是一种编程范式,它将程序中的数据和操作数据的方法组合成一个对象,通过对象之间的交互来实现程序的功能。

面向对象编程的核心思想是将现实世界中的事物抽象成对象,通过对象之间的交互来模拟现实世界中的行为。

面向对象编程的三大特征是封装、继承和多态。

封装是指将数据和操作数据的方法封装在一个对象中,只对外暴露必要的接口,隐藏内部实现细节,提高了程序的安全性和可维护性。

继承是指子类可以继承父类的属性和方法,从而减少了代码的重复性,提高了代码的复用性。

多态是指同一个方法可以根据不同的对象调用出不同的行为,提高了程序的灵活性和可扩展性。

面向对象编程的优点是代码的可读性和可维护性高,代码的复用性和扩展性强,程序的结构清晰,易于理解和修改。

面向对象编程的缺点是代码的复杂度高,需要花费更多的时间和精力来设计和实现程序,程序的性能也可能受到影响。

面向对象编程的应用范围非常广泛,包括桌面应用程序、Web应用程序、移动应用程序、游戏开发等领域。

在桌面应用程序中,面向对象编程可以实现图形界面的设计和实现,提高用户体验。

在Web 应用程序中,面向对象编程可以实现数据的处理和交互,提高网站的性能和可靠性。

在移动应用程序中,面向对象编程可以实现移动设备的特定功能,提高应用程序的用户体验。

在游戏开发中,面向
对象编程可以实现游戏的逻辑和交互,提高游戏的可玩性和趣味性。

面向对象编程是一种强大的编程范式,它可以帮助程序员更好地设计和实现程序,提高程序的可读性、可维护性、复用性和扩展性,是现代软件开发中不可或缺的一部分。

面向接口编程

面向接口编程

抽象类可以有实现的方法,也可以有未实现的方法;接口只有未实现的方法 类可以实现无限个接口,但仅能从一个抽象类继承
6 | Feature title | date
All Rights Reserved © Alcatel-Lucent 2006, #####
什么是面向接口编程 在系统分析和架构中,分清层次和依赖关系,每个层次不是直接向其上层提供 服务(即不是直接实例化在上层中),而是通过定义一组接口,仅向上层暴露 其接口功能,上层对于下层仅仅是接口依赖,而不依赖具体类。
遗传学家:人,猪,树都是生物,但和石头不一样:IDescendable
马列:所有都是物质(能被意识所反映的客观实在 ):IEsse
“面向接口编程”中的接口是一种思想层面的用于实现多态性、提高软件灵活 性和可维护性的架构部件,而具体语言中的“接口”是将这种思想中的部件具 体实施到代码里的手段
4 | Feature title | date
–交通工具定义成抽象类,汽车、飞机、轮船定义成子类,是可以接受的,因为汽车、飞 机、轮船都是 一种特殊的交通工具 –实现Icomparable接口的类必须要可以进行比较,这是一条规则。如果Car这个类实现了 Icomparable,只是说,我们的Car中有一个方法可以对两个Car的实例进行比较,可能 是比哪辆车更贵,也可能比哪辆车更大,这都无所谓,但我 们不能说“汽车是一种特 殊的可以比较”
– 如果一个类的实例必须使用另一个对象、而这个对象又属于一个特定的类,那么复用性 会受到损害。 如果“使用”类只需要“被使用”类的某些方法、而不是要求“被使用”类与“使用” 类有“is-a”的关系,就可以考虑让“被使用”类实现一个接口、“使用”类通过这个 接口来使用需要的方法,从而限制了类之间的依赖。 Client(客户)—使用实现了IndirectionIF的其他类。 InterdirectionIF(间接接口)—提供间接性,保证Client与Service之间的独立性。 Service(服务者)—实现IndirectionIF,为Client提供服务。

面向接口编程的好处

面向接口编程的好处

⾯向接⼝编程的好处⾯向接⼝编程⼀些好处:1.⼀个功能的调⽤者只需要关⼼如何使⽤此功能,⽽⽆须关注功能的实现。

如:如我们在main ⽅法中调⽤⼀个client程序,我们只需要Client client = new ClientImpl(),⽆论 ClientImpl 类中定义了多么复杂的成员函数和成员变量(包括javadoc),你都看不到,你也⽆须看到。

2.⾯向接⼝编程便于团队合作,有了统⼀的接⼝(接⼝是公开的,⾥⾯的⽅法都是public的),⽆须担⼼别⼈的程序⽆法使⽤我的实现(他根本就不关⼼)。

假如我们团队正在做⼀个计算器⼩程序,想要计算1+2+...+100=?,product manager 写了⼀个接⼝,让两个员⼯分别实现,他最后看那个程序算法算得快,于是这两个员⼯就对接⼝分别做了实现。

PM只需要写⼀个程序就可以评估他们的算法。

public int getTime(Interface in){int a = System.currentTime();in.run();return Sustem.currentTime()-a;}试想⼀下,如果没有接⼝,这个经理必须分别new这两个员⼯的class,然后调⽤可能不同的⽅法(A:run(), B:go())来运⾏。

3.(回答你的问题)接⼝的继承关注的是功能的扩展,⽽不是代码的修改。

class的继承就是功能性代码的增加。

两者关注的焦点不同。

本⼈观点:我个⼈认为,接⼝⼀旦设计好了,很少需要修改,除⾮业务逻辑或需求有较⼤变动。

多继承的⽤途(只是举个例⼦):如,SUN对⼀项技术写了⼀个规范如J2EE的JMS规范,很多vender在⾃⼰的应⽤服务器(如WebSphere, WebLogic, Jboss等)都要实现这⼀个规范,故且把这个规范叫做接⼝,每个vender想要对这个规范添加⾃⼰独特的功能,怎么办呢?就是⽤接⼝的继承,然后对继承了的接⼝做实现。

举个例⼦:public interface InterfaceA {public void method1();}public interface InterfaceB {public void method2();}public interface InterfaceAB extends InterfaceA, InterfaceB{public void method3();}public class InterfaceAImpl implements InterfaceA {@Overridepublic void method1() {System.out.println("The implemention of InterfaceA.");}}public class InterfaceBImpl implements InterfaceB {@Overridepublic void method2() {System.out.println("The implemention of InterfaceB.");}}public class InterfaceABImpl implements InterfaceAB {@Overridepublic void method1() {System.out.println("The implemention of InterfaceAB(method1).");}@Overridepublic void method2() {System.out.println("The implemention of InterfaceAB(method2)."); }@Overridepublic void method3() {System.out.println("The implemention of InterfaceAB(method3)."); }}public class Main {public static void main(String[] args) {InterfaceA a = new InterfaceABImpl();InterfaceB b = new InterfaceABImpl();InterfaceAB ab = new InterfaceABImpl();a.method1();b.method2();ab.method3();}}利⽤多态(向上转型),我们就可以达到不同vender间接⼝的统⼀。

面向接口编程

面向接口编程
7
实例
8
实例
public class MyClass { private Checker checker; public void setChecker(Checker checker){ this.checker = checker; } public void login(User user){ if (checker.isValidUser(user)) { System.out.println("User is logged in."); }else{ System.out.println("User is not logged in."); } } }
4
接口的典型应用
• Java Message Service (JMS)
– 43个接口。 – 2个类。
• java.sql
– 22个接口。 – 7个类。
Java EE 6
5
什么时候使用接口?
• 构建软件框架。 • 分离功能定义和功能实现。 • 降低组件之间的耦合度。
6
如何使用接口?
接口的典型应用形式
11
如果不使用接口?
• • • • • 难以进行软件架构的设计。 对象之间紧密耦合。 软件可扩展性差。 开发人员之间难以合作。 随着开发深入,编程工作陷入泥沼。
12
– 接口是方法定义和常量值的集合。
• 设计层面:
– 接口是功能定义的集合。 – 接口是面向对象系统中最抽象的元素。 – 接口是设计软件、构建软件框架的基本要素。源自2软件的认知与实现
• 对软件的理解过程
抽象 具体
• 软件的实现过程
接口 类
3
为什么要使用接口?

面向对象、面向接口、面向方法编程的区别?

面向对象、面向接口、面向方法编程的区别?

⾯向对象、⾯向接⼝、⾯向⽅法编程的区别?
其实不论是⾯向接⼝还是⾯向对象还是⾯向⽅⾯编程,只是设计模式的⼀种体现,⽤最简单的话来解释就是:
----------------------------------------------------------------------------
⾯向对象编程就是⼀堆对象,通过封装、继承、多态等更加有效的组织程序。

⾯向接⼝编程就是⼀堆接⼝,通过接⼝规约对象的属性和⽅法,是⾯向对象⼀部分。

⾯向⽅⾯编程把业务的主逻辑和次逻辑分开的⼀种思想。

⾯向对象不好解释,可以理解为以⼀切元素都是对象,在设计时以对象为单位,考虑它的属性及⽅法。

设计中采⽤了封装、继承、抽象的⼿法
⾯向接⼝本⾝就是⾯向对象的,⽆所谓区别,只不过⾯向接⼝的好处是耦合性低
⾯向⽅⾯Aspect-Oriented Programming (AOP)就是⼤名⿍⿍的AOP。

其实有点象struts⾥的拦截器。

举例:假设有在⼀个应⽤系统中,有⼀个共享的数据必须被并发同时访问,⾸先,将这个数据封装在数据对象中,称为Data Class,同时,将有多个访问类,专门⽤于在同⼀时刻访问这同⼀个数据对象。

为了完成上述并发访问同⼀资源的功能,需要引⼊锁Lock的概念,也就是说,某个时刻,当有⼀个访问类访问这个数据对象时,这个数据对象必须上锁Locked,⽤完后就⽴即解锁unLocked,再供其它访问类访问。

这种加锁与解锁的操作可以使⽤拦。

C#面向接口编程

C#面向接口编程

C#⾯向接⼝编程⾯向接⼝编程就是将对象中的某个功能提取出来作为接⼝,⽽功能的具体实现则交由继承⾃这个接⼝的实现类处理。

⾯向接⼝的好处是降低程序的耦合性,当有新的功能时只需要对新功能进⾏编写,不需要修改已有的代码下⾯是⼀个简单的范例:1//⽗类2public class Duck3 {4protected IFlyBehaviour flyBehaviour;5//可以动态修改对象的某⼀功能的实现6public void SetDuckFly(IFlyBehaviour fb)7 {8 flyBehaviour = fb;9 }10public void DuckFly()11 {12 flyBehaviour.Fly();13 }14 }1516//⼩鸭⼦类,继承鸭⼦类17public class LittleDuck : Duck18 {19public LittleDuck()20 {21 flyBehaviour = new SlowFly();22 }23 }2425//⼤鸭⼦类,继承鸭⼦类26public class BigDuck : Duck27 {28public BigDuck()29 {30 flyBehaviour = new QuickFly();31 }32 }3334//飞⾏为的接⼝,只定义了飞⾏的⽅法⽽未实现35public interface IFlyBehaviour36 {37void Fly();38 }3940//实现快速飞的⾏为类,继承了飞⾏接⼝41public class QuickFly : IFlyBehaviour42 {43public void Fly()44 {45 Console.WriteLine("飞⾏速度⾮常快");46 }47 }4849//实现慢速飞⾏的⾏为类,继承了飞⾏接⼝50public class SlowFly : IFlyBehaviour51 {52public void Fly()53 {54 Console.WriteLine("飞⾏速度⾮常慢");55 }56 }假设作为⽗类的鸭⼦类Duck具有飞⾏的功能,继承⾃它的两个⼦类⼤鸭⼦BigDuck飞得快,⼩鸭⼦LittleDuck飞的慢,通过⾯向接⼝的⽅式进⾏实现,⽽通过⽗类Duck中的SetDuckFly()⽅法,我们还可以在程序运⾏过程中动态的去修改某⼀功能执⾏:1 BigDuck bigDuck = new BigDuck();2 bigDuck.DuckFly();34 LittleDuck littleDuck = new LittleDuck();5 littleDuck.DuckFly();67 littleDuck.SetDuckFly(new QuickFly());8 littleDuck.DuckFly();结果:1飞⾏速度⾮常快2飞⾏速度⾮常慢3飞⾏速度⾮常快。

由最简单的例子理解接口的实例化和面向接口编程

由最简单的例子理解接口的实例化和面向接口编程

由最简单的例⼦理解接⼝的实例化和⾯向接⼝编程主要写写⾃⼰对接⼝实例化的理解:关于接⼝⼤家应该都清楚,类实现接⼝必须实现接⼝的所有⽅法,属性除外。

那么既然有类来实例化接⼝,那么为什么还要把类的实例转换为接⼝,也就是我们所说的接⼝的实例化。

这样⼀来⼀回岂不是多此⼀举,⾃找⿇烦?其实⾯向对象的概念⾥⾯推荐的⼀条就是⾯向接⼝编程,拿到接⼝的实例,我们不必关注类⽅法具体实现的细节,⾯向接⼝编程可以降低程序之间的耦合度,是指说在具体的调⽤处都是接⼝去进⾏的,并不依赖于具体的某⼀个类。

⽐如说定义了个I接⼝,有两个fun1,fun2⽅法。

然后有三个类实现了该接⼝:I i1 = new A();I i2 = new B();I i3 = new C();可以有很多个类实现了该接⼝,但当我们还没实例化的时候,我们可以I i直接拿来⽤,i.fun1,i.fun2可以提前编程,我们可以直接对i来进⾏编程设计,具体的取那⼀种实例由以后需求变化的时候我们⾃⼰选择,我的理解是:这样的好处叫做提前编程,我可以先把这个类(接⼝的实例),在他还没实例化的时候拿来⽤,以后等他具体实现了再给赋实例值,当然这种说法是我⾃⼰的理解。

其实⾯向接⼝编程⽤的地⽅⾮常多,有时候我们也经常写,绝对⽤到他了,只不过没注意罢了,由最简单⽤的最多的地⽅说说吧。

下⾯是最简单的⼀个点击Button事件import .wp.test1.R;import android.os.Bundle;import android.app.Activity;import android.view.Menu;import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;import android.widget.Toast;public class MainActivity extends Activity implements OnClickListener{private Button mBtn1;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_main);mBtn1 = (Button) findViewById(R.id.id_btn1);mBtn1.setOnClickListener(this);}@Overridepublic void onClick(View v) {switch (v.getId()) {case R.id.id_btn1:Toast.makeText(MainActivity.this, "id_btn1", Toast.LENGTH_SHORT).show();break;default:break;}}}setOnClickListener(this)这是我们经常写的⽅法吧,有时候还总会丢掉这句代码,来看看原理以后就不会漏了。

面向对象接口的概念

面向对象接口的概念

面向对象接口的概念
面向对象接口可以理解为一种特殊的类,由全局常量和公共的抽象方法所组成。

类是一种具体实现体,而接口定义了某一批类所需要遵守的规范,接口不关心这些类的内部数据,也不关心这些类里方法的实现细节,它只规定这些类里必须提供某些方法。

接口是一种规范,也是一种约束。

接口定义的基本语法是:[修饰符]
interface接口名[extends父接口1,父接口2]{零个到多个常量定义;零个到多个抽象方法的定义}。

接口就是用来被继承、被实现的,修饰符一般建议用public。

接口定义的内容全部都是常量和抽象方法,也一定有抽象的abstract,如果不写,系统会自动加上。

对面向对象编程的理解

对面向对象编程的理解

面向对象编程的理解1. 引言面向对象编程(Object-Oriented Programming,简称OOP)是一种编程范式,也是一种编程思维方式。

它通过将数据与对数据的操作封装在一起,以对象的形式来组织和管理程序,以解决复杂问题。

在面向对象编程中,我们以对象为基本单位,通过定义类来创建对象,从而实现程序的模块化、可重用、可维护、可扩展等优势。

面向对象编程的理念和方法已经广泛应用于各种编程语言和开发领域。

2. 核心概念面向对象编程有三个核心概念:封装、继承和多态。

2.1 封装封装是面向对象编程的基本特性之一,它将数据和操作数据的方法封装在一起,形成一个独立的对象。

通过封装,我们可以隐藏对象的内部实现细节,只暴露必要的接口给外部使用者。

这样可以提高代码的可读性和可维护性,同时也降低了对象之间的耦合度。

封装可以通过访问修饰符(如private、protected、public)来实现对属性和方法的访问控制。

private表示私有的,只能在类的内部访问;protected表示受保护的,只能在类的内部和子类中访问;public表示公开的,可以在任何地方访问。

2.2 继承继承是面向对象编程的另一个核心概念,它允许一个类派生出子类,子类会继承父类的属性和方法。

通过继承,子类可以复用父类的代码,并可以在此基础上添加新的特性或修改父类的行为。

继承可以实现代码的复用,减少冗余,提高开发效率。

继承分为单继承和多继承两种方式。

单继承表示一个类只能继承自一个父类,多继承表示一个类可以同时继承自多个父类。

继承可以通过关键字extends来实现。

多态是面向对象编程的另一个重要概念,它允许不同的对象对同一消息作出不同的响应。

简而言之,多态性是指在父类定义的方法在子类中可以有不同的实现。

多态有两种表现形式:编译时多态和运行时多态。

编译时多态是指方法的重载,即一个类中有多个同名方法,但参数列表不同。

运行时多态是指方法的重写,即子类对父类中的方法进行重写。

面向接口编程重点讲义资料

面向接口编程重点讲义资料

面向接口编程1.面向接口编程和面向对象编程是什么关系首先,面向接口编程和面向对象编程并不是平级的,它并不是比面向对象编程更先进的一种独立的编程思想,而是附属于面向对象思想体系,属于其一部分。

或者说,它是面向对象编程体系中的思想精髓之一。

2.接口的本质接口,在表面上是由几个没有主体代码的方法定义组成的集合体,有唯一的名称,可以被类或其他接口所实现(或者也可以说继承)。

它在形式上可能是如下的样子:interface InterfaceName{void Method1();void Method2(int para1);void Method3(string para2,string para3);}那么,接口的本质是什么呢?或者说接口存在的意义是什么。

我认为可以从以下两个视角考虑:1)接口是一组规则的集合,它规定了实现本接口的类或接口必须拥有的一组规则。

体现了自然界“如果你是……则必须能……”的理念。

例如,在自然界中,人都能吃饭,即“如果你是人,则必须能吃饭”。

那么模拟到计算机程序中,就应该有一个IPerson(习惯上,接口名由“I”开头)接口,并有一个方法叫Eat(),然后我们规定,每一个表示“人”的类,必须实现IPerson接口,这就模拟了自然界“如果你是人,则必须能吃饭”这条规则。

从这里,我想各位也能看到些许面向对象思想的东西。

面向对象思想的核心之一,就是模拟真实世界,把真实世界中的事物抽象成类,整个程序靠各个类的实例互相通信、互相协作完成系统功能,这非常符合真实世界的运行状况,也是面向对象思想的精髓。

2)接口是在一定粒度视图上同类事物的抽象表示。

注意这里我强调了在一定粒度视图上,因为“同类事物”这个概念是相对的,它因为粒度视图不同而不同。

例如,在我的眼里,我是一个人,和一头猪有本质区别,我可以接受我和我同学是同类这个说法,但绝不能接受我和一头猪是同类。

但是,如果在一个动物学家眼里,我和猪应该是同类,因为我们都是动物,他可以认为“人”和“猪”都实现了IAnimal这个接口,而他在研究动物行为时,不会把我和猪分开对待,而会从“动物”这个较大的粒度上研究,但他会认为我和一棵树有本质区别。

面向接口编程的理解-概述说明以及解释

面向接口编程的理解-概述说明以及解释

面向接口编程的理解-概述说明以及解释1.引言1.1 概述接口是指在程序设计中定义的一种抽象数据类型,它规定了一组方法的签名,而不需要提供具体实现。

在面向对象编程中,接口是一种约定,它定义了对象之间的通信方式和交互行为。

面向接口编程是一种编程思想,它鼓励程序员在设计程序时,关注对象的行为和能力,而不是关注对象的具体实现。

通过面向接口编程,我们可以将程序的不同部分解耦,实现高内聚、低耦合的设计。

面向接口编程的优势主要体现在以下几个方面:首先,面向接口编程提高了代码的可扩展性。

通过定义接口,可以明确规定对象的行为,使得程序的各个模块之间可以方便地进行替换和协同工作,当需要添加新功能或修改现有功能时,只需要实现相应的接口,而不需要修改已有的代码。

这大大降低了代码的耦合度,提高了代码的可维护性和可拓展性。

其次,面向接口编程提高了代码的复用性。

通过定义接口,可以将一组相关的功能定义在同一个接口中,并在不同的类中实现该接口。

这样,不同的类可以共享同一个接口,实现相同或相似的功能,大大提高了代码的重用性。

另外,面向接口编程提高了代码的可测试性。

由于接口定义了对象的行为,我们可以通过实现接口来模拟对象的行为,从而进行单元测试和集成测试。

通过针对接口进行测试,可以更方便地进行测试用例的编写和执行,提高了测试的可靠性和可重复性。

综上所述,面向接口编程是一种重要的编程思想,它通过定义接口来规范对象的行为,实现了代码的解耦、可扩展、可复用和可测试等优势。

在软件开发中,我们应该更加注重面向接口编程的实践,以提高代码的质量和可维护性。

1.2 文章结构本文将围绕“面向接口编程”的概念展开讨论,旨在深入探究面向接口编程的优势以及其在软件开发中的应用。

文章主要分为引言、正文和结论三个部分。

引言部分将给出有关“面向接口编程”的概述,通过介绍该概念的基本定义和背景,引起读者的兴趣。

正文部分将详细论述“面向接口编程”的概念。

首先,我们将解释什么是接口,包括接口的定义、特点和作用。

一篇带你入门面向接口编程

一篇带你入门面向接口编程

⼀篇带你⼊门⾯向接⼝编程⽂章的开头我们先来复习⼀下⾯向对象编程的⼏⼤特性:封装、继承、多态、抽象。

⽽⾯向接⼝编程是⾯向对象编程的⼀个重要⽅⾯。

它是上⾯提到的⾯向对象的四⼤特性和⼀些设计模式的基础。

然⽽并不是所有的编程语⾔都⽀持接⼝这⼀特性。

在不同的语⾔中对于抽象类和接⼝的⽀持程度也各有不同。

本⽂会⾸先介绍接⼝的使⽤意义,然后介绍接⼝与抽象类的区别和联系,最后再介绍C++和JAVA两⼤主流语⾔中对于接⼝和抽象类的⽀持情况。

1.接⼝的意义很多同学在⼀开始学习接⼝的时候并不明⽩为什么要有接⼝,教科书上的语⾔过于抽象以⾄于让⼈费解,案例⼜过于短⼩以⾄于不能体现接⼝的意义。

我在最开始学习接⼝的时候总是不知道如何使⽤它(当时没有接触过正经的项⽬),甚⾄于⼀度觉得不⽤接⼝不也可以实现功能吗?那么接⼝的价值体现在哪⾥呢?本⽂重点介绍接⼝的两⼤价值:1.将协议标准与⾏为解耦,对调⽤者⽽⾔可以屏蔽底层的实现。

2.定义好⼀种标准,使框架/系统更加易于扩展。

第⼆点可以理解为第⼀点的补充。

举⼀个⽣活中最常⽤的关于接⼝的例⼦:USB接⼝。

有⼈说你怎么举例的是⼀种硬件的接⼝呀?其实硬件的接⼝和我们代码⾥⾯的接⼝的含义是相似的,完全可以借助硬件上我们熟悉的接⼝来理解⾯向对象编程中的接⼝。

百度百科上对于USB是这样定义的:“USB,是英⽂Universal Serial Bus(通⽤串⾏总线)的缩写,是⼀个外部总线标准,⽤于规范电脑与外部设备的连接和通讯。

“这⾥我们可以看到,USB⾸先是⼀套标准。

也就是说,接⼝它是定义了⼀种标准。

甭管你是U盘还是硬盘,是机械硬盘还是SSD,只要您想通过USB与电脑通讯,您都要遵守并实现⼀套USB协议。

那对于电脑(调⽤者)来说,电脑不⽤关注U盘读取数据和硬盘读取数据的具体区别,它只需要按照USB接⼝这套标准来调⽤数据的提供者进⾏读取数据即可。

这样就把协议标准与⾏为进⾏了解耦,对调⽤者⽽⾔可以屏蔽底层的实现。

云计算技术与应用专业《面向接口编程》

云计算技术与应用专业《面向接口编程》
面向接口编程的意思是指在面向对象的系统中所有的类或者模块之 间的交互是由接口完成的。
第三页,共四页。
内容总结
接口的作用:面向接口编程。接口的作用:面向接口编程。接口是设计层面的概念,往往由 设计师设计,将定义与实现别离。程序员实现接口,实现具体方法。或者说,它是面向对象编程 体系中的思想精髓之一。面是由接口完成的
接口的作用:面向接口编程
第一页,共四页。
接口的作用
接口是设计层面的概念,往往由设计师设计,将定义与实现别离
程序员实现接口,实现具体方法
常见的类设计结构
接口 子接口 具体类
抽象类
第二页,共四页。
面向接口编程
面向接口编程和面向对象编程并不是平级的,它并不是比面向 对象编程更先进的一种独立的编程思想,而是附属于面向对象 思想体系,属于其一局部。 或者说,它是面向对象编程体系中的思想精髓之一。
第四页,共四页。

java面向接口编程的理解

java面向接口编程的理解

java⾯向接⼝编程的理解初学者可能在学习中会有很多疑惑,为什么要这样,明明可以那样实现,这样做的好处⼜是什么?可能会的⼈觉得很简单很容易理解,甚⾄可能觉得问的问题很智障,但对于⼩⽩来说可能是苦思冥想都不得其解的。

⾃⼰⾝为初学者也深知初学者的不易,很多问题⽹上没有很明确的答案。

⾃⼰遇到什么问题想出来后就写下,也为了便于后来⼈,毕竟前⼈种树后⼈乘凉。

初看容器时,有很多疑问,为什么都⽤接⼝作为类型去实现?(List<lnteger> l = new ArrayList<>())⽽不直接这样写?(ArrayList <Integer> i = new ArrayList<>())我说⼀下我这个初学者的理解,如有错误之处还望指出,不胜感谢!这时就可以把A接⼝看做是⼀种要完成的A功能的规范,实现它的A1类是完成A功能的⼀种⽅法,A2类也是完成A功能的⼀种⽅法。

然后再我们需要实现A功能时,我们需要根据具体情况的不同,采⽤不同的⽅法去实现这个功能。

这个思想更符合我们⽇常⾯向对象的思想,先想需要完成什么功能,再想怎么完成这个功能(根据当前情况选择合适的⽅法去完成)。

例如我这⾥需要存储有序的数据,那我们先想如何实现这个功能,当然是List接⼝。

然后根据我当前的具体情况再想,List接⼝下那个类更适合当前情况。

是数组(ArrayList),还是链表(LinkedList)⽅式存储?这需要结合这两种存放⽅式的优缺点和当前具体需求去决定。

举个更加通俗的例⼦:假如我定义⼀个接⼝的功能是去图书馆,我再定义⼏个实现该接⼝的类,有教学楼到去图书馆的类,有⾷堂去图书馆的类,还有寝室去图书馆的类。

然后我们思考时是先想做什么?去图书馆,这就确定了接⼝是去图书馆的接⼝。

然后我们再想怎么去,由于各个⼈的所在位置的不同,我们就需要根据当前所在位置的具体情况去调⽤合适的类,我在寝室就⽤寝室去图书馆的类,我在⾷堂就调⽤⾷堂去图书馆的类。

针对接口编程解释

针对接口编程解释

针对接口编程解释针对接口编程-问世间情为何物直教人生死相许应用场景举例:“十六年后在此重会;夫妻情深勿失信约”,悲痛欲绝的杨过跑到断肠崖,看到小龙女亲手留在石壁上的文字,即惊喜又痛苦不欲生:“十六年!为什么要等到十六年?!”。

但是信约已定,痴情的杨过也只能等十六年了。

离开断肠崖后,杨过一边开始了自己的苦苦的等待与思恋,一边寄情练功,当然开始时候也忘不了吃那疗伤的草药。

后来杨过巧遇了千年神雕,和神雕一见如故,从此便开始修炼独孤求败的武功。

无事可做,寄情练剑倒也不失为人生的一大快事。

“相思无用,唯别而已。

别期若有定,千般煎熬又何如?莫道黯然销魂,何处柳暗花明?!”,惊天地泣鬼神的黯然销魂掌就这样诞生了。

时光飞逝,恍惚间快过了十六年。

此时,杨过的神功已成,想象着十六年约期就将来临,心中想象着自己一生的挚爱,不免感慨和激动万分!在祭拜过求败他老人家之后,杨过和神雕一起开始去赴那场长达十六年之久的约会。

令众生激动和艳羡。

再出江湖的杨过惩奸除恶、帮扶弱小,很快就侠名远播,被人尊称为“神雕侠”。

自己心中想象着小龙女过往的一笑一颦,想象着她是怎么度过这十六年的,不禁催生了更加浓烈的相思和相见之情。

千呼万唤,终于,这一天来到!断肠崖边,佳人芳踪迹未现,过儿万念俱灰,纵身跳下悬崖…幸好悬崖下面是深渊,杨过并没有死,被水冲到了岸边的杨过苏醒过来后,看到了很多小蜜蜂,他一眼就认出了这是小龙女样的蜜蜂,莫非龙儿就在附近?最后在深潭水下,杨过找到了自己苦苦等待了十六年的挚爱。

原来小龙女得知自己无药可救,也纵身跳下断肠崖,十六年之期只不过是为了让杨过不要轻生。

但是跳崖后的小龙女并没有死掉,接着就在谷底一个世外桃源的地方慢慢的疗伤,竟然完全康复了。

真是有情人终成眷属,有情人终成名人。

定义:接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)。

项目开发过程中论“面向接口编程”的重要性

项目开发过程中论“面向接口编程”的重要性

项⽬开发过程中论“⾯向接⼝编程”的重要性刚刚领导了⼀轮新项⽬开发,在开发过程中⾄始⾄终坚持“⾯向接⼝编程”的原则,并基于此原则进⾏分⼯合作,最终较⾼质量的完成了代码编写过程。

总结项⽬过程,深味⾯向接⼝编程思想的重要性,个中滋味与君分享。

⾯向接⼝编程的好处之⼀是,可以站在全局⾓度俯瞰项⽬架构,对项⽬需求有更深层次的理解。

往常我们只归纳项⽬流程以及设计对象,但是对于接⼝的设计没有提前,算是做到哪再想有哪些接⼝,这样很有可能会在没有完全理解整体需求的情况下就开动,造成了后期调试的⿇烦和返⼯。

⾯向接⼝编程的另⼀个好处是,从横向将项⽬切割成⼀个⼀个的剖⾯,特别适合现在分层⽐较复杂且各层权责分明的项⽬架构。

各层之间的交互关⼼的其实是接⼝定义得如何,事先将接⼝确定下来,可以是项⽬⾻架趋于稳定,也可以降低开发中的风险和不可测。

⾯向接⼝编程还有⼀个好处是,使team leader能更好地把控项⽬的开发节奏。

在分⼯阶段,既可以按照功能模块和功能点分⼯,也可以按照层次之间进⾏分⼯。

例如,之前的项⽬开发中,曾经尝试过让不同⼈分别负责前端页⾯和后端服务开发,由于事先未定义好彼此间交互和通信的接⼝,并⾏开发到联调阶段发现,双⽅对于各⾃所需差异很⼤,联调耗时甚⾄⽐开发时间还长,得不偿失。

⽽事先定义好接⼝,甚⾄细化到url和接⼝的命名,参数和返回的类型,则⼤⼤缩短了联调的时间,最终联调时间仅占开发时间的五分之⼀不到,效果明显。

在单元测试阶段,由于接⼝固定,可以将各层的单元测试提前写好,节省了开发时间。

通过实际项⽬开发的实践,以及对过往项⽬开发的总结,可以深切体会到⾯向接⼝编程这种思想的好处。

接⼝者,通信协议也。

项⽬间协作和配合完全靠⼀个个清晰简约的接⼝实现。

沿着这些接⼝的脉络,能更好地提⾼团队开发效率,促进团队进步。

【设计模式】设计原则--面向接口编程你理解的对吗?

【设计模式】设计原则--面向接口编程你理解的对吗?

【设计模式】设计原则--面向接口编程你理解的对吗?最近看了《Head First Design Patterns》这本书。

正如其名,这本书讲的是设计模式(Design Patterns),而这本书的第一章,讲的是很重要的一些设计原则(Design Principles)。

•Identify the aspects of your application that vary and separate them from what stays the same.(识别应用程序中各个方面的变化,并将它们与保持不变的部分分开。

)•Program to an interface, not an implementation.(面向接口而不是实现编程。

)•Favor composition over inheritance.(优先考虑组成而不是继承。

)其中令我感触颇深的是,“面向接口而不是实现编程”颠覆了我一直以来的认识。

文章中示例代码为原书中截图,C#代码参照文末提供链接。

开始书中用了一个很形象的示例:模拟鸭子程序(SimUDuck)。

系统的最初设计使用标准的OO技术,并创建了一个Duck基类,所有其他Duck类型都继承自该基类。

设计系统时考虑到鸭子都会发出叫声,而且都会游泳,于是将Quack方法和Swim方法定义到Duck基类中并实现;此外,并不是所有的鸭子都是长得一样的,那么将Display方法在Duck基类中定义为抽象的,所有继承自Duck基类的子类编写自己的实现。

新的需求产生了!我们需要让系统中的鸭子可以飞。

从面向对象的角度来考虑,如果我们想要代码重用,只需要在Duck基类中添加方法Fly并实现它——所有的鸭子子类都是继承自Duck基类的——就实现了让鸭子飞的功能。

我们通过继承实现了代码重用,很轻松就解决了问题。

也许我们需要深入考虑一下,所有的鸭子都会飞吗?玩具橡胶鸭呢?我们把Fly方法的定义及实现放到了Duck基类中,所有继承自它的子类都继承到了Fly方法,其中也包括了不应继承Fly方法的子类。

为什么提倡面向接口编程

为什么提倡面向接口编程

为什么提倡面向接口编程为什么先行者们要提倡面向接口编程?要回答这个问题,我们先以一个反问作为开场:1. 如果不是接口,那是谁?在百度搜了一堆“为什么要面向接口编程”,最有道理的答案似乎是“方便维护和扩展”,因为“规范和实现分离”,比如JDK只定义了数据库的接口,各大厂商自己提供具体实现。

但实体类就不能做到这一点吗?比如顶级实体类提供空方法,具体实现类提供实现细节。

当然,这样做对子类的控制力会减弱,那用抽象类不可以吗?一个只定义了抽象方法的抽象类在本质上和接口是没有什么差别的。

肯定会有道友说,一个类可以实现多个接口,但只能继承一个抽象类。

没错,但这只不过是JAVA语言的一个特性而已,JAVA完全可以允许多继承,这样是不是接口就没有存在的意义了?换句话说,JAVA为什么要这样做?这样做的背后是不是因为遇到了什么实际的问题?要回答这个问题,有必要引出下一个问题:2. 接口和抽象类有什么区别?对于这个问题,相信绝大多数JAVA开发人员都可以回答出很多点,但我这里只说一点,相信这一点以前从来没有人说过:接口是不会被实例化的。

肯定有的道友会说,抽象类也不能被实例化呀?没错,但这是有前提的:抽象类本身并不能被使用者直接实例化,但被具体类继承后,就可以在具体类实例化的过程中被实例化了。

更直观的来说就是,子类可以使用super.xxx()调用抽象父类中的具体方法,但你无法用这种方式调用接口中的方法,即使是JAVA8之后接口中的default方法。

啰里啰唆说了这么多,你到底想说什么?3. 类继承所面临的问题终于要到正题了。

在先行者们的实践中发现,类继承有着一些无法避免的缺陷:3.1 父类的实现细节会影响子类的行为这看起来是一句废话,但如果父类具体实现细节的变化导致子类出现BUG了呢?要知道,封装可是面向对象最引以为傲的卖点之一,其一大目标就是:你不用管我的具体实现逻辑,只需要知道入参和返回值就行了。

但这个目标却被面向对象的另一引以为傲的卖点 -> 继承打破了。

相关主题
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
1.关于接口的理解。
接口从更深层次的理解,应是定义(规范,约束)与实现(名实分离的原则)的分离。
我们在一般实现一个系统的时候,通常是将定义与实现合为一体,不加分离的,我认为最为理解的系统设计规范应是所有的定义与实现分离,尽管这可能对系统中的某些情况有点繁烦。
接口的本身反映了系统设计人员对系统的抽象理解。
3.按照组件的开发模型(3C),它们三者相辅相成,各司一面,浑然一体,缺一不可。
面向对象是指,我们考虑问题时,以对象为单位,考虑它的属性及方法
面向过程是指,我们考虑问题时,以一个具体的流程(事务过程)为单位,考虑它的实现
接口设计与非接口设计是针对复用技术而言的,与面向对象(过程)不是一个问题
面向interface编程,原意是指面向抽象协议编程,实现者在实现时要严格按协议来办。面向对象编程是指面向抽象和具象。抽象和具象是矛盾的统一体,不可能只有抽象没有具象。一般懂得抽象的人都明白这个道理。 但有的人只知具象却不知抽象为何物。 所以只有interface没有实现,或只有实现而没有interface者是没有用的,反OO的。
if (instanceof BatteryPoweredMotor){...}
无论是哪种发动机,马力这个参数都很重要,所以在所有派生的抽象类(SolarPoweredMotor和BatteryPoweredMotor)中,getHorsepower()方法都有效。
现在销售部门又有了一种新的发动机,它是一种既有电驱动又有光驱动的双重驱动发动机。光驱动和电驱动的行为本身没有变化,但新的发动机同时支持两种行为。在考虑如何定义新型的光电驱动发动机时,接口和抽象类的差别开始显示出来了。新的目标是在增加新型发动机的前提下尽量少改动代码。因为与光驱动发动机、电驱动发动机有关的代码已经过全面的测试,不存在已知的Bug。为了增加光电驱动发动机,要定义一个新的SolarBatteryPowered抽象类。如果让SolarBatteryPowered从Motor抽象类派生,SolarBatteryPowered将不支持针对光驱动发动机和电驱动发动机的instanceof操作。也就是说,如果查询一个光电驱动的发动机是光驱动的,还是电驱动的,得到的答案是:都不是。
所以还是老老实实面向对象编程,面向协议编程,或者什么都不面向,老老实实编程。
但是我很讨厌讨论这样的术语,不如我们谈谈什么叫面向领导的编程?面向用户的编程?领导和用户有时都很BT,我们就面向BT编程?
选择Java接口还是抽象类
很多人有过这样的疑问:为什么有的地方必须使用接口而不是抽象类,而在另一些地方,又必须使用抽象类而不是接口呢?或者说,在考虑Java类的一般化问题时,很多人会在接口和抽象类之间犹豫不决,甚至随便选择一种。
销售部门的人要求每一个发动机都有一个称为马力的参数。对于他们来说,这是惟一值得关心的参数。基于这一判断,可以把发动机的行为定义为以表示马力的整数。
虽然现在还不清楚发动机如何取得马力这个参数,但可以肯定发动机一定支持这个行为,而且这是所有发动机惟一值得关注的行为特征。这个行为特征既可以用接口定义,也可以用抽象类定义。为了说明用抽象类定义可能出现的问题,下面用抽象类建立发动机的行为模型,并用Java方法描述行为1,代码如下:
}
如图1所示,SolarPoweredMotor和BatteryPoweredMotor都从Motor抽象类派生。在整个软件中,90%以上的代码以相同的方式对待所有的发动机。偶尔需要检查一下发动机是光驱动还是电驱动,使用instanceof实现,代码如下:
代码
if (instanceof SolarPoweredMotor){...}
在使用接口的同时仍旧可以使用抽象类,不过这时抽象类的作用是实现行为,而不是定义行为。只要实现行为的类遵从接口定义,即使它改变了父抽象类,也不用改变其它代码与之交互的方式。特别是对于公用的实现代码,抽象类有它的优点。抽象类能够保证实现的层次关系,避免代码重复。然而,即使在使用抽象类的场合,也不要忽视通过接口定义行为模型的原则。从实践的角度来看,如果依赖于抽象类来定义行为,往往导致过于复杂的继承关系,而通过接口定义行为能够更有效地分离行为与实现,为代码的维护和修改带来方便。
如果让SolarBatteryPowered从SolarPoweredMotor(或BatteryPoweredMotor)抽象类派生,类似的问题也会出现,SolarBatteryPowered将不支持针对BatteryPoweredMotor(或SolarPoweredMotor)的instanceof操作。从行为上看,光电驱动的发动机必须同时从两个抽象类派生,但Java语言不允许多重继承。之所以会出现这个问题,根本的原因在于使用抽象类不仅意味着定义特定的行为,而且意味着定义实现的模式。也就是说,应该定义一个发动机如何获得行为的模型,而不仅仅是声明发动机具有某一个行为。
interface关键字用来声明一个接口,它可以产生一个完全抽象的类,并且不提供任何具体实现。interface的特性整理如下:
1. 接口中的方法可以有参数列表和返回类型,但不能有任何方法体。
2. 接口中可以包含字段,但是会被隐式的声明为static和final。
3. 接口中的字段只是被存储在该接口的静态存储区域内,而不属于该接口。
UML里面所说的interface是协议的另一种说法。并不是指com的interface,CORBA的interface,Java的interface,Delphi的interface,人机界面的interface或NIC的interface。
在具体实现中,是可以把UML的interface实现为语言的interface,分布式对象环境的interface或其它什么interface,但就理解UML的interface而言,指的是系统每部分的实现和实现之间,通过interface所确定的协议来共同工作。
Java接口特性学习
在Java中看到接口,第一个想到的可能就是C++中的多重继承和Java中的另外一个关键字abstract。从另外一个角度实现多重继承是接口的功能之一,接口的存在可以使Java中的对象可以向上转型为多个基类型,并且和抽象类一样可以防止他人创建该类的对象,因为接口不允许创建对象。
行为3:查询光驱动发动机能够正常运转所需要的最小流明数,发动机返回一个整数。
再定义一个抽象类并把行为3转换成Java方法,代码如下:
代码
public abstract SolarPoweredMotor extends Motor{
abstract public int getLumensToOperate();
通过抽象类建立行为模型
在接口和抽象类的选择上,必须遵守这样一个原则:行为模型应该总是通过接口而不是抽象类定义。为了说明其原因,下面试着通过抽象类建立行为模型,看看会出现什么问题。
假设要为销售部门设计一个软件,这个软件包含一个“发动机”(Motor)实体。显然无法在发动机对象中详细地描述发动机的方方面面,只能描述某些对当前软件来说重要的特征。至于发动机的哪些特征是重要的,则要与用户(销售部门)交流才能确定。
行为2:查询电驱动发动机的充电时间,发动机将返回一个表示充电时间的整数。
用Java方法来描述这个行为,代码如下:
代码
public abstract BatteryPoweredMotor extends Motor{
abstract public int getTimeToRecharge();
接口应有两类:第一类是对一个体的抽象,它可对应为一个抽象体(abstract class);
第二类是对一个体某一方面的抽象,即形成一个抽象面(interface);
一个体有可能有多个抽象面。
抽象体与抽象面是有区别的。
2.设计接口的另一个不可忽视的因素是接口所处的环境(context,environment),系统论的观点:环境是系统要素所处的空间与外部影响因素的总和。任何接口都是在一定的环境中产生的。因此环境的定义及环境的变化对接口的影响是不容忽视的,脱离原先的环境,所有的接口将失去原有的意义。
面向接口编程
在一个面向对象的系统中,系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下,各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了;而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信,大到各模块之间的交互,在系统设计之初都是要着重考虑的,这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。
代码
public interface BatteryPoweredMotor extends Motor(){
public int getTimeToRecharge();
}
行为3:
代码
public interface SolarPoweredMotor extends Motor{
代码
public abstract Motor{
abstract public int getHorsepower();
}
在Motor抽象类的基础上构造出多种具体实现,例如A型发动机、B型发动机等,再加上系统的其它部分,最后得到1.0版的软件并交付使用。一段时间过去了,现在要设计2.0版的软件。在评估2.0版软件需求的过程中,发现一小部分发动机是电池驱动的,而电池需要一定的充电时间。销售部门的人希望能够通过计算机查阅充电时间。根据这一要求定义一个新的行为,如图1所示。
}
在销售部门的软件中,电驱动发动机也以类的形式实现,但这些类从BatteryPoweredMotor而不是Motor派生。这些改动加入到2.0版软件之后,销售部门很满意。随着业务的不断发展,不久之后光驱动的发动机出现了。销售部门要求光驱动发动机需要一定光能才能运转,光能以流明(Lumen)度量。这个信息对客户很重要,因为下雨或多云的天气里,某些光驱动发动机可能无法运转。销售部门要求为软件增加对光驱动发动机的支持,所以要定义一个新的行为。
相关文档
最新文档