处理特定项的唯一ID的java类>抽象还是非抽象？

Question

我对编程相当陌生，尤其是OOP概念。我创建了一个类，该类应该处理其他类对象的唯一ID。我只想给构造函数中的对象分配一个唯一的ID

我不知道IdHandler类是否应该是抽象的。据我所知，如果我需要不同的ID名称空间（可能是不同的仓库），我需要为每个ID创建一个IdHandler对象？我在哪里创建这些对象？在主类的开头或在定义名称空间的构造函数中（例如Warehouse()）

即ID类->

public class IdHandler {

    private String newId;
    private ArrayList<String> idList = new ArrayList<String>();


    public String getId() {

        this.newId = "";
        while (this.newId == "") {
            this.newId = UUID.randomUUID().toString();

            // if doesn't exist already , add to list, else empty String
            if (!this.idList.contains(this.newId)) {
                this.idList.add(this.newId);
                break;
            }

            else
                this.newId = "";
        }
        return this.newId;

    }
}

Answer 1

不清楚你的类是应该持有一个对象的ID，还是用来生成该对象将持有自己的唯一ID

按照您的代码，我假设您的类仅用于生成新ID。在本例中，您的类用作实用程序类。所以你不想把它抽象化。抽象的意思是“应该扩展”或者一个实用类不应该扩展，你可以把它设为final以避免子类

然后，您希望存储ID列表并将其共享给每个人，这样就不会重复使用ID。所以你必须让它静止。变量newId在每次调用getId（）时重置之后。所以你可以让它成为本地的方法。最后，将该方法设置为静态，这样它就不需要IdHandler的实例，所以调用该方法的每个人都可以使用相同的实例

在这种情况下，我认为可以将该方法重命名为getNewId()

public final class IdHandler {

    private static ArrayList<String> idList = new ArrayList<String>();

    public static String getNewId() {
        newId = "";
        while (newId == "") {
            newId = UUID.randomUUID().toString();

            // if doesn't exist already , add to list, else empty String
            if (!idList.contains(newId)) {
                idList.add(newId);
                break;
            }
            else
                newId = "";
        }
        return newId;
    }
}

并调用该方法：

public static void main() {
    String myId = IdHandler.getNewId();
}

---

编辑以下内容：

如果您想要为不同的对象使用不同的IdHandler。例如，您希望狗对象有一个ID处理程序，猫对象有一个ID处理程序。所以狗和猫可以有相同的ID，这不是问题，因为它们不是同一类的实例

您可以考虑为每个实例创建简单的IdHandler实例，但这并不是最好的，因为您必须将引用传递到要创建新ID的任何地方

相反，通过在类中创建一个引用IdHandler实例的静态字段，可以“隐藏”每种类型对象（换句话说，每个类）的IdHandler实例，一个在Dog中，一个在Cat中。通过这样做，每个类（狗或猫）都会有一个实例，您可以直接从类中访问它，因为它是静态的

首先修改IdHandler类以不保留静态字段，因为您不希望它们在dog实例和cat实例之间共享

公共类IdHandler{

    private ArrayList<String> idList = new ArrayList<String>();

    public String getNewId() {
        newId = "";
        while (newId == "") {
            newId = UUID.randomUUID().toString();

            // if doesn't exist already , add to list, else empty String
            if (!idList.contains(newId)) {
                idList.add(newId);
                break;
            }
            else
                newId = "";
        }
        return newId;
    }
}

然后在需要ID来引用IdHandler实例的类中添加一个静态字段

Public class Dog {
    public static final idHanlder = new IdHandler();

    private final id;

    public Dog(String id) {
        this.id = id;
    }

    public String bark() {
        return "waf!";
    }
}

public class Cat {
    public static final idHanlder = new IdHandler();

    private final id;

    public Cat(String id) {
        this.id = id;
    }

    public String Meow() {
        return "meow";
    } 
}

IdHandler将在创建类Dog（或Cat）时创建，并在Dog（或Cat）的所有实例之间共享。你可以直接从类狗（或猫）上访问它

public void main() {
    String dogId1 = Dog.idHandler.getNewId();
    Dog dog1 = new Dog(dogId1);
    String dogId2 = Dog.idHandler.getNewId();
    Dog dog2 = new Dog(dogId2);
    String catId1 = Cat.idHandler.getNewId();
    Cat cat1 = new Cat(catId1);
}

Answer 2

这取决于你是否想实例化你的类。 对于像IdHandler这样的类来说，抽象是没有意义的

抽象类的概念是，它们定义了继承类可以使用的公共字段和方法，但不应单独实例化

但是如果您使用的是UUID，那么整个IdHandler都是多余的。让一个类处理ID生成是个好主意。但实际上没有必要将它们保存到列表或检查它们是否在该列表中（顺便说一句，这不是理想的数据结构，因为查找速度很慢，最好使用哈希集）

UUID背后的理念是，生成UUID时，它是唯一的。理论上有发生碰撞的可能性，但几率很小，因此更有可能被陨石击中

还有，如果发生冲突，为什么要返回空字符串？如果这种情况真的发生（很可能永远不会发生），您可能会想知道这一点并抛出一个异常

所以我给你的建议是：

public class IdGenerator {

    public static String generateId() {
        return UUID.randomUUID().toString();
    }

}