相关疑难解决方法(0)

经过一番调查后,我发现C++ 0x将元素向后存储在元组中.

例如,请使用以下代码:

std::tuple<char, char, char> x('\0', 'b', 'a');
char* y = (char*)&x;
std::cout << sizeof(x) << std::endl;
std::cout << y << std::endl;

使用GCC 4.5.2编译时,我得到以下输出:

3
ab

这最初困惑了我.为什么数据会向后存储？在通过GNU无意识混淆的标头搜索之后,我注意到实现类似于:

template<typename head, typename... tail> class tuple<head, tail...> : public tuple<tail...>
{
  head value;
  ...
};

因为基类包含最后一个元素,所以下一个派生类包含倒数第二个,等等,模板参数的实际顺序是相反的.

当我第一次进入元组时,我认为我可以将它们用于类似函数glInterleavedArrays(),它将顶点数据数组设置为颜色,纹理坐标,法线和点的元组.当然,如果我创建一个元组数组,这些数据必须反向输入,如果你碰巧忘记按正确的顺序放置参数,这可能会导致非常奇怪的错误.

那么这样的事呢？

template<typename... head, typename tail> class tuple<head..., tail> : public tuple<head...>
{
  tail value;
  ...
};

根据GCC 4.5.2:

std::tuple<char, char, char> x('\0', 'b', 'a');
char* y = (char*)&x;
std::cout << sizeof(x) << std::endl; …

我即将参加我的第一个面向对象编程课程的期末考试,但我仍然不了解多态性的概念.

假设我有一个抽象类"Vehicle",这个类有一个名为"Aircraft"的子类.我的问题是,这两个代码有什么不同？

Aircraft Jetplane = new Aircraft();

和

Vehicle Jetplane = new Aircraft();

我是一名初学者.我知道OOP的基础知识,但我还不知道"最佳实践".例如,一个继续出现在编程中的范例是"抽象工厂"设计模式,这似乎相当简单.其背后的一个关键意图是避免使用关键字"new",因为它被认为是有害的.我在编程课程中从未听过这个.有人可以详细阐述这一点吗？为什么我们要避免以这种形式实例化对象？

这是“如何在Java中实例化Queue对象？”的答案。，

Queue是一个接口。除了通过匿名内部类，您不能直接实例化接口。通常，这不是您要为集合执行的操作。而是选择一个现有的实现。例如：

队列q = new LinkedList（）;

要么

队列q = new ArrayDeque（）;

通常，您可以根据您感兴趣的性能和并发特性来选择集合实现。

这是如何运作的？接口Queue实施LinkedList意味着什么？

这是否意味着对象可以在FIFO中（先进先出顺序）出队，并且调用链表方法就q可以了？

我有一个列表列表,我想使用java Stream返回具有最小大小的列表.

这是我试过的:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Example {
   public static void main( String[] args )  {
         ArrayList<Integer> list1 = new ArrayList<>();
         list1.add(0);list1.add(2);list1.add(3);

         ArrayList<Integer> list2 = new ArrayList<>();
         list2.add(0);list2.add(2);list2.add(3);list2.add(4);

         System.out.println( getTheMinList(list1,list2).size());    
   }

   public static ArrayList<Integer> getTheMinList(ArrayList<Integer>... lists) {
         return Arrays.stream(lists)
                      .map(list->list.size())
                      /*here i stoped*/
                ;
   }
}

程序应该打印,3因为第一个列表具有最小大小.

请注意,我无法更改getTheMinList()的签名.有人可以给我一个提示吗？

大多数ј2ее(spring和JPA)类都设计有接口.除了继承任何技术原因有？像dynaimc proxy或aop,我需要更多技术细节

前

public interface UserDAO {
   void delete();
   void update();
   void save();
   List<User> get();
}

public class UserDAOImpl implements UserDAO {
   public void delete(){}
   public void update(){}
   public void save(){}
   public List<User> get(){}
}

当我遇到这段代码时,我正在阅读一篇博文:

<?php
include_once 'config.php';
class User
{
//Database connect 
public function __construct() 
{
$db = new DB_Class();
}

在评论中有人发布了以下内容:

永远不要在构造函数中初始化db连接

但与所有评论战士一样,他们从来没有给出理由？为什么这是错误的或不好的做法？

我在声纳上收到这个警告:

避免使用像'HashMap'这样的实现类型; 改为使用界面

这是什么意思？

我收到此警告的类如下:

class A {
   private HashMap<String, String> map=new HashMap<String, String>();

   //getters and setters

}

请,我想要适当的解决方案,以避免在声纳上发出警告.

在生产代码中,我经常看到如下定义的类:

public interface SomeComponent { // Some methods }
public class SomeComponentImpl implements SomeComponent { // Some methods}

public interface SomeComponentV2 extends SomeComponent { // Some methods }
public class SomeComponentV2Impl extends SomeComponentImpl implements SomeComponent { // Some methods }

为什么在这种情况下我们要分离接口及其实现？

或者这样说,为什么简单地有一个基类,让V2扩展/覆盖V1如下:

public class SomeComponent { // Some methods }
public class SomeComponentV2 extends SomeComponent 
{
  // Override methods for reimplementation
  // Add new methods for new features.
}

在下面的代码中,我有两种不同的方法来实例化类的对象B.

public interface A {}

public class B implements A {}

public static void main(String[] args)
{
    A test1 = new B();
    B test2 = new B();  
}

变量test1和test2有什么区别？
我何时应该使用Interface类型(type1)进行实例化,何时不应该？