Question

我有2个类执行非常类似的任务，但需要传递给它们的不同数据类型才能执行这些功能。

他们最终都写入文件并公开了一个公共方法：write()使用构造函数进行简单的依赖注入。

这是他们不同的地方--1个类接受特定类型的单个对象，而另一个接受该对象类型的数组。

这是多态的有效案例吗？我认为它可以但不应该是这样的吗？

如何正确处理这种情况，即2个或更多类执行非常相似的功能，但方式略有不同，至关重要的是，需要将不同的数据类型作为依赖项传递？

Answer 1

在这种情况下，您需要重载方法。一个用于单个对象，另一个用于多个对象。他们应该在同一个班级。

这是一种易于记忆的何时使用的方式：
1.重载是指你需要用不同的数据做同样的事情 2.覆盖是指您需要以不同方式使用相同数据执行相同的操作

public class FileWriter {

    public void write(File from){ // single file
        // magic logic
    }

    public void write(File... from){ // multiple files using varargs
        // magic logic
    }
}

Answer 2

如果您只有两个Write方法，一个采用单个对象，另一个采用对象列表 - ＆gt;我会把两种方法放在同一个类上。

如果每种类型都有一个Write，我会选择泛型。

引入基类不是我的第一选择，最好将常规内容提取到另一个类中，并从不同的类中使用它（has-a而不是is-a）。

多态性仅在您具有相同的方法签名但需要以不同方式执行操作时才有用。

Answer 3

如果没有特定的代码示例，很难回答，但您提供的场景与装饰模式类似：

class X
{
    public void doSomething(int number) { ... }
};

class XForCollections
{
    public XForCollections(X x) { ... }

    public void doSomething(int[] numbers) { ... }
};

请注意，它不是真正的装饰者，因为XForCollection不会继承X。

Answer 4

多态性 - 表示给定类型的单个变量用于引用对象的能力不同的类型，并自动调用特定于变量引用的对象类型的方法。在一个简而言之，多态是一种自下而上的方法调用。 多态的好处是很容易添加新的不破坏调用代码的派生对象类，它使用多态类或接口。当您向对象发送消息时，即使您不知道它是什么特定的类型，正确的事情发生了，那就是所谓的多态。使用的过程用于实现多态的面向对象编程语言称为 动态绑定 。

示例：

<强>启动

    private void init() {
        //client or calling code
        double dim = 5.0; //i.e. 5 meters radius or width
        List<Shape> listShapes = new ArrayList<Shape>(20);
        Shape s = new Circle();
        listShapes.add(s); //add circle
        s = new Square();
        listShapes.add(s); //add square
        getTotArea (listShapes,dim); //returns 78.5+25.0=103.5
        //Later on, if you decide to add a half circle then define
        //a HalfCircle class, which extends Circle and then provide an
        //area(). method but your called method getTotArea(...) remains
        //same. 
        }

    /** called method: method which adds up areas of various
     ** shapes supplied to it.
     **/
    public double getTotArea(List<Shape> listShapes, double dim){
        Iterator<Shape> it = listShapes.iterator();
        double totalArea = 0.0;
        //loop through different shapes
        while(it.hasNext()) {
            Shape s = (Shape) it.next();
            totalArea += s.area(dim); //polymorphic method call
        }
        return totalArea ;
    }
}

<强>形状

public abstract class Shape {
    protected abstract double area(double dim);
}

<强>方形

public class Square extends Shape{

    @Override
    protected double area(double dim) {
        return dim*dim;
    }
}

<强>环

public class Circle extends Shape{

    @Override
    protected double area(double dim) {
        return Math.PI*dim*dim;
    }
}

enter image description here

Answer 5

使用具有常见内容的抽象通用超类。

如果您希望WriterA写入类型为ArgA的参数，而WriterB写入类型为ArgB的参数，则您将

包含所有常见内容的摘要Writer<T>，以及public void write(T arg)
WriterA延伸Writer<ArgA>
WriterB延伸Writer<ArgB>

Answer 6

说你有这个：

class A{
    void write(int a){}
}

class B{
    void write(int[] a){}
}

既然你说这些方法的实现之间的差异很大，那么varargs可能不是一个合适的选择。为了简化操作，请执行以下操作::

class WriteStuff{
    void write(int a){}
    void write(int[] a){}
}

这可以让你的课程达到更高的凝聚力。多态性在这里并不是必需的。

然后再说一遍，这些信息真的太少了。您应该编写一些示例代码。

有效使用多态？

6 个答案: