Java 对象数组索引值被前面的索引值覆盖

这对我来说是一个奇怪的情况，我刚刚开始学习Java OOP

我做了一个像这样的课

public class Student {
        public static String name;
        public static int marks;

        public Student(String n, int m){
            name = n;
            marks = m;
        }
        public static void printProperties(){
            System.out.println("Name = " + name + " , marks = " + m);
        }
    }

如您所见，构造函数接受两个数据：name和marks

在我的主要方法中

      System.out.println("Please enter number of students:");
            int n = scan.nextInt();

            Student[] stu = new Student[n];

            String name;
            int marks = 0;

            for(int i = 0; i < stu.length; i++){

                System.out.println("Please enter name for student #" + (i+1));
                name = scan.next();

                System.out.println("Please enter marks for student #" + (i+1));
                marks  = scan.nextInt();

                stu[i] = new Student(name,marks);

                System.out.println();
            }

//Display
            for(int x = 0; x < stu.length; x++){
                System.out.println("#" + (x+1) + " Name: " + stu[x].name + ", Marks: " + stu[x].marks);

            }

应该是：

   #1 Name: tom, Marks: 20
   #2 Name: billy, Marks: 80

---

为什么前面的索引值超过了前面的索引值？

如果您的学生班级看起来像这样，那么您的代码应该工作得非常好：

public class Student{
    String name;
    int marks;
    public Student(String name, int marks){
        this.name = name;
        this.marks = marks;
    }
}

编辑：

这就是Jon Skeet提到的

您使用的静态变量是类级变量，因此每次为它们赋值时都会覆盖它们，并且只保留最后一个值

---

这里需要实例变量。

如果您的学生类看起来像这样，您的代码应该工作得非常好：

public class Student{
    String name;
    int marks;
    public Student(String name, int marks){
        this.name = name;
        this.marks = marks;
    }
}

编辑：

这就是Jon Skeet提到的

您使用的静态变量是类级变量，因此每次为它们赋值时都会覆盖它们，并且只保留最后一个值

---

这里需要实例变量。

不要使用静态，简单的不要使用静态，简单的不要将字段设置为

静态

，让我们使用

私有

来控制访问-

public class Student {
    private String name; // not static, and use private.
    private int marks;

    public Human(String n, int m){
        name = n;
        marks = m;
    }
    public void printProperties(){ // also should not be static.
        System.out.println("Name = " + name + " , marks = " + m);
    }
}

---

不要使字段

为静态的

，让我们使用

私有的

来控制访问-

public class Student {
    private String name; // not static, and use private.
    private int marks;

    public Human(String n, int m){
        name = n;
        marks = m;
    }
    public void printProperties(){ // also should not be static.
        System.out.println("Name = " + name + " , marks = " + m);
    }
}

---

静态变量属于整个类。它是所有对象共享的一个变量。因此，当您更改该变量时，它会更改所有对象的变量

相反，将

名称

和

标记

定义为实例变量。换句话说，从变量声明中删除

static

修饰符。实例变量对于每个对象都是唯一的。每个对象都有自己的实例变量副本

另外，最好将

名称

和

标记

声明为

私有

。然后为这些变量创建getter和setter。这隐藏了实现

import java.util.Scanner;

public class Student{

    private String name;
    private int marks;

    public String getName() {  //getter
        return name;
    }

    public void setName(String name) {  //setter
        this.name = name;
    }

    public int getMarks() {  //getter
        return marks;
    }

    public void setMarks(int marks) {  //setter
        this.marks = marks;
    }

    public Student(String n, int m){
        name = n;
        marks = m;
    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        System.out.println("Please enter number of students:");
        int n = scan.nextInt();

        Student[] stu = new Student[n];

        String name;
        int marks = 0;

        for(int i = 0; i < stu.length; i++){

            System.out.println("Please enter name for student #" + (i+1));
            name = scan.next();

            System.out.println("Please enter marks for student #" + (i+1));
            marks  = scan.nextInt();

            stu[i] = new Student(name,marks);

            System.out.println();
        }

        //Display
        for(int x = 0; x < stu.length; x++){
            System.out.println("#" + (x+1) + " Name: " + stu[x].getName() + ", Marks: " + stu[x].getMarks());

        }

        scan.close();
    }


}

import java.util.Scanner；
公立班学生{
私有字符串名称；
私人整数标记；
公共字符串getName（）{//getter
返回名称；
}
public void setName（字符串名）{//setter
this.name=名称；
}
public int getMarks（）{//getter
返回标记；
}
公共无效设置标记（整型标记）{//setter
这个。标记=标记；
}
公立学生（字符串n，整数m）{
name=n；
分数=m；
}
公共静态void main（字符串[]args）{
扫描仪扫描=新扫描仪（System.in）；
System.out.println（“请输入学生人数：”）；
int n=scan.nextInt（）；
学生[]stu=新学生[n]；
字符串名；
整数分=0；
对于（int i=0；i

A静态变量属于整个类。它是所有对象共享的一个变量。因此，当您更改该变量时，它会更改所有对象的变量

相反，将

名称

和

标记

定义为实例变量。换句话说，从变量声明中删除

static

修饰符。实例变量对于每个对象都是唯一的。每个对象都有自己的实例变量副本

另外，最好将

名称

和

标记

声明为

私有

。然后为这些变量创建getter和setter。这隐藏了实现

import java.util.Scanner;

public class Student{

    private String name;
    private int marks;

    public String getName() {  //getter
        return name;
    }

    public void setName(String name) {  //setter
        this.name = name;
    }

    public int getMarks() {  //getter
        return marks;
    }

    public void setMarks(int marks) {  //setter
        this.marks = marks;
    }

    public Student(String n, int m){
        name = n;
        marks = m;
    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        System.out.println("Please enter number of students:");
        int n = scan.nextInt();

        Student[] stu = new Student[n];

        String name;
        int marks = 0;

        for(int i = 0; i < stu.length; i++){

            System.out.println("Please enter name for student #" + (i+1));
            name = scan.next();

            System.out.println("Please enter marks for student #" + (i+1));
            marks  = scan.nextInt();

            stu[i] = new Student(name,marks);

            System.out.println();
        }

        //Display
        for(int x = 0; x < stu.length; x++){
            System.out.println("#" + (x+1) + " Name: " + stu[x].getName() + ", Marks: " + stu[x].getMarks());

        }

        scan.close();
    }


}

import java.util.Scanner；
公立班学生{
私有字符串名称；
私人整数标记；
公共字符串getName（）{//getter
返回名称；
}
public void setName（字符串名）{//setter
this.name=名称；
}
public int getMarks（）{//getter
返回标记；
}
公共无效设置标记（整型标记）{//setter
这个。标记=标记；
}
公立学生（字符串n，整数m）{
name=n；
分数=m；
}
公共静态void main（字符串[]args）{
扫描仪扫描=新扫描仪（System.in）；
System.out.println（“请输入学生人数：”）；
int n=scan.nextInt（）；
学生[]stu=新学生[n]；
字符串名；
整数分=0；
对于（int i=0；i

请在

学生

中显示代码。我想知道你是否在使用静态变量，例如…请发布你的学生类，看看你是如何在构造函数中使用值的。请在

Student

中显示代码。我想知道你是否在使用静态变量，例如…请发布你的学生课程，看看你是如何在构造函数中使用值的。我想补充一点，在分配时，应该在循环中声明main中的字符串名和int标记，只需声明为ens