如何将静态方法转换为非静态方法。与java oop相关的小说明/示例

如果没有静态这个词，我就不知道如何使用/创建oop代码。我阅读Sun教程，有书和示例。我知道有构造函数，然后“指针”等等。我可以用return语句创建一些简单的非静态方法。真正的问题是，我只是不明白它是如何工作的。我希望通过一些交流让我有动力继续前进。如果有人问，这不是家庭作业。我只是想学习如何编码。 下面的代码是静态方法和一些非常基本的算法。我想知道如何通过逻辑步骤将其更改为非静态代码（请） 第二段代码显示了一些我可以编写但不能完全理解的非静态代码，也不能将其用作重写第一段代码的模板。 提前感谢您的任何提示

    import java.util.Scanner;

/**
 *
 * @author
 */

public class NumberArray2{

    public static int[] table() {
        Scanner Scan = new Scanner(System.in);
        System.out.println("How many numbers?");
        int s = Scan.nextInt();
        int[] tab = new int[s];

        System.out.println("Write a numbers: ");
        for(int i=0; i<tab.length; i++){
           tab[i] = Scan.nextInt();
        }
        System.out.println("");
        return tab;
    }

    static public void output(int [] tab){
        for(int i=0; i<tab.length; i++){
            if(tab[i] != 0)
                System.out.println(tab[i]);
        }

    }

    static public void max(int [] tab){
       int maxNum = 0;
        for(int i=0; i<tab.length; i++){
            if(tab[i] > maxNum)
                maxNum = tab[i];

        }
    //return maxNum;
       System.out.println(maxNum);
    }

    static public void divide(int [] tab){
        for(int i=0; i<tab.length; i++){
            if((tab[i] % 3 == 0) && tab[i] != 0)
                System.out.println(tab[i]);
        }
    }

    static public void average(int [] tab){
          int sum = 0;
          for(int i=0; i<tab.length; i++)
            sum = sum + tab[i];
            int avervalue = sum/tab.length;
            System.out.println(avervalue);

}




        public static void isPrime(int[] tab) {
        for (int i = 0; i < tab.length; i++) {
            if (isPrimeNum(tab[i])) {
                System.out.println(tab[i]);
            }
        }


    }

    public static boolean isPrimeNum(int n) {
        boolean prime = true;
        for (long i = 3; i <= Math.sqrt(n); i += 2) {
            if (n % i == 0) {
                prime = false;
                break;
            }
        }
        if ((n % 2 != 0 && prime && n > 2) || n == 2) {
            return true;

        } else {
            return false;
        }
    }




    public static void main(String[] args) {
        int[] inputTable = table();

        //int s = table();


        System.out.println("Written numbers:");
        output(inputTable);
        System.out.println("Largest number: ");
        max(inputTable);
        System.out.println("All numbers that can be divided by three: ");
        divide(inputTable);
        System.out.println("Average value: ");
        average(inputTable);
        System.out.println("Prime numbers: ");
        isPrime(inputTable);


    }
}

---

首先，OOP是基于对象的。它们应该表示（抽象）现实世界的对象/概念。常见的例子是：

Car
properties - engine, gearbox, chasis
methods - ignite, run, brake

ignite

方法取决于

engine

字段

静态方法是那些不依赖于对象状态的方法。也就是说，它们与

对象的概念不相关。单程序算法、数学计算等最好是静态的。为什么？因为它们接受输入并生成输出，而不需要将过程中的任何内容表示为对象。此外，这还节省了不必要的对象实例化。
看看
java.lang.Math
——正是因为这个原因，它的方法是静态的。
首先，OOP是基于对象的。它们应该表示（抽象）现实世界的对象/概念。常见的例子是：

Car
properties - engine, gearbox, chasis
methods - ignite, run, brake

ignite
方法取决于
engine
字段

静态方法是那些不依赖于对象状态的方法。也就是说，它们与
对象的概念不相关。单程序算法、数学计算等最好是静态的。为什么？因为它们接受输入并生成输出，而不需要将过程中的任何内容表示为对象。此外，这还节省了不必要的对象实例化。
看看
java.lang.Math
——正是出于这个原因，它的方法是静态的。
让我们从一个简单的例子开始：

public class Main
{
    public static void main(final String[] argv)
    {
        final Person personA;
        final Person personB;

        personA = new Person("John", "Doe");
        personB = new Person("Jane", "Doe");

        System.out.println(personA.getFullName());
        System.out.println(personB.getFullName());
    }
}

class Person
{
    private final String firstName;
    private final String lastName;

    public Person(final String fName,
                  final String lName)
    {
        firstName = fName;
        lastName  = lName;
    }

    public String getFullName()
    {
        return (lastName + ", " + firstName);
    }
}

现在，我将对getFullName方法进行一个小的更改：

public String getFullName()
{
    return (this.lastName + ", " + this.firstName);
}

注意我现在使用的“this”

问题是“这”是从哪里来的？它并没有在任何地方声明为变量，所以它就像魔术一样。事实证明，“this”是每个实例方法的一个隐藏参数（实例方法是一个非静态的方法）。从本质上讲，您可以认为编译器接受您的代码并像这样重新编写它（实际上，这并不是实际情况，但我希望代码能够编译）：

因此，当您查看代码时，请记住实例方法有一个隐藏参数，告诉它变量属于哪个实际对象

希望这能让你朝着正确的方向前进，如果是这样的话，尝试一下使用对象重新编写第一个类——如果你在文章中遇到了困难，如果你一路都完成了，那么就发布它，我相信我们会帮你看看你是否做对了。
让我们从一个简单的例子开始：

public class Main
{
    public static void main(final String[] argv)
    {
        final Person personA;
        final Person personB;

        personA = new Person("John", "Doe");
        personB = new Person("Jane", "Doe");

        System.out.println(personA.getFullName());
        System.out.println(personB.getFullName());
    }
}

class Person
{
    private final String firstName;
    private final String lastName;

    public Person(final String fName,
                  final String lName)
    {
        firstName = fName;
        lastName  = lName;
    }

    public String getFullName()
    {
        return (lastName + ", " + firstName);
    }
}

现在，我将对getFullName方法进行一个小的更改：

public String getFullName()
{
    return (this.lastName + ", " + this.firstName);
}

注意我现在使用的“this”

问题是“这”是从哪里来的？它并没有在任何地方声明为变量，所以它就像魔术一样。事实证明，“this”是每个实例方法的一个隐藏参数（实例方法是一个非静态的方法）。从本质上讲，您可以认为编译器接受您的代码并像这样重新编写它（实际上，这并不是实际情况，但我希望代码能够编译）：

因此，当您查看代码时，请记住实例方法有一个隐藏参数，告诉它变量属于哪个实际对象

希望这能让你朝着正确的方向前进，如果是这样的话，试着用对象重新编写第一个类——如果你在尝试后遇到了困难，如果你一路都完成了，请发布它，我相信我们会帮助你看看你是否做对了。
下面的程序是通过使方法非静态来编写的

import java.util.Scanner;

public class NumberArray2{

   private int tab[]; // Now table becomes an instance variable.

   // allocation and initilization of the table now happens in the constructor.
   public NumberArray2() {
      Scanner Scan = new Scanner(System.in);
      System.out.println("How many numbers?");
      int s = Scan.nextInt();
      tab = new int[s];

      System.out.println("Write a numbers: ");
      for(int i=0; i<tab.length; i++){
         tab[i] = Scan.nextInt();
      }
      System.out.println("");
   }

   public void output(){
      for(int i=0; i<tab.length; i++){
         if(tab[i] != 0)
            System.out.println(tab[i]);
      }
   }

   public void max(){
      int maxNum = 0;
      for(int i=0; i<tab.length; i++){
         if(tab[i] > maxNum)
            maxNum = tab[i];
      }
      System.out.println(maxNum);
   }

   public void divide(){
      for(int i=0; i<tab.length; i++){
         if((tab[i] % 3 == 0) && tab[i] != 0)
            System.out.println(tab[i]);
      }
   }

   public void average(){
      int sum = 0;
      for(int i=0; i<tab.length; i++)
         sum = sum + tab[i];
      int avervalue = sum/tab.length;
      System.out.println(avervalue);
   }

   public void isPrime() {
      for (int i = 0; i < tab.length; i++) {
         if (isPrimeNum(tab[i])) {
            System.out.println(tab[i]);
         }
      }
   }

   public boolean isPrimeNum(int n) {
      boolean prime = true;
      for (long i = 3; i <= Math.sqrt(n); i += 2) {
         if (n % i == 0) {
            prime = false;
            break;
         }
      }
      if ((n % 2 != 0 && prime && n > 2) || n == 2) {
         return true;
      } else {
         return false;
      }
   }

   public static void main(String[] args) {

      // instatiate the class.
      NumberArray2 obj = new NumberArray2();

      System.out.println("Written numbers:");
      obj.output(); // call the methods on the object..no need to pass table anymore.
      System.out.println("Largest number: ");
      obj.max();
      System.out.println("All numbers that can be divided by three: ");
      obj.divide();
      System.out.println("Average value: ");
      obj.average();
      System.out.println("Prime numbers: ");
      obj.isPrime();
   }
}

import java.util.Scanner；
公共课编号RAY2{
private int tab[]；//现在表成为一个实例变量。
//表的分配和初始化现在在构造函数中进行。
公众号码ray2（）{
扫描仪扫描=新扫描仪（System.in）；
System.out.println（“多少个数字？”）；
int s=Scan.nextInt（）；
tab=新整数[s]；
System.out.println（“写一个数字：”）；
对于（int i=0；i，通过使方法非静态，对以下程序进行了编码

import java.util.Scanner;

public class NumberArray2{

   private int tab[]; // Now table becomes an instance variable.

   // allocation and initilization of the table now happens in the constructor.
   public NumberArray2() {
      Scanner Scan = new Scanner(System.in);
      System.out.println("How many numbers?");
      int s = Scan.nextInt();
      tab = new int[s];

      System.out.println("Write a numbers: ");
      for(int i=0; i<tab.length; i++){
         tab[i] = Scan.nextInt();
      }
      System.out.println("");
   }

   public void output(){
      for(int i=0; i<tab.length; i++){
         if(tab[i] != 0)
            System.out.println(tab[i]);
      }
   }

   public void max(){
      int maxNum = 0;
      for(int i=0; i<tab.length; i++){
         if(tab[i] > maxNum)
            maxNum = tab[i];
      }
      System.out.println(maxNum);
   }

   public void divide(){
      for(int i=0; i<tab.length; i++){
         if((tab[i] % 3 == 0) && tab[i] != 0)
            System.out.println(tab[i]);
      }
   }

   public void average(){
      int sum = 0;
      for(int i=0; i<tab.length; i++)
         sum = sum + tab[i];
      int avervalue = sum/tab.length;
      System.out.println(avervalue);
   }

   public void isPrime() {
      for (int i = 0; i < tab.length; i++) {
         if (isPrimeNum(tab[i])) {
            System.out.println(tab[i]);
         }
      }
   }

   public boolean isPrimeNum(int n) {
      boolean prime = true;
      for (long i = 3; i <= Math.sqrt(n); i += 2) {
         if (n % i == 0) {
            prime = false;
            break;
         }
      }
      if ((n % 2 != 0 && prime && n > 2) || n == 2) {
         return true;
      } else {
         return false;
      }
   }

   public static void main(String[] args) {

      // instatiate the class.
      NumberArray2 obj = new NumberArray2();

      System.out.println("Written numbers:");
      obj.output(); // call the methods on the object..no need to pass table anymore.
      System.out.println("Largest number: ");
      obj.max();
      System.out.println("All numbers that can be divided by three: ");
      obj.divide();
      System.out.println("Average value: ");
      obj.average();
      System.out.println("Prime numbers: ");
      obj.isPrime();
   }
}

import java.util.Scanner；
公共课编号RAY2{
private int tab[]；//现在表成为一个实例变量。
//表的分配和初始化现在在构造函数中进行。
公众号码ray2（）{
扫描仪扫描=新扫描仪（System.in）；
System.out.println（“多少个数字？”）；
int s=Scan.nextInt（）；
tab=新整数[s]；
System.out.println（“写一个数字：”）；
对于（inti=0；i我猜你对“static”的作用感到困惑。在OOP中，一切都是一个对象。每个对象都有自己的函数/变量

Person john = new Person("John",18);
Person alice = new Person("Alice",17);

如果设置'name'变量的函数是非静态的，即字符串setName（字符串名称）{}，这意味着对象john的名称为“john”，对象alice的名称为“alice”

当您希望在同一类的所有对象中保留某个值时，使用static

class Person{
static int amountOfPeopleCreated;
   public Person(string name, int age){
      amountOfPeopleCreated++;
      setName(name);
      setAge(age);
   }
   ...
}

因此，如果你想知道，amountOfPeopleCreated的值将是相同的，无论你检查alice还是john。
我猜你对“静态”的作用感到困惑。在OOP中，一切都是一个对象。每个对象都有自己的函数/变量。例如

Person john = new Person("John",18);
Person alice = new Person("Alice",17);

如果设置“name”变量的函数是非静态的，即string setName（string name