java中的面向对象设计与静态类及并发性开发

我有7-8个可调用类，这些类使用了一些类似的功能，还阅读了一些相同的列表和HashMap。 因此，我创建了一个静态类，其中包含静态函数、静态列表和hashMap等所有功能

现在，我有一些疑问：

1.）在java中使用静态类是否是一种错误的做法，因为我的前辈责备我使用静态类，而是要求我将其转换为单例类

但是静态类比单例类快。不是吗

2.）引用静态/非静态方法以获取调用方法（线程中）内的列表之类的数据或执行某些任务是一种糟糕的设计吗

它是否像我的上级所说的那样违反了线程安全或并行性？并要求我将该列表作为私有成员放在thread类中

但是，这不是因为其他6-7线程类使用相同的列表进行只读而导致的内存使用不好吗

3.）如何改进OO设计，同时提高性能

示例代码如下所示：

public class StaticClass {
    private static List<String> ListOne;
    private static List<String> listTwo;
    private static HashMap<String, String> hMap;

    static{
        //initialize list and maps by reading from file
    }


    public static List<String> getListOne() {
        return ListOne;
    }
    public static List<String> getListTwo() {
        return listTwo;
    }
    public static HashMap<String, String> gethMap() {
        return hMap;
    }

    public static void commonMethodOne(){

    }

    public static String commonMethodTwo(){

        }

    public static String[] commonMethodThree(){

    }

}

公共类静态类{
私有静态列表列表；
私有静态列表列表2；
私有静态HashMap-hMap；
静止的{
//通过读取文件初始化列表和映射
}
公共静态列表getListOne（）{
返回列表一；
}
公共静态列表getListTwo（）{
返回列表2；
}
公共静态HashMap gethMap（）{
返回hMap；
}
公共静态void commonMethodOne（）{
}
公共静态字符串commonMethodTwo（）{
}
公共静态字符串[]commonMethodThree（）{
}
}

public类CallableThread实现可调用{
公共字符串调用（）{
HashMap mapTask=StaticClass.gethMap（）；
List taskOne=StaticClass.getListOne（）；
用于（字符串温度：taskOne）{
//做你该做的事
}
for（字符串键：mapTask.keySet（））{
//做你该做的事
}
返回“使用CallableThread完成”；
}
}

像这样的方法是一个糟糕的想法（命名不好，没有遵循Java编码标准）：

公共静态列表getListOne（）{
返回列表一；
}

您将返回一个可变引用，因此任何获得此列表的人都可以根据自己的需要修改其内容。隐私不再是隐私

如果必须返回对私有列表或数据结构的引用（我看不出有任何理由这样做），则应该使其不可变或返回一个副本

public static List<String> getListOne() {
    return Collections.unmodifiableList(ListOne);
}

公共静态列表getListOne（）{
返回集合。不可修改列表（ListOne）；
}

---

没有任何类型的同步，您就得到了可变的共享数据，因此该类根本不是线程安全的。

像这样的方法是一个糟糕的想法（命名不好，没有遵循Java编码标准）：

公共静态列表getListOne（）{
返回列表一；
}

您将返回一个可变引用，因此任何获得此列表的人都可以根据自己的需要修改其内容。隐私不再是隐私

如果必须返回对私有列表或数据结构的引用（我看不出有任何理由这样做），则应该使其不可变或返回一个副本

public static List<String> getListOne() {
    return Collections.unmodifiableList(ListOne);
}

公共静态列表getListOne（）{
返回集合。不可修改列表（ListOne）；
}

---

没有任何类型的同步，您就得到了可变的共享数据，因此该类根本不是线程安全的。

像这样的方法是一个糟糕的想法（命名不好，没有遵循Java编码标准）：

公共静态列表getListOne（）{
返回列表一；
}

您将返回一个可变引用，因此任何获得此列表的人都可以根据自己的需要修改其内容。隐私不再是隐私

如果必须返回对私有列表或数据结构的引用（我看不出有任何理由这样做），则应该使其不可变或返回一个副本

public static List<String> getListOne() {
    return Collections.unmodifiableList(ListOne);
}

公共静态列表getListOne（）{
返回集合。不可修改列表（ListOne）；
}

---

没有任何类型的同步，您就得到了可变的共享数据，因此该类根本不是线程安全的。

像这样的方法是一个糟糕的想法（命名不好，没有遵循Java编码标准）：

公共静态列表getListOne（）{
返回列表一；
}

您将返回一个可变引用，因此任何获得此列表的人都可以根据自己的需要修改其内容。隐私不再是隐私

如果必须返回对私有列表或数据结构的引用（我看不出有任何理由这样做），则应该使其不可变或返回一个副本

public static List<String> getListOne() {
    return Collections.unmodifiableList(ListOne);
}

公共静态列表getListOne（）{
返回集合。不可修改列表（ListOne）；
}

---

没有任何类型的同步，您就得到了可变的共享数据，因此这个类根本不是线程安全的。

我认为单例远远优于静态类

以下是对您问题的连续回答：

1） 不，这完全取决于您的需求，但静态类速度更快，但也允许更多的bug进入您的项目

2） 是的，有时只要它不影响您的私有数据成员并使您的数据不安全

3） 使用单例，因为它提供了更多的OO功能，从而提高了性能

这里有一篇很好的参考文章供您参考：

---

我认为单例类远比静态类好

以下是对您问题的连续回答：

1） 不，这完全取决于您的需求，但静态类速度更快，但也允许更多的bug进入您的项目

2） 是的，有时只要它不影响您的私有数据成员并使您的数据不安全

3） 使用单例，因为它提供了更多的OO功能，从而提高了性能

这里有一篇很好的参考文章供您参考：

我认为是单身