Java 类滥用 - 最佳实践

Question

我相当确定我没有正确地做一些与类相关的事情。

我正在使用一个类来创建一组变量(就像一个javascript对象，也许但不是真的(。

我正在使用它，如下所示(一个基本示例(

public class myScript {
    public static void main(String[] args) {
        Client   warehouse          = new Client();
        Contacts warehouseContactsA = new Contacts();
        Contacts warehouseContactsB = new Contacts();
        warehouse.idno = 1;
        warehouse.name = "warehouse";
        warehouse.desc = "I don't exist";
        warehouseContactsA.client_idno = 1;
        warehouseContactsA.email       = "[e-mail]"
        warehouseContactsB.client_idno = 1;
        warehouseContactsB.email       = "[e-mail]"            
        insertIntoDB(warehouse,
                     warehouseContactsA,
                     warehouseContactsB);
    }
    public static void insertIntoDB(Client   warehouse,
                                    Contacts warehouseContactsA,
                                    Contacts warehouseContactsB) {
        // code to insert into database here
    }
    private class Client {
        int      idno;
        String   name;
        String   desc;
    }
    private class Contacts {
        int      client_idno;
        String   email;
    }
}

是否有

任何理由不以这种方式使用类，如果是这样，是否有一种更简单的方法来存储/管理不需要类的数据？

Answer 1

创建内部类可能会给您带来陷阱。当您不将它们定义为静态时，它们需要对外部类的隐式引用，而您的代码不需要，它只会妨碍并导致模糊的错误。也许您这样做是为了只能编译一个类并避免使用构建脚本？使用 gradle 的简单构建脚本是微不足道的(不像我们使用 ant 的糟糕的过去(，所以这应该不是问题。最好将持久实体移到单独的文件中。

您对数据库连接和事务执行的操作尚不清楚。通常，尝试在自己的事务中执行每个插入是不好的，如果只是因为每个事务都有开销并且它增加了插入需要运行的时间。通常，您希望分批处理插入件。

不过，主要是，如果您正在编写脚本，请使用脚本语言。Groovy在这里可能是一个不错的选择：

• 过程脚本部分不需要外部类
• 可以在一个文件中定义多个公共类
• Groovy包含一个时髦的.sql API用于简化JDBC代码。

Answer 2

import java.util.Arrays;
import java.util.List;
public final class WarehouseRepository {
    public static void main(String[] args) {
        WarehouseRepository repository = new WarehouseRepository();
        Client warehouse = new Client(1, "warehouse", "I don't exist");
        Contacts warehouseContactsA = new Contacts(1, "[e-mail]");
        Contacts warehouseContactsB = new Contacts(1, "[e-mail]");
        repository.insertIntoDB(warehouse, Arrays.asList(warehouseContactsA, warehouseContactsB));
    }
    public void insertIntoDB(Client warehouse, List<Contacts> contacts) {
        // code to insert into database here
    }
}
final class Client {
    private final int id;
    private final String name;
    private final String desc;
    public Client(int id, String name, String desc) {
        this.id = id;
        this.name = name;
        this.desc = desc;
    }
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public String getDesc() {
        return desc;
    }
}
final class Contacts {
    private final int clientName;
    private final String email;
    public Contacts(int clientName, String email) {
        this.clientName = clientName;
        this.email = email;
    }
    public int getClientName() {
        return clientName;
    }
    public String getEmail() {
        return email;
    }
}

需要注意的一些事项：

1. 尝试根据类的意图和一些 Java 约定来命名类。例如，执行数据库操作的类通常称为repository
2. 除非需要，否则将类和变量设为最终结果。
3. 将字段设为私有，如果它们必须具有，则使它们成为构造函数参数，而不是公共或 getter/setter。
4. 如果可以有多个联系人与客户相关联，那么最好将List<Contact>作为客户端中的字段。

Answer 3

我会使用Map<String,String>来存储属性。我将字符串和整数存储为字符串并在需要时解析它们的地方。

希望对您有所帮助

Answer 4

是的，这是一个足够好的表示。

不，这并不理想。您可以更改一些内容来改善这种情况：

可见性选项 1：使用访问器将内容设为私有

您可以通过将"bean"类(即仅具有数据存储目的，没有逻辑的对象(字段私有，然后使用公共访问器来掩盖内部表示，从而使事情更加具有OO习惯

：

public class Client {
  private int id;
  public int getId() { return this.id; }
  public void setId(int id) { this.id = id; }
}

可见性选项 2：使您的 Bean 不可变

另一种选择是使您的 bean 不可变(这样您就可以在多线程环境中随意传递它们(，并保证它们已正确初始化并且没有人以非法状态写入它们(例如删除/清零 id 但不删除其余数据(：

public class Client {
  public final int id;
  public Client(int id) { this.id = id; }
}

最后，如果你有可能存在也可能不存在的东西(例如描述"我不存在"(，我建议使用 Optional 类型，而不仅仅是 String 类型。