Question

我现在还没有编码任何东西，我决定练习一下。我在程序的最开始就想出了这个问题，我昨晚花了很多时间试图弄清楚或找到解决这个问题的方法，但我没有得到任何预期的结果。

首先，让我们看看班级：

public class Task {
private static int priority;
private static int taskTime;
private static boolean solved;

public void setPriority(int p){this.priority = p;}
public void setTasktime(int t){this.taskTime = t;}
public void setSolved(boolean s){solved = s;}

public int getPriority(){return this.priority;}
public int getTaskTime(){return this.taskTime;}
public boolean getSolved(){return this.solved;}

public Task(int p, int t){
    this.priority = p;
    this.taskTime = t;
    this.solved = false;
}

public static class ComparePriority implements Comparator<Task>{
    @Override
    public int compare(Task t1, Task t2){
        return Integer.compare(t1.getPriority(), t2.getPriority());
    }

}
}

现在，这是我试图运行的代码片段：

public class main {

public static void main(String[] args) {            
    Task t1 = new Task(20,1);
    Task t2 = new Task(13,2);
    Task t3 = new Task(10,5);
    ArrayList<Task> t = new ArrayList<Task>();
    t.add(t2);
    t.add(t3);
    t.add(t1);
    System.out.println("List size: " + t.size());
    System.out.println("T1 object's priority: " + t1.getPriority());
    System.out.println("T2 object's priority: " + t2.getPriority());
    System.out.println("T3 object's priority: " + t3.getPriority());


    for(int i=0;i<t.size();i++){
        System.out.println("Current object task time: "+ t.get(i).getTaskTime());
        System.out.println("Current index:" + i);
    }

    Collections.sort(t, new Task.ComparePriority());

    for(int i=0;i<t.size();i++){
        System.out.println("Current object task time (post sort): " + t.get(i).getTaskTime());
        System.out.println("Current index: " + i);
    }
}

我知道这些属性是以静态方式定义的，我应该以 Class.method（）;

的形式访问它们

如果我要实例化3个对象（如上面的示例所示），是否有任何方法可以静态访问它们，但仍然可以从对象读取的每条信息都是唯一的而不是＆＃34;相同的＆＃34 34;

为什么非静默地访问它们呢？

Answer 1

你要求提出矛盾的事情。

静态访问

矛盾

仍然可以从对象中读取的每条信息都是唯一的而不是“相同的”

如果您希望前者，您应该期望所有实例都能看到相同的值。

如果您希望使用后者，请不要将它们定义为静态。

至于非静态访问它们，据我所知它没有任何区别。它们只是因为我不能非静态地访问静态成员（即通过解除引用该类的对象）是可读性的。当您阅读object.member时，您希望member成为非静态成员。当您阅读ClassName.member时，您知道它是一个静态成员。

Answer 2

当调用静态方法时，它会处理类级别的所有内容，而不是对象级别。这意味着该方法没有调用它的对象状态的概念 - 它将被视为与调用它的每个对象相同。这就是编译器发出警告的原因。使用形式为a.Method()的静态方法会产生误导，因为它暗示该方法在对象上被调用，而在静态方法的情况下则不然。这就是为什么在对象的实例上调用静态方法是不好的做法。

Answer 3

在编程中根本不打算非静态地访问它们，但实际上是鼓励的。如果要非静态地访问内容，请尝试将该代码放在方法中的另一个类中。然后在这堂课中放

public static void main(String[] args) { 
AnotherClass ac = new AnotherClass();
ac.initializeProcess()
}

我不知道为什么人们喜欢降级问题，我猜他们认为他们根本不是新手。

更新的静态对象不会太快地被扔进垃圾收集器，但只要引用它就会保存它;静态对象可能导致内存问题

Answer 4

我认为你误解了类变量和静态变量之间的区别。程序只有一个静态变量平均值，而每个对象都有自己的类变量值。将它与静态成员一起使用也被认为是误导性的。

Java初始化对象 - 静态访问与非静态访问

4 个答案: