标签: abstraction

用Java编程我几乎总是出于习惯,写下这样的东西:

public List<String> foo() {
    return new ArrayList<String>();
}

大多数时候甚至没有考虑过它.现在,问题是:我是否应该始终将接口指定为返回类型？或者建议使用接口的实际实现,如果是,在什么情况下？

很明显,使用界面有很多优点(这就是它的原因).在大多数情况下,库函数使用的具体实现并不重要.但也许有些情况确实很重要.例如,如果我知道我将主要随机访问列表中的数据,LinkedList那就不好了.但是如果我的库函数只返回界面,我根本就不知道.为了安全起见,我甚至可能需要将列表明确地复制到ArrayList:

List bar = foo();
List myList = bar instanceof LinkedList ? new ArrayList(bar) : bar;

但这看起来很可怕,我的同事可能会在自助餐厅里骂我.理所当然.

你们有什么感想？您的指导方针是什么？您何时倾向于抽象解决方案,何时会显示您的实施细节以获得潜在的性能提升？

我正在开发一个抽象类,其中实现类需要实现T的列表.问题是这不起作用:

public class AbstractClass
{
    public int Id { get; set; }
    public int Name { get; set; }

    public abstract List<T> Items { get; set; }
}

public class Container : AbstractClass
{
    public List<Widgets> Items { get; set; }
}

我确信有一个明显的答案,我缺少,我知道我可以构建一个抽象的基类型放入列表,但是当我使用我的Linq命令来构建列表时,抽象类型(ItemBase) )与.ToList()方法不能很好地配合.我正在努力做到这么独特吗？

define('anActionType', 1);
$actionTypes = array(anActionType => 'anActionType');
class core {
    public $callbacks = array();
    public $plugins = array();
    public function __construct() {
        $this->plugins[] = new admin();
        $this->plugins[] = new client();
    }
}
abstract class plugin {
    public function registerCallback($callbackMethod, $onAction) {
        if (!isset($this->callbacks[$onAction]))
            $this->callbacks[$onAction] = array();

        global $actionTypes;
        echo "Calling $callbackMethod in $callbacksClass because we got {$actionTypes[$onAction]}" . PHP_EOL;

        // How do I get $callbacksClass?

        $this->callbacks[$onAction][] = $callbackMethod;
    }
}
class admin extends plugin {
    public function __construct() {
        $this->registerCallback('onTiny', …

如何在数据库(没有特定的)中存储格式化的文本块(换行符,选项卡,列表等)以在Web上显示(XHTML),同时保持抽象级别,以便数据可以在其他数据中使用申请或网站的结构将来如何改变？

我从不同的文章中学习了Bridge模式,并且按照我的理解实现了它.令我困惑的一件事是桥模式说

BridgePattern将抽象与其实现分离,以便两者可以独立变化

这个陈述的含义是什么？实现是在单独的jar中吗？

什么是独立声明的含义？

考虑提供的journaldev文章,详细说明答案.

任何帮助是极大的赞赏.

首先,我认为这样做有些荒谬,但是我团队的其他成员坚持认为,除了"我认为这是愚蠢的"之外,我无法提出反对它的好论据......

我们要做的是创建一个完全抽象的数据层,然后具有该数据层的各种实现.很简单吧？输入实体框架4.1 ...

我们的最终目标是程序员(我尽力只留在数据层)永远不希望暴露于具体的类.除了显然需要实例化工厂之外,他们只想在代码中使用接口.

我希望实现以下内容:

首先我们有所有接口的"Common"库,我们称之为"Common.Data":

public interface IEntity
{
    int ID { get; set; }
}

public interface IUser : IEntity
{
    int AccountID { get; set; }
    string Username { get; set; }
    string EmailAddress { get; set; }
    IAccount Account { get; set; }
}

public interface IAccount : IEntity
{
    string FirstName { get; set; }
    string LastName { get; set; }
    DbSet<IUser> Users { get; set; } // OR IDbSet<IUser> OR [IDbSet implementation]?
}

public …

我有一个servlet,传递给查询参数,从DAO获取对象列表,将列表转换为JSON,并将其发送回响应中.每个列表都由具有方法的对象组成:

public String getAsJson(){...}

servlet有一堆看似简单的方法:

private String getUserListAsJson() {
    List<User> userList = this.dao.getUsers();
    StringBuilder builder = new StringBuilder();
    builder.append('[');
    // loops over the list appending the value of each objects getAsJson()
    builder.append(']');
    return builder.toString();
}

问题是我有大约6种方法(并且还在增长),除了不同的DAO查询外,它们看起来完全一样.我的想法是创建一个只有getAsJson()方法定义的接口,让每个bean实现它,然后在servlet中有另一个方法来接受实现该接口的对象.结束看起来像这样:

public Interface JsonEnabled {
    public String getAsJson();
}

public class User implements JsonEnabled {
    ....
    @Override
    public String getAsJson() {...}
}

public class TheServlet {
    ...
    private String getUserListAsJson() {
        List<User> userList = this.dao.getUsers();
        return this.getListAsJson(userList);
    }
    private String getListAsJson(List<? implements JsonEnabled> list) { …

我当前的应用程序允许用户通过一组管理屏幕定义自定义Web表单.它本质上是一个EAV类型的应用程序.因此,我无法硬编码HTML或ASP.NET标记来呈现给定页面.相反,UI从服务层请求Form对象的实例,而该服务层又使用多个RDMBS表构造一个.表单包含您希望在这样的上下文中看到的类:Form=> IEnumerable<FormSections>=>IEnumerable<FormFields>

以下是服务层的外观:

public class MyFormService: IFormService{

       public Form OpenForm(int formId){
          //construct and return a concrete implementation of Form 
       }
}

一切都很好(一段时间).UI对于给定表单中存在哪些部分/字段并不明智:它很乐意将它接收的Form对象呈现为功能性ASP.NET页面.

几周后,我从业务中得到了一个新的要求:当查看表单的不可编辑(即只读)版本时,某些字段值应该合并在一起,并且应该添加其他设计/计算字段.没问题,我说.只需修改我的服务类,使其方法更明确:

public class MyFormService: IFormService{

       public Form  OpenFormForEditing(int formId){
          //construct and return a concrete implementation of Form 
       }

       public Form  OpenFormForViewing(int formId){
          //construct and a concrete implementation of Form  
          //apply additional transformations to the form
       }
}

一切都很好,平衡已恢复到力量.用户界面仍然不知道表格中的内容,我们的关注点分离得以实现.然而,仅仅几个星期之后,该业务就提出了一项新要求:在某些情况下,我们应该只应用上面提到的一些表单转换.

在这一点上,感觉就像"显式方法"方法已达到死胡同,除非我想最终爆发一些方法(OpenFormViewingScenario1,OpenFormViewingScenario2等).相反,我引入了另一个间接层:

public interface IFormViewCreator{
        void CreateView(Form form);
}

public class MyFormService: IFormService{

       public Form …

让我说清楚一点.

我恨.CSS.

这是一场永无止境的噩梦.每一个小的布局变化都像一个黑客.问题的解决方案似乎经常涉及到像一些厨师试图弄清楚他将要在他即将成名的米饭布丁中放入多少肉豆蔻的数字.然后是多个浏览器问题,多个分辨率问题..

长话短说,这是一种痛苦.PITA,如果你愿意的话.

许多框架试图从HTML(自定义标签,JSF组件系统)中抽象出来,以便更容易处理特定的鱼群.

有没有人用过,有类似的概念应用于CSS？为你做一堆跨浏览器魔术的东西,支持变量(我为什么每次想要那种颜色时都要键入#3c5c8d),支持计算字段('编译'到CSS和JS中)等等.

或者,我是否正确地考虑过这个问题？我试图通过一个非常圆的洞推动一个非常方形的块？

在Stackers的推荐下,我一直在阅读Crockford的优秀Javascript:The Good Parts.

这是一本很棒的书,但由于其中很多都致力于描述使用Javascript基本功能的最佳方式,我不确定如何在不重复许多其他Javascript程序员的努力的情况下将他的建议付诸实践.

以这段话为例,例如:

创建新对象时,可以选择应该是其原型的对象.Javascript提供的机制是混乱和复杂的,但它可以大大简化.我们将create为该Object函数添加一个方法.该create方法创建一个使用旧对象作为其原型的新对象.

if (typeof Object.create !== 'function') {
 Object.create = function(o) {
  var F = function () {};
  F.prototype = o;
  return new F();
}

Run Code Online (Sandbox Code Playgroud)

我可以手动将此代码添加到我的所有Javascript项目中,但跟踪所有内容将是一个巨大的痛苦.

是否有任何库实现了Good Part的建议,从而省去了必须跟踪它们(/物理地将它们全部输出)的麻烦？