相关疑难解决方法(0)

哪种类设计更好,为什么？

public class User
{
    public String UserName;
    public String Password;
    public String FirstName;
    public String LastName;
}

public class Employee : User
{
    public String EmployeeId;
    public String EmployeeCode;
    public String DepartmentId;
}

public class Member : User
{
    public String MemberId;
    public String JoinDate;
    public String ExpiryDate;
}

要么

public class User
{
    public String UserId;
    public String UserName;
    public String Password;
    public String FirstName;
    public String LastName;
}

public class Employee
{
    public User UserInfo;
    public String …

最近我在求职面试时被问到这个问题,我无法回答.那么,java.io中最常用的模式是什么？它是如何使用的？常见的Java库中使用的其他模式有哪些？

当我设计类并且必须在继承和组合之间进行选择时,我通常使用经验法则:如果关系是"is-a" - 使用继承,如果关系是"has-a" - 使用组合.

总是对的吗？

谢谢.

我试图弄清楚我对动作听众做错了什么.我正在关注多个教程,但是当我尝试使用动作监听器时,netbeans和eclipse会给我错误.

下面是一个简单的程序,我试图让按钮工作.

我究竟做错了什么？

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;


public class calc extends JFrame implements ActionListener {



    public static void main(String[] args) {

        JFrame calcFrame = new JFrame();

        calcFrame.setSize(100, 100);
        calcFrame.setVisible(true);

        JButton button1 = new JButton("1");
        button1.addActionListener(this);

        calcFrame.add(button1);
    }

    public void actionPerformed(ActionEvent e) {
        if(e.getSource() == button1)
    }  

}

动作监听器永远不会注册,因为if(e.getSource() == button1)它无法看到button1,错误说无法找到符号.

关于钻石问题的维基百科:

"......当两个B和C类继承自A,而D类继承自B和C时,钻石问题就会产生歧义.如果D中的方法调用A中定义的方法(并且不重写方法) ),B和C以不同的方式覆盖了该方法,然后从哪个类继承:B或C？"

所以钻石看起来像这样:

  A
 / \
B   C
 \ /
  D

我的问题是,如果没有这样的A类会发生什么,但B和C再次声明相同的方法,比如说foo().这不是同一个问题吗？为什么它被称为钻石问题？

例:

class B {
    public void foo() {...}
}

class C {
    public void foo() {...}
}

class D extends B, C {
}

new D().foo();

组成和继承.

我知道它们都是适当选择的工具,上下文在组合和继承之间进行选择时非常重要.然而,关于每个的适当背景的讨论通常有点模糊; 这让我开始考虑传统OOP的独特方面是多么明显的继承和多态.

多态性允许人们同等地指定"is-a"关系以及继承.特别是,从基类继承隐式地创建该类与其子类之间的多态关系.然而,尽管可以使用纯接口实现多态,但是继承通过同时传输实现细节使多态关系复杂化.通过这种方式,继承与纯多态性完全不同.

作为一种工具,继承通过简化在无关紧要的情况下重用实现,为程序员提供与多态(通过纯接口)不同的方式.但是,在大多数情况下,超类的实现细节与子类的要求略有冲突.这就是为什么我们有"覆盖"和"成员隐藏"的原因.在这些情况下,继承所提供的实现重用是通过在级联级别的代码中验证状态更改和执行路径的额外工作来购买的:子类的完整"扁平化"实现细节分布在多个类之间,这通常意味着多个文件,其中只有部分适用于相关的子类.在处理继承时,查看该层次结构是绝对必要的,因为如果不查看超类的代码,就无法知道哪些未覆盖的细节会对您的状态进行整理或转移您的执行.

相比之下,独占使用组合可以保证您可以看到哪些状态可以通过显式实例化对象进行修改,这些对象的方法可以自行调用.真正扁平化的实现仍然没有实现(实际上甚至不可取,因为结构化编程的好处是实现细节的封装和抽象)但是你仍然可以重用代码,你只需要在一个地方查看当代码行为不端时.

我的目标是在实践中测试这些想法,避免传统继承为基于纯接口的多态性和对象组合的组合,我想知道,

有什么对象组成和接口无法实现继承吗？

编辑

在迄今为止的回复中,ewernli认为一种技术没有技术专长,而另一种技术则没有; 后来他提到了每种技术固有的不同模式和设计方法.这是有道理的.但是,这个建议让我通过询问是否专用组合和界面代替传统继承来禁止使用任何主要设计模式来改进我的问题？如果是这样,在我的情况下是不是有相同的模式？

上下文:
受保护和公共类成员的继承是面向对象编程的基本概念.下面的简单示例说明了一个经常遇到的情况,其中类CDerived继承了类的所有公共成员,CBase并添加了自己的1个附加函数,而不更改或显式重新定义或重新定义类的任何公共成员CBase.

#include <stdio.h>

class CBase
{
public:
    char Arr[32];

    int Fn1(void) {
        return Arr[1] ^ Arr[sizeof(Arr)-1];
    }

    int Fn2(void) {
        return Arr[2] ^ Arr[sizeof(Arr)-2];
    }
};


class CDerived : public CBase
{
public:  
    int FnSum(void) {
        return Fn1() + Fn2();
    }
};

int main(void)
{
    CDerived ddd;

    printf("%d\n", ddd.Fn1());
    printf("%d\n", ddd.Fn2());
    printf("%d\n", ddd.FnSum());

    return (int)ddd.Arr[0];
};

上面的代码在所有主要编译器上编译都没有问题.

但是,如果希望" 模板化 "此代码,例如:通过参数化Arr数组的大小,那么CBase类模板的所有公共成员对CDerived符合最新C++标准的编译器上的类模板都是不可见的.
以下是问题代码:

#include <stdio.h>

template …

C++是一种多范式语言,STL和Boost是针对语言的功能范例而构建的.STL由容器(用于保存数据),迭代器(用于访问数据)和算法(用于操作数据的函数)组成.通过使用迭代器将算法函数应用于容器.作为副作用,这些方法不是容器类的一部分,而是完全独立的.(这避免了库编写者的冗余,但对于库用户来说却很痛苦.)

是否有STL/Boost的C++替代品,以更传统的面向对象的方式提供这样的容器？我正在寻找字符串,向量,链表,地图,树,哈希表等.容器应该易于继承和扩展.相比之下,从STL/Boost扩展类是一个非常糟糕的想法,这是他们的设计师的设计.

PS:请不要使用下面的回复空间来证明STL/Boost的优势.我很清楚他们!:-)

有了intellij的想法,我如何找出使变量可见的原因？

一个很难的例子:

• 假设你看class A,你看到一个变量something.如果你跳转到源代码,你会看到它的定义trait X.但你没有直接的extend特质X.那么,你使这个变量可见的是什么呢？如果您有一个深层嵌套的层次结构,跟踪可能很难.

任何建议或解决方案？

编辑:如果您喜欢此功能请求,请考虑投票:http://youtrack.jetbrains.com/issue/IDEA-124369

我把两个单独的程序放在一起,玩一个名为'Crazy Eights'的纸牌游戏.

我为这个程序编写的类基于一个默认的"card"包,它提供了扑克牌对象和扑克牌的一些通用方法.

我采取了两种不同的方法来实现这一点,这些方法本身都是功能性的.

这是两个UML类图,描述了两种方法:

继承子类'转换'方法

具有类似方法的组合子类

正如你在方法1中看到的,EightsCard类包含一个方法转换(Card)这里是方法:

  /**
   * Converts a Card into an EightsCard
   * @param card The card to be converted
   * @return The converted EightsCard
   */
   public EightsCard convert(Card card) {
     if (card != null) {
     EightsCard result = new EightsCard(card.getRank(), card.getSuit());
     return result;
     } 
     return null;
   }
 }

此方法允许您从CardCollection调用方法,否则这些方法将不合法.例如,在EightsPlayer类的play方法中如下所示:

  /**
   * Removes and returns a legal card from the player's hand.
   */
  public EightsCard play(Eights eights, EightsCard prev) {
    EightsCard ecard = new EightsCard(0, 0); …