blocks|key|1232463|text|接口抽象在进行单元测试时很方便。它有助于模拟测试对象。它在TDD中非常有用，用于开发而不实际使用数据库中的数据。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1232464|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Interfaces abstraction are convenient when doing unit test. It helps for mocking test objects. It very useful in TDD for developing without actually using data from your database.

blocks|key|2642147|text|如果您不需要在Interface...then中找不到的类的任何特性，为什么不总是首选接口实现呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2642148|这将使您的代码在将来更容易修改，也更容易测试(模拟)。|2642149|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

If you don't need any features of the class that aren't found in the Interface...then why not always prefer the Interface implementation?

It will make your code easier to modify in the future and easier to test (mocking).

blocks|key|2642196|text|此外，在以下情况下使用接口|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2642197|2642198|多个对象需要以特定的方式操作，但本质上并不相关。也许您的许多业务对象都访问特定的实用程序对象，当它们访问时，它们需要提供对该实用程序对象的自身引用，以便该实用程序对象可以调用特定的方法。将该方法放在接口中，并将该接口作为参数传递给接口周围的实用工具object.|unordered-list-item|2642199|Passing，这对单元测试非常有帮助。即使您只有一种类型的对象使用特定的接口，因此不需要定义接口，您也可以定义/实现一个接口，以便在单元测试中"fake“该对象。|offset|length|2642200|有关前两个项目符号，请查看Observer+pattern和Dependency+Injection。我并不是说要实现这些模式，但它们说明了接口实际上是helpful.|2642201|Another的地方。这是为了实现几个SOLID+Principals，Open+Closed+principal和Interface+Segregation+principle。就像上一篇文章一样，不要为在任何地方严格实现这些原则而感到压力(至少现在是这样)，但使用这些概念可以帮助你将思考从对象的去处转移到更多关于契约和dependency|2642202|In的最后，让我们不要把它搞得太复杂:我们在.NET中处于一个强类型的世界。如果你需要调用一个方法或设置一个属性，但你传递/使用的对象可能是根本不同的，那么使用一个接口。|2642203|2642204|我要补充的是，如果你的代码不会被另一个库引用(至少在一段时间内)，那么在特定情况下是否使用接口的决定是你可以负责任地推迟的。如今，“提取接口”重构很容易做到。在我当前的项目中，我有一个正在传递的对象，我想也许我应该切换到一个接口；我并不为此而感到压力。|2642205|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Mock_object|1|http://en.wikipedia.org/wiki/Observer_pattern|2|http://en.wikipedia.org/wiki/Dependency_injection|3|http://en.wikipedia.org/wiki/Open/closed_principle|4|http://en.wikipedia.org/wiki/Interface_segregation_principle^0|0|0|0|21|4|0|0|D|G|1|U|K|2|0|10|L|3|1M|V|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1A|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|1B|8|@]|9|@$H|1C|I|1D|1|1E]]|A|$]]|$1|J|3|K|5|E|7|1F|8|@]|9|@$H|1G|I|1H|1|1I]|$H|1J|I|1K|1|1L]]|A|$]]|$1|L|3|M|5|E|7|1M|8|@]|9|@$H|1N|I|1O|1|1P]|$H|1Q|I|1R|1|1S]]|A|$]]|$1|N|3|O|5|E|7|1T|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1V|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1W|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]|10|$5|V|W|X|A|$Y|11]]|12|$5|V|W|X|A|$Y|13]]|14|$5|V|W|X|A|$Y|15]]|16|$5|V|W|X|A|$Y|17]]]]

Also, use interfaces when 

<ul>
<li>Multiple objects will need to be acted upon in a particular fashion, but are not fundamentally related. Perhaps many of your business objects access a particular utility object, and when they do they need to give a reference of themselves to that utility object so the utility object can call a particular method. Have that method in an interface and pass that interface to that utility object.</li>
<li>Passing around interfaces as parameters can be very helpful in unit testing. Even if you have just one type of object that sports a particular interface, and hence don't really need a defined interface, you might define/implement an interface solely to "<a href="http://en.wikipedia.org/wiki/Mock_object" rel="nofollow noreferrer">fake</a>" that object in unit tests.</li>
<li>related to the first 2 bullets, check out the <a href="http://en.wikipedia.org/wiki/Observer_pattern" rel="nofollow noreferrer">Observer pattern</a> and the <a href="http://en.wikipedia.org/wiki/Dependency_injection" rel="nofollow noreferrer">Dependency Injection</a>. I'm not saying to implement these patterns, but they illustrate types of places where interfaces are really helpful.</li>
<li>Another twist on this is for implementing a couple of the SOLID Principals, <a href="http://en.wikipedia.org/wiki/Open/closed_principle" rel="nofollow noreferrer">Open Closed principal</a> and the <a href="http://en.wikipedia.org/wiki/Interface_segregation_principle" rel="nofollow noreferrer">Interface Segregation principle</a>. Like the previous bullet, don't get stressed about strictly implementing these principals everywhere (right away at least), but use these concepts to help move your thinking away from just what objects go where to thinking more about contracts and dependency</li>
<li>In the end, let's not make it too complicated: we're in a strongly typed world in .NET. If you need to call a method or set a property but the object you're passing/using could be fundamentally different, use an interface.</li>
</ul>

I would add that if your code is not going to be referenced by another library (for a while at least), then the decision of whether to use an interface in a particular situation is one that you can responsibly put off. The "extract interface" refactoring is easy to do these days. In my current project, I've got an object being passed around that I'm thinking maybe I should switch to an interface; I'm not stressing about it.

blocks|key|134816|text|你已经有了正确的想法。我只想在这上面加几个注释...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|134817|首先，抽象并不意味着“接口”。例如，“连接字符串”是一种抽象，即使它只是一个字符串...这不是关于有问题的东西的“类型”，而是关于对那个东西的使用意图。|134818|其次，如果您正在进行任何类型的测试自动化，请寻找在编写测试时暴露出来的痛苦和摩擦。如果你发现自己必须为一个测试设置太多的外部条件，这是一个迹象，表明你需要在你的测试和它所交互的东西之间有一个更好的抽象。|134819|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

you have the right idea, already. i would only add a couple of notes to this... 

first, abstraction does not mean 'interface'. for example, a "connection string" is an abstraction, even though it's just a string... it's not about the 'type' of the thing in question, it's about the intention of use for that thing. 

and secondly, if you are doing test automation of any kind, look for the pain and friction that are exposed by writing the tests. if you find yourself having to set up too many external conditions for a test, it's a sign that you need a better abstraction between the thing your testing and the things it interacts with.

blocks|key|135550|text|我觉得你说得很好。这在很大程度上是一种风格上的东西。有一些我看过的开源项目，所有的东西都有一个接口和一个实现，这有点令人沮丧，但这可能会让迭代开发变得更容易一些，因为任何对象实现都可能中断，但虚拟对象仍然可以工作。但老实说，我可以通过继承来模拟任何不过度使用final关键字的类。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|135551|我会在你的列表中加上这一点:任何可以被认为是黑盒的东西都应该被抽象。这包括您提到的一些东西，但也包括毛发算法，这些算法可能有多个有用的实现，在不同的情况下具有不同的优势。|135552|此外，对于复合对象，接口经常派上用场。这是像java的swing库这样的东西做任何事情的唯一方法，但它对更普通的对象也是有用的。(我个人喜欢有一个像ValidityChecker这样的接口，可以通过and-compose或者or-compose从属ValidityChecker的方式。)|135553|entityMap^0|3L|5|0|0|22|F|3G|F|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|K|$]]

I think you've said it pretty well. Much of this will be a stylistic thing. There are open source projects I've looked at where everything has an interface and an implementation, and it's kind of frustrating, but it might make iterative development a little easier, since any objects implementation can break but dummies will still work. But honestly, I can dummy any class that doesn't overuse the <code>final</code> keyword by inheritance.

I would add to your list this: anything which can be thought of as a black box should be abstracted. This includes some of the things you've mentioned, but it also includes hairy algorithms, which are likely to have multiple useful implementations with different advantages for different situation.

Additionally, interfaces come in handy very often with composite objects. That's the only way something like java's swing library gets anything done, but it can also be useful for more mundane objects. (I personally like having an interface like <code>ValidityChecker</code> with ways to and-compose or or-compose subordinate <code>ValidityChecker</code>s.)

blocks|key|1232694|text|接口传递带来的大多数有用的东西都已经说过了。然而，我要补充的是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1232695|1232696|实现一个对象的接口，或后来的多个对象，强制所有实现者遵循相同的模式来实现与对象的协定。在某些语言中，您可以在接口本身上添加属性，这些属性可以不同于实际的对象实现属性，如|unordered-list-item|1232697|1232698|1232699|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|K|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|L|8|@]|9|@]|A|$]]|$1|F|3|-4|5|E|7|M|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|N|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|O|8|@]|9|@]|A|$]]]|I|$]]

Most of the useful things that come with the Interface passing have been already said. However I would add:

<ul>
<li>implementing an interface to an object, or later multiple objects, FORCES all the implementers to follow an IDENTICAL pattern to implement contract with the object. This can be useful in case you have not so OOP-experienced-programmers actually writing the implementation code.</li>
<li>in some languages you can add attributes on the interface itself, which can be different from the actual object implementation attribute as sense and intent</li>
</ul>

When do you encourage programming against an interface and not directly to a concrete class?

A guideline that I follow is to create abstractions whenever code requires to cross a logical/physical boundary, most especially when infrastructure-related concerns are involved.

Another checkpoint would be if a dependency will likely change in the future, due to possible additional concerns code (such as caching, transactional awareness, invoking a webservice instead of in-process execution) or if such dependencies have direct references to infrastructure integration points.

If code depends on something that does not require control to cross a logical/physical boundary, I more or less don't create abstractions to interact with those.

Am I missing anything?

When do you need to create abstractions in the form of interfaces?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

什么时候鼓励针对接口编程，而不是直接针对具体类进行编程？我遵循的一个指导原则是，每当代码需要跨越逻辑/物理边界时，都要创建抽象，尤其是当涉及到与基础设施相关的问题时。另一个检查点是，由于可能的额外关注点代码(例如缓存、事务感知、调用due服务而不是进程内执行)，或者如果这些依赖项直接引用基础设施集成点，依赖项可能会在未...

问什么时候需要以接口的形式创建抽象？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候需要以接口的形式创建抽象？EN