如何將靜態方法轉化爲非靜態方法。與java相關的小解釋/範例oop

Question

我無法得到如何使用/創建沒有詞靜態的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); 


    } 
} 

二碼

public class Complex { 
// datové složky 

    public double re; 
    public double im; 
// konstruktory 

    public Complex() { 
    } 

    public Complex(double r) { 
     this(r, 0.0); 
    } 

    public Complex(double r, double i) { 
     re = r; 
     im = i; 
    } 


    public double abs() { 
     return Math.sqrt(re * re + im * im); 
    } 

    public Complex plus(Complex c) { 
     return new Complex(re + c.re, im + c.im); 
    } 

    public Complex minus(Complex c) { 
     return new Complex(re - c.re, im - c.im); 
    } 


    public String toString() { 
     return "[" + re + ", " + im + "]"; 
    } 
} 

Answer 1

首先，OOP是根據各地的對象。他們應該代表（抽象）真實世界的對象/概念。常見的例子是：

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

ignite該方法依賴於engine字段。

靜態方法是那些不依賴於對象狀態的方法。即它們與objects的概念不相關。單程序算法，數學計算等優選是靜態的。爲什麼？因爲他們接受輸入並生成輸出，而不需要在過程中表示任何東西，就像對象一樣。此外，這節省了不必要的對象實例。 看看java.lang.Math - 由於這個確切的原因，它的方法是靜態的。

Answer 2

讓我們先從一個簡單的例子：

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」是每個實例方法的隱藏參數（實例方法不是靜態的方法）。你基本上可以認爲編譯器把你的代碼像這樣重新寫它（在現實中，這是不是會發生什麼 - 但我想代碼編譯）：

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(Person.getFullName(personA)); 
     System.out.println(Person.getFullName(personB)); 
    } 
} 

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

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

    public static String getFullName(final Person thisx) 
    { 
     return (thisx.lastName + ", " + thisx.firstName); 
    } 
} 

所以，當你看代碼請記住，實例方法有一個隱藏參數，告訴它變量屬於哪個實際對象。

希望這會讓你朝着正確的方向前進，如果是這樣的話，那麼使用對象重新編寫第一課時會有刺傷 - 如果你發現你嘗試過的東西，如果你完成所有的事情發佈後，我是當然我們會幫助你看看你是否正確。

Answer 3

下面的程序已通過使方法非靜態編碼。

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(); 
    } 
} 

所做的更改：

• INT tab[]現在已經做出了 實例變量。
• 表的分配和初始化發生在構造函數中。 因爲這必須發生在每個 實例化的對象上，所以最好在 保存在一個構造函數中。
• 該方法不需要與 表稱爲參數爲 完全訪問實例 變量（在這種情況下表）現在
• 的方法已經進行了 非靜態的所有方法，使之不能被稱爲 使用類名稱，而不是我們需要 來實例化類創建一個 對象，然後調用 對象使用obj.method（） 語法的方法。

Answer 4

我猜你對「靜態」有什麼困惑。在OOP中，一切都是一個對象。每個對象都有自己的函數/變量。例如

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

如果函數來設置「名稱」變量將是非靜態的即串的setName（字符串名稱）{}這意味着該對象約翰具有名稱「John」和Alice具有名稱「的對象Alice「

當您希望在同一個類的所有對象中保留某個值時使用static。

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

所以如果你願意amountOfPeopleCreated的價值將是相同的，無論你檢查愛麗絲或約翰。

Answer 5

很容易將類方法從靜態方法轉換爲非靜態方法。您所要做的就是從所有方法名稱中刪除「static」。 （OFC不這樣做在public static void main，你將無法運行示例）

例子：
public static boolean isPrimeNum(int n) {將成爲
public boolean isPrimeNum(int n) {

在public static void main，你叫你將有方法來昌從您的來電beeing static，以引用指定類的對象。

前：
NumberArray2.isPrimeNum(11);

後：
NumberArray2 numberarray2 = new NumberArray2(); //創建給出 numberarray2.isPrimeNum(11); //類對象調用給定對象

在NumberArray2您還沒有包括在構造函數的方法（構造函數就像承包商一樣，他採用藍圖（類文件，NumberArray2）並遵循指導方針，例如建築物（對象）。 當您不想包含構造函數時，java編譯器將添加爲你。它看起來像這樣： public NumberArray2(){};

希望這會有所幫助。你是對的，這看起來像作業：D

我相信它的慣例是首先提供public修飾符。你沒有用「你的」第一種方法做到這一點，但在其他人中你已經做到了這一點static public。至少爲了可讀性，你應該同時執行這兩個操作（代碼將以ether方式編譯，作爲compilator dosnt care）。

該代碼乾淨，易於閱讀。對於「只想學習編碼」的人來說，這很難做到。希望這可以幫助你順利地完成你的「只是看起來像是工作而已」的學習。