Java 为什么要创建类的新实例？

我已经完成了一些Java教程，它们都说在调用类时创建一个新变量。为什么会这样？我已经测试了一些代码，它不需要这样做就可以工作。 我已经使用python有一段时间了，所以我习惯于使用动态语言

请参阅下面我一直在使用的一些代码：

import java.util.Scanner; 

class MyClass {

    static String myName(String name) {
        return ("Your name is: "+name);
    }
    static String myAge(Integer age){
        return ("Your age is: "+age);
    }
    static String myGender(String gender){
        return ("You are: "+gender);
    }
}

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

        MyClass user = new MyClass();

        //Output with new variable of class - user
        String input = ui.next();
        String newname = user.myName(input);
        System.out.println(newname);

        //Output calling class directly
        Integer input1 = ui.nextInt();
        String newage = MyClass.myAge(input1);
        System.out.println(newage);

        //Output with new variable of class - user
        String input2 = ui.next();
        String newgender = MyClass.myGender(input2);
        System.out.println(newgender);

    }

}

---

谢谢您的时间。

如果类中的所有内容都是静态的（就像您发布的代码一样），那么就不需要创建类的实例。但是，如果类有实例字段和/或方法，那么故事就不同了。例如，考虑这样的类：

class Person {
    private String name;
    private int age;
    private String gender;

    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    String myName() { return "Your name is: " + name; }
    String myAge() { return "Your age is: " + age; }
    String myGender() { return "You are: " + gender; }
}

然后，您可以创建几个具有不同内部状态的

Person

实例，并在代码中互换使用它们：

public static void main(String[] args) {
    Person jim = new Person("Jim", 40, "male");
    Person sally = new Person("Sally", 12, "female");

    report(jim);
    report(sally);
}

private static report(Person person) {
    System.out.println(person.myName());
    System.out.println(person.myAge());
    System.out.println(person.myGender());
}

---

如果类中的所有内容都是

静态的

（与您发布的代码一样），则无需创建类的实例。但是，如果类有实例字段和/或方法，那么故事就不同了。例如，考虑这样的类：

class Person {
    private String name;
    private int age;
    private String gender;

    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    String myName() { return "Your name is: " + name; }
    String myAge() { return "Your age is: " + age; }
    String myGender() { return "You are: " + gender; }
}

然后，您可以创建几个具有不同内部状态的

Person

实例，并在代码中互换使用它们：

public static void main(String[] args) {
    Person jim = new Person("Jim", 40, "male");
    Person sally = new Person("Sally", 12, "female");

    report(jim);
    report(sally);
}

private static report(Person person) {
    System.out.println(person.myName());
    System.out.println(person.myAge());
    System.out.println(person.myGender());
}

---

若我们用static关键字创建任何成员，它会立即为所有对象获取内存，当我们在类中有公共属性时使用static关键字，我们不想为所有实例对象创建单独的内存。。。它不需要创建实例变量来调用它，这个静态块可以共享给所有对象。。。。例如，如果我们有动物课，我们想描述5种不同类型的狗。。。我们不把颜色、大小等属性定义为静态。。。因为它们都有自己不同的大小和颜色。。。。我希望你能得到它

如果我们用static关键字创建任何成员，它会立即为所有对象获取内存，我们在类中有公共属性时使用static关键字，我们不想为所有实例对象创建单独的内存。。。它不需要创建实例变量来调用它，这个静态块可以共享给所有对象。。。。例如，如果我们有动物课，我们想描述5种不同类型的狗。。。我们不把颜色、大小等属性定义为静态。。。因为它们都有自己不同的大小和颜色。。。。我希望您能理解它

“在调用类时创建一个新变量”这是什么意思

MyClass

没有任何变量，只有一些静态方法。Python有对象。听起来你好像还没用过。（不是说不知道有什么不对……我曾经在社区学院上过C++课程，他们从来没有告诉我们C++有对象……）我说OOP犯了一个错误，我的意思是我习惯于使用动态语言，比如Python。我的问题是，为什么要创建一个类的新实例，如示例中所示：MyClass user=new MyClass（）；但我还是一个编程新手，所以我为任何不正确的术语道歉。“在调用类时创建一个新变量”你这是什么意思

MyClass

没有任何变量，只有一些静态方法。Python有对象。听起来你好像还没用过。（不是说不知道有什么不对……我曾经在社区学院上过C++课程，他们从来没有告诉我们C++有对象……）我说OOP犯了一个错误，我的意思是我习惯于使用动态语言，比如Python。我的问题是，为什么要创建一个类的新实例，如示例中所示：MyClass user=new MyClass（）；但我对编程还是新手，所以我为任何不正确的术语道歉。我不知道这有什么帮助。语法、拼写、标点符号都坏了。你没有提到OP的例子。而通过关注

静态

，谈论“内存”，你的解释忽略了OO的真正意义。请看Ted Hopp的答案，以获得一个好的/有用的答案。okk bro，我在这里学习，谢谢。这就是我发表评论的原因……我看不出这有什么帮助。语法、拼写、标点符号都坏了。你没有提到OP的例子。而通过关注

静态

，谈论“内存”，你的解释忽略了OO的真正意义。请看Ted Hopp的答案，以获得一个好的/有用的答案。okk bro，我在这里学习，谢谢。这就是我发表评论的原因……这很好，谢谢你的解释。这很好，谢谢你的解释。