小编gna*_*nat的帖子

我一直在做很多关于如何使用单例类在编程中成为不良实践的原因,因为隐藏的依赖性,难以测试等等.

我读过很多论坛帖子说你仍然可以维护单例的主要功能,只允许一个实例而不使用单例模式.

我想知道是否有人能给出一个实际的例子.很多帖子都建议使用工厂类来创建单例实例,其中清楚地显示了依赖关系.对我来说,这似乎只是采取多个单身人士并将它们组合成一个单一的工厂单身人士,这会产生同样的问题吗？

我们假设我们有以下类:

public class Message extends Object {}

public class Logger implements ILogger {
 public void log(Message m) {/*empty*/}
}

以及以下程序:

public static void main(String args[]) {
  ILogger l = new Logger();
  l.log((Message)null); // a)
  l.log(new Message()); // b)
}

Java编译器是否会删除语句a和b？在这两种情况下(剥离或不剥离),Java编译器的决定背后的基本原理是什么？

我需要在凹面(非凸面)内部多边形周围生成Voronoi图.我在网上寻找方法,但我无法弄清楚如何做到这一点.基本上,我生成点的凸包,计算双点并在这些点之间建立边缘网络.但是,当遇到内部多边形的边缘时,它必须看起来像形状的边缘,就像凸包一样.因此,通过这样做并剪切边界处的所有边缘,我应该得到一个Voronoi图,它具有内部多边形边界的良好边缘,并且没有位于内部多边形两侧的单元格.

让我给你举个例子:

这个问题是单元格穿过内部多边形边缘,并且单元格结构和多边形形状之间没有视觉关系.

有人知道如何解决这个问题吗？是否有一些算法已经做到这一点或接近我正在努力实现的目标？

非常感谢你的任何输入!

在处理面试问题时,我遇到了以下代码:

List<Object> list = new ArrayList();
Map<Object, ? super ArrayList> m = new HashMap<Object,  ArrayList>();
m.put(1, new Object());
m.put(2, list);

上面两个put方法都是抛出编译时错误.但是,当我添加m.put(3, new ArrayList());它时添加到map没有编译时错误.

我很清楚我可以添加new Object()一个值,HashMap因为map声明属于类型< ? super ArrayList>; 这意味着我可以补充一点,高于任何值ArrayList(即超级的ArrayList)和ArrayList下面反对过,但没有什么ArrayList.

这个特殊的概念在Kathy Sierra和Bert Bates的SCJP 6中写得非常好,基于该理论和实例,我认为它应该按照我的理解工作.有人可以帮我理解错误吗？

我正在尝试按照格式编写我的第一个客户Html Helper扩展方法

public static MvcHtmlString<TModel, TProperty>
    MyHelperFor(this HtmlHelper<TModel> helper, 
    Expression<Func<TModel, TProperty>> expression)

并且似乎有几种不同的方法来访问属性名称和值 expression

var body = expression.Body as MemberExpression;
var propertyName = body.Member.Name;
var propertyInfo = typeof(TModel).getProperty(propertyName)
var propertyValue = propertyInfo.GetValue(helper.ViewData.Model);

和

var metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
var propertyName = metadata.PropertyName;
var propertyValue = metadata.Model;

并且

TModel model = (TModel)helper.ViewContext.ViewData.ModelMetadata.Model;
TProperty value = expression.Compile().Invoke(model);

有人可以解释这些方法之间的区别吗？有没有一个优于其他人的情况？

我正在阅读J. Bloch的Effective Java,现在我正在继承vs组成部分.据我所知,他说继承并不总是好的.

子类中脆弱性的一个相关原因是它们的超类可以在后续版本中获取新方法.假设程序依赖于其安全性,因为插入到某个集合中的所有元素都满足某些谓词.这可以通过 继承集合并覆盖每个能够 添加元素的方法来保证,以确保在 添加元素之前满足谓词.这可以正常工作,直到在后续版本中将能够插入元素的新方法添加到超类中.

但为什么它不起作用？超类只是Collection接口,如果我们添加一个新方法,我们只是一个编译时错误.那不是有害的......

我在WebAPI控制器中有以下LINQ:

MyDate = i.Products.FirstOrDefault().Date

它按预期工作.但是,Products是一个集合,所以可以有很多日期.以上只选择第一个.

我真正想做的是找到最早的时间,并选择那个.

那怎么样？

我有两个具有相同数量元素的Python列表.第一个列表的元素是唯一的,第二个列表中的元素 - 不一定如此.例如

list1 = ['e1', 'e2', 'e3', 'e4', 'e5', 'e6', 'e7']
list2 = ['h1', 'h2', 'h1', 'h3', 'h1', 'h2', 'h4']

我想删除第二个列表中的所有"第一次遇到"元素及其第一个列表中的相应元素.基本上,这意味着删除所有唯一元素和重复项的第一个元素.通过上面的例子,应该是正确的结果

>>>list1
['e3', 'e5', 'e6']
>>>list2
['h1', 'h1', 'h2']

也就是说,元素'e1'被删除了,因为第一次遇到了相应的'h1','e2'被删除了,因为第一次看到'h2',因为'h1'已经'e3'了看到'e4'被删除了,因为第一次看到'h3','e5'被留下了因为'h1'已经被看到了,'e6'被留下了因为'h2'已经被看到了,'e7'被删除了因为'h4'是第一次出现.

什么是解决这个问题的有效方法？列表可能包含数千个元素,因此如果可能的话,我宁愿不复制它们或运行多个循环.

template<typename T>
struct a 
{ 
  using type = int;
  typename T::type i;
};

template<typename T, typename = a<T>>
void f1(T) {}

template<typename T, typename = typename a<T>::type>
void f2(T) {}

int main()
{
  f1<int>(1); // ok
  f2<int>(1); // error

  return 0;
}

实例化a<int>应该是错误,因为它int::type是非法的.但似乎f1<int>不能引起实例化a<T>,但f2<int>可以.什么原因？

我有一个帖子:

Thread t = new Thread(){
    public void run(){
        ServerSocketConnection scn = (ServerSocketConnection)
                Connector.open("socket://:1234");
        // Wait for a connection.
        SocketConnection sc = (SocketConnection) scn.acceptAndOpen();
       //do other operation
    }
};
t.start();

让我们说没有客户端连接到服务器,所以这个线程将被阻止.现在我想杀死上面的线程t？我怎么能杀了它？