Java 多态性的有效使用？

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

它们最终都会写入文件，并公开一个公共方法：

write（）

，使用构造函数进行简单的依赖项注入

这就是它们的不同之处-1类接受特定类型的单个对象，而另一个类接受该对象类型的数组

这是多态性的有效案例吗？我认为可以，但实际上不应该

---

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

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

以下是一种简单易记的方法，说明何时使用what:
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
    }
}

---

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

以下是一种简单易记的方法，说明何时使用what:
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
    }
}

---

如果您只有两个

Write

方法，一个使用单个对象，另一个使用对象列表->我会将这两个方法放在同一个类上

如果每种类型都有一个

Write

，我会选择泛型

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

---

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

如果您只有两个

Write

方法，一个使用单个对象，另一个使用对象列表->我会将这两个方法放在同一个类上

如果每种类型都有一个

Write

，我会选择泛型

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

---

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

如果没有特定的代码示例，很难回答，但您所介绍的场景符合类似于装饰器模式的情况：

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

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

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

---

请注意，它并不是真正的装饰器，因为如果没有特定的代码示例，

XForCollection

不会继承

X

很难回答，但您所介绍的场景与装饰器模式类似：

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

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

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

---

请注意，它并不是真正的装饰器，因为

XForCollection

不会继承

X

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

例如：

启动器

    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;
    }
}

圆圈

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;
    }
}

---

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

例如：

启动器

    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;
    }
}

圆圈

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;
    }
}

---

将抽象泛型超类与公共内容一起使用

如果您想要写入类型为

ArgA

的参数的

WriterA

，以及写入类型为

ArgB

的参数的

WriterB

，您将

• 一个包含所有常用内容的摘要

  编写器

  ，以及一个抽象方法，如

  public void write（T arg）

• WriterA

  扩展

  Writer

• WriterB

  扩展

  Writer

---

将抽象泛型超类与公共内容一起使用

如果您想要写入类型为

ArgA

的参数的

WriterA

，以及写入类型为

ArgB

的参数的

WriterB

，您将

• 一个包含所有常用内容的摘要

  编写器

  ，以及一个抽象方法，如

  public void write（T arg）

• WriterA

  扩展

  Writer