标签: overloading

今天我在一个巨大的项目中遇到了一个有趣的情况 一个类有几个构造函数,它们用this()相互调用,最后会调用init(),build()等等.我想设置一个标志,然后调用this()和整个繁琐的过程,但调用this()它应该是第一个.

如何在不修改Contructor标头并设置标志的情况下修改此类中的代码？:)

我知道这听起来像是hackish,也许这不是在学校学到的,这就是为什么至少对我来说有趣.对于其他人来说在某些情况下也很有用.

这是一个基本的例子,我做了一些修改来模拟真正的问题,即init()方法. http://docs.oracle.com/javase/tutorial/java/javaOO/thiskey.html

public class Rectangle {
    private int x, y;
    private int width, height;
    private boolean flag;

    public Rectangle() {
      // execute code here, before this(), how?  -set the flag true for eg.
      this(0, 0, 0, 0);
    }
    public Rectangle(int width, int height) {
       // execute code here to, something different as above, before this(), how?   
       this(0, 0, width, height);
    }
    public Rectangle(int x, int y, int width, int height) {
        this.x = x;
        this.y = …

class Base{
//...
    public:
    int get()const{ // const
    // Do something.
     }
    int get(int x){
    // Do Someting.
     }

    //...

};
class Derived:public Base{
//....
     public:
     int get(){ // not const (not the same signature as the one is the base class) 
     //Dosomething
     }
      //...

};

我知道Derived类中的get()将隐藏Base类中的get()和get(int x)方法.所以我的问题是:
1)这是否意外超载或覆盖？
2)在派生类中使get()const会改变一些东西(隐藏或不隐藏Base类方法).

从c ++书中引用:

"当你打算覆盖它时,通过忘记包含关键字const来隐藏基类方法是一个常见的错误.const是签名的一部分,而离开它会改变签名,因此隐藏方法而不是覆盖它."

我有以下代码:

#include <iostream>
#include <vector>
using namespace std;

struct A{};
struct B: public A {};

template <typename T>
void foo(const T& obj) { cerr << "Generic case"<< endl;}

void foo(const A& a) {
    cerr << "Specific case" << endl;
}

int main() {
    vector<int> v;
    foo(v);
    B b;
    foo(b);
    A a;
    foo(a);
}

输出是

• 一般情况
• 一般情况
• 具体情况

为什么foo(const A& a)没有为B对象选择它？

奇怪的是,如果我删除了模板化方法并且只是具有以下内容:

#include <iostream>
#include <vector>

struct A{};
struct B: public A {};

//template <typename T>
//void …

我在Scala中加载构造函数时遇到了问题.每次我尝试为过载的CTOR传递值时,我都会收到错误

Example: 
    var client : Client = Client(*variable type List[String]()*);

 Unspecified value parameter clientList.    

我的目标是使用2种不同的数据类型创建对象.一个是NodeSeq,另一个是列表.从来没有.我是否过度加载了CTOR或者是否有更有效的方法来实现我的目标？

package api
import xml._

case class Client(clientNode: NodeSeq, clientList: List[String]) {

  def this(clientNode: NodeSeq) = this(clientNode, null)
  def this(clientList: List[String]) = this(null, clientList)

  var firstName: String
  var lastName: String
  var phone: String
  var street: String
  var city: String
  var state: String
  var zip: String
  var products = List[String]()
  var serviceOrders = List[String]()

  if (clientList == null) {
    firstName = (clientNode \\ "firstname").text
    lastName = (clientNode …

我在以下函数中遇到了这个错误.有谁知道它意味着什么？

template <class T>
void printAll(Array <T> &A){
    for(int i=0; i<31; i++){
        A.M[i].printObj; ///// ERROR
        std::cout<<std::endl;
    }
}

该函数应该打印我的所有对象..printObj因为我在类打印功能中测试了它.谢谢,有关我可能忘记的任何细节,请询问.

所以我在尝试在c ++中重载时遇到了这个问题:我有这些类:

class Data
{
public:
    void virtual f(){cout<<"In data!"<<endl;}
};

class A: public Data
{
public:
    void f(int x){cout<<"Class A int is: "<<x<<endl;}

};

然后我做:

Data *D=new A();
D->f(4);

我希望Data的f()函数可以做到A类的f()函数,因为我是虚拟的,但事实并非如此.

有什么方法可以使它工作？

我可以自己回答这个问题,写一个虚拟测试,但我想知道人们对这个问题的看法.这里是:

当我们同时重载和覆盖时,将调用哪种方法？我只考虑类型重载而不是arity重载和类型重载是相关的.

让我举个例子:

class AA {}
class BB : AA {}

class A {
    public virtual void methodA(AA anAA) { Console.Write("A:methodA(AA) called"); }
    public virtual void methodA(BB aBB) { Console.Write("A:methodA(BB) called"); }
}

class B : A {
    public override void methodA(AA anAA) { Console.Write("B:methodA(AA) called"); }
}

new B().methodA(new BB());     // Case 1
new B().methodA(new AA());     // Case 2
new B().methodA((AA)new BB()); // Case 3

你能说出案例1,2和3会发生什么吗？

我个人认为过载是邪恶的,并且没有一致的想法可以导致可预测的答案.这完全基于编译器+ vm中实现的约定.

编辑:如果您对过载是邪恶的原因有疑问,可以阅读Gilad Brach的博客文章

谢谢

我有以下设置:

class Base {};
class ImplA extends Base {};
class ImplB extends Base {};
class ImplC extends Base {};

Base baseFactory(int type) {
    switch(type) {
    case 0:
        return new ImplA();
    case 1:
        return new ImplB();
    case 2:
        return new ImplC();
}

Base a = baseFactory(0);
Base b = baseFactory(1);
Base c = baseFactory(2);


List<Base> list = new ArrayList<Base>();

list.add(a);
list.add(b);
list.add(c);

// Somewhere else I have:
interface BaseHandler {
    process(ImplA a);
    process(ImplB b);
    process(ImplC c);
};

现在,我希望能够做的是:

class Processor { …

我有需要的方法Collection<Object>,其中Object可以是一个String或CustomClass.然后它接受集合的每个元素并将其传递给具有如下参数的方法Object:

public void foo(Collection<Object> c) {
    for(Object o : c)
        bar(o);
}

public void bar(Object o) {
    if(o instanceof String || o instanceof CustomClass) {
        ...
    }
}

bar当我通过它正常工作String或CustomClass,但是当我试图通过一个NavigableSet<String>给foo我弄cannot find symbol; symbol : method foo(java.util.NavigableSet<java.lang.String>).

但是,如果我更改参数类型foo以Collection<String>它工作正常,但是这意味着我需要一个新的foo(Collection<CustomClass>),这将涉及到重复代码的方法.有没有解决的办法？

它是我不确定而不是问题的东西.这个代码我在测试中遇到过.我现在要把代码粘贴到这里.

static void count(String...obj){
     System.out.println(obj.length);
}

public static void main(String str[]){
    count(null,null,null);
    count(null,null);
    count(null);
}

程序运行良好,输出为3 2,在最后一次计数调用中它抛出一个零点异常(显然已经足够了).顺便说一下,测试中的问题是什么.无论如何,我无法理解什么样的函数参数(String ... obj).请有人帮帮我吧.