小编Mik*_*378的帖子

我刚刚学习了BridgePattern及其意图:将抽象与其实现分离,以便两者可以独立变化.

但为什么不能AbstractFactory做同样的事情呢？

我知道一个AbstractFactory可以创建一个特定的桥梁,但我的问题涉及使用AbstractFactory而不是Bridge解耦抽象和实现.

你能解释一下AbstractFactory和BridgePattern 之间的真正区别吗？

我尝试使用另一种等宽字体(如Inconsolota)更改IntelliJ IDE的字体.

我在目录上放了Inconsolata.ttf(我用的是Windows):

   C:\Program Files\Java\jdk1.7.0_01\jre\lib\fonts

为什么IntelliJ不提供它？这是错误的道路吗？

(我确切地说,我已经检查过IntelliJ使用的是JDK,而不是另一个)

Java规范保证原始变量赋值总是原子的(期望long和双精度)types.

相反,对应于着名的增量操作的获取和添加操作i++将是非原子的,因为导致读 - 修改 - 写操作.

假设这段代码:

public void assign(int b) {
    int a = b;
}

生成的字节码是:

public void assign(int);
    Code:
       0: iload_1       
       1: istore_2      
       2: return 

因此,我们看到赋值由两个步骤组成(加载和存储).

假设这段代码:

public void assign(int b) {
        int i = b++;
}

字节码:

public void assign(int);
    Code:
       0: iload_1       
       1: iinc          1, 1    //extra step here regarding the previous sample
       4: istore_2      
       5: return 

知道X86处理器可以(至少是现代处理器)以原子方式操作增量操作,如上所述:

在计算机科学中,fetch-and-add CPU指令是一种特殊指令,它以原子方式修改存储器位置的内容.它用于在多处理器系统中实现互斥和并发算法,信号量的泛化.

因此,第一个问题:尽管字节码需要两个步骤(加载和存储),但是Java依赖于这样的事实:赋值操作是一个操作,无论处理器的体系结构如何都始终以原子方式执行,因此可以确保永久原子性(对于原始赋值) )在其规格？

第二个问题:用非常现代的X86处理器确认并且不跨不同架构共享编译代码是不对的,根本不需要同步 …

当我读到关于继承时,我总是对某个例子感到困惑.

通常有一个类似于下面例子的例子.

class Shape
{
public:
    Shape() {}
    virtual ~Shape  () {}
    virtual void Draw() = 0;
};

class Cube : public Shape
{
public:
   Cube(){}
   ~Cube(){}
   virtual void Draw();
};

Shape* newCube = new Cube();
newCube->Draw(); 

我的问题是,为什么Shape要自拔自拔？难道渲染器类不应该知道如何绘制形状而是为渲染器提供形状吗？如果我们想记录维度的变化怎么办？等等？我们是否有针对这些不同任务的方法Shape？

看到这样的众多例子有时让我想知道我将责任分配给班级的能力.有什么我不理解只有一个责任的课程吗？

正下方,的代码Iterator的++方法:

/** Concatenates this iterator with another.
       *
       *  @param   that   the other iterator
       *  @return  a new iterator that first yields the values produced by this
       *  iterator followed by the values produced by iterator `that`.
       *  @note    Reuse: $consumesTwoAndProducesOneIterator
       *  @usecase def ++(that: => Iterator[A]): Iterator[A]
       */
      def ++[B >: A](that: => GenTraversableOnce[B]): Iterator[B] = new Iterator[B] {
        // optimize a little bit to prevent n log n behavior.
        private var cur : Iterator[B] …

我目前正在使用最新的Ionic"nighty build"版本.

这个版本的一个好消息是缓存视图的概念:

默认情况下,会缓存视图以提高性能.当视图被导航离开时,其元素将保留在DOM中,并且其范围与循环断开连接.导航到已缓存的视图时,其范围将重新连接,并且留在DOM中的现有元素将成为活动视图.这也允许保持先前视图的滚动位置.

有意思,所以我尝试了它,它非常顺利.

但是,我遇到了一个严重的UX问题:

基本上,我的应用程序由2个选项卡组成.

• TabA旨在显示加载和列表项.
• TabB旨在显示其他项目.

每个人都有自己的导航:列出并显示特定项目.
显然,第一次,数据是新鲜的,但随后,自缓存=>陈旧.

缓存视图实际上适用于从特定选项卡的"显示"到"列表"的"后退"按钮.
实际上,滚动是维护的,控制器不需要重新加载=>非常好的性能.

但是,用户在单击特定选项卡时想要的是获取刷新列表.

我真的找不到一种非常有效的方法来刷新有关被点击元素的特定缓存视图.

我有那些声明的状态(显示TabA的示例):

        .state('tab', {
            url: "/tab",
            abstract: true,
            templateUrl: "/tabs.tpl.html",
            controller: 'TabsCtrl'
        })

        .state('tab.tabAList', {
            url: '/items',
            views: {
                'tab-a': {
                    templateUrl: '/tabAList.tpl.html',
                    controller: 'TabACtrl'
                }
            }
        })

        .state('tab.tabAShow', {
            url: '/tabAList/:itemId',
            views: {
                'tab-a': {
                    templateUrl: '/tabAShow.tpl.html',
                    controller: 'TabAShowCtrl'
                }
            }
        });

因此,tab"S控制器是家长tab.tabAList和tab.tabAShow.

tabList 包含如下函数:

$scope.reloadItems = function() {
    //...
}

tabA …

每当开发宝石时,我都没有看到为什么Gemfile没有直接检查依赖关系的原因.

确实,为什么要使用.gemspec文件来列出它们？有真正的好处吗？

我使用IDEA IntelliJ 12.0.2.

我的application-context.xml是:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:neo4j="http://www.springframework.org/schema/data/neo4j"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/data/neo4j http://www.springframework.org/schema/data/neo4j/spring-neo4j.xsd">

    <neo4j:config storeDirectory="../embeddedNeo4j"/>

    <context:spring-configured/>

    <context:annotation-config/>
    <context:component-scan base-package="models"/>

</beans>

我的测试类是:

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.neo4j.support.Neo4jTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"/application-context.xml"})
@Transactional
public class MyTest {

    @Autowired
    Neo4jTemplate template; //=> Could not autowire.No beans of Neo4jTemplate type found

    //my tests here
}

我错过了一些配置吗？

这似乎是Intellij的一个老问题:http://www.markvandenbergh.com/archives/260/autowiring-spring-bean-in-intellij/

IntelliJ 14中是否有一种方法可以显示特定文件的完整日志？

我的意思是:以git log --follow图形方式执行一种以查看旧版本; 在这些文件可能被重命名之前.

目前,当我在一个文件上执行Git => Show History时,它只显示相当于git log.

Bob克隆了该项目，并A从创建一个本地分支master。

鲍勃（Bob）添加了一些有用的帮助程序类，其中包括清理/重构单元测试设置，并清理所有现有测试。

Bob提交，推送到远程服务器，然后创建拉取请求，以便从John获得有关此重构的代码审查。

负责该项目的John忙了一个星期，因此无法立即进行审查。

在要求进行代码审查之后，Bob希望编写一些全新的测试文件和一组类，并以另一个单独的请求请求结束，因为它被视为正在使用一项新功能。
显然，鲍勃想使用他的新助手来处理这些测试文件。

采用哪种策略：

• 对于那些新的单元测试，鲍勃应该创建一个B来源于分支master，而不是A因为A还没有任何评价。缺点是他还不能使用单元测试助手，因为它不存在B。

• Bob应该等待第一个请求的代码审查，合并到master，然后B从派生master。在这段时间里，他应该专注于其他不依赖于先前的拉取请求的作品。

• 鲍勃应该B从A这些帮助者那里派生并使用这些帮助者，冒着A在审核后不被接受的风险。显然导致拒绝B。

• 约翰应该摇摇晃晃的屁股，并作为一个好的领导者，应该在短时间内审查第一个拉动请求，以便鲍勃可以串连。

处理一系列多个请求之间的依赖关系的良好做法是什么？