如何重寫此代碼以使用面向對象編程？

Question

public class stackOverflow 
{ 
    public static void main (String args[]) 
    { 
     int maxNumbers = 100; 
     int numbers[] = new int[maxNumbers]; 
     for (int k = 0; k < numbers.length; k++) 
      numbers[k] = getRandom(10,99); 
     for (int k = 0; k < numbers.length; k++) 
      System.out.print(numbers[k] + " "); 
     System.out.println(); 
    } 
    public static int getRandom(int min, int max) 
    { 
     int range = max - min + 1; 
     double rndDouble = Math.random() * range; 
     int rndInt = (int) rndDouble + min; 
     return rndInt; 
    }   
} 

提供的程序正常工作，但我沒有寫得很整齊/專業。任何人都可以給我一些指導，我如何可以重寫這個實現面向對象編程列表類？

Answer 1

import java.util.ArrayList; 
import java.util.List;  

int maxNumbers = 100; 
List<Integer> numbers = new ArrayList<Integer>(); 
for (int k = 0; k < maxNumbers; k++) 
    numbers.add(getRandom(10,99)); 

System.out.println(numbers.toString()); 

這是你想要的嗎？

Answer 2

這可以是一種替代...

class Numbers { 
    int maxNumbers; 
    int numbers[]; 
    public Numbers(int maxNumbers) { 
     // TODO Auto-generated constructor stub 
     this.maxNumbers = maxNumbers; 
     this.numbers = new int[maxNumbers]; 
    } 
    public int getRandom(int min, int max) { 
     int range = max - min + 1; 
     double rndDouble = Math.random() * range; 
     int rndInt = (int) rndDouble + min; 
     return rndInt; 
    } 
} 
public class StackOverflow { 
    public static void main(String [] args) { 
     Numbers numbers = new Numbers(100); 
     for (int k = 0; k < numbers.numbers.length; k++) 
      numbers.numbers[k] = numbers.getRandom(10,99); 
     for (int k = 0; k < numbers.numbers.length; k++) 
      System.out.print(numbers.numbers[k] + " "); 
    } 
} 

或者這樣的事情...

public class StackOverflow { 

    static int maxNumbers = 100; 
    static int numbers[] = new int[maxNumbers]; 

    public static void main (String args[]) { 
     StackOverflow stackOverflow = new StackOverflow(); 

     for (int k = 0; k < numbers.length; k++) 
      numbers[k] = stackOverflow.getRandom(10,99); 
     for (int k = 0; k < numbers.length; k++) 
      System.out.print(numbers[k] + " "); 
     System.out.println(); 
    } 

    public int getRandom(int min, int max) { 
     int range = max - min + 1; 
     double rndDouble = Math.random() * range; 
     int rndInt = (int) rndDouble + min; 
     return rndInt; 
    }   
} 

朋友，還有其他選擇的號碼。

Answer 3

一些編寫這個structured linear程序的方法在oops。這裏是我的版本..

public class stackOverflow 
{ 
    int numbers[]; 

    public stackOverflow(){ //assuming default constructor will provide a 100 length array 
     int maxNumbers = 100; 
     this.numbers[] = new int[maxNumbers]; 
    } 

    public stackOverflow(int length){ //Provide a length according to your need. 
     this.numbers[] = new int[length]; 
    } 

    private void fillNumberArrayWithRandomNumber(){ 
    for (int k = 0; k < this.numbers.length; k++) 
      numbers[k] = this.getRandom(10,99); 
    } 

    private void printAllNumbersInArray(){ 
      for (int k = 0; k < this.numbers.length; k++) 
      System.out.print(numbers[k] + " "); 
     System.out.println(); 
    } 

    public static void main (String args[]) 
    { 
     stackOverflow obj1 = new stackOverflow(); //default Constructor will call with array lenth 100 
     obj1.fillNumberArrayWithRandomNumber(); 
     obj1.printAllNumbersInArray(); 

     stackOverflow obj2 = new stackOverflow(50); //overloaded Constructor will Call with array length 50 
     obj2.fillNumberArrayWithRandomNumber(); 
     obj2.printAllNumbersInArray(); 

    } 
    public int getRandom(int min, int max) 
    { 
     int range = max - min + 1; 
     double rndDouble = Math.random() * range; 
     int rndInt = (int) rndDouble + min; 
     return rndInt; 
    }   
} 

另一種方式將業務邏輯分離到其他類。並從別人那裏調用它。

public class GenerateRandomNumbers 
    { 
     int numbers[]; 

     public GenerateRandomNumbers(){ //assuming default constructor will provide a 100 length array 
      int maxNumbers = 100; 
      this.numbers[] = new int[maxNumbers]; 
     } 

     public GenerateRandomNumbers(int length){ //Provide a length according to your need. 
      this.numbers[] = new int[length]; 
     } 

     public void fillNumberArrayWithRandomNumber(){ 
     for (int k = 0; k < this.numbers.length; k++) 
       numbers[k] = this.getRandom(10,99); 
     } 

     public void printAllNumbersInArray(){ 
       for (int k = 0; k < this.numbers.length; k++) 
       System.out.print(numbers[k] + " "); 
      System.out.println(); 
     } 

     private int getRandom(int min, int max) 
     { 
      int range = max - min + 1; 
      double rndDouble = Math.random() * range; 
      int rndInt = (int) rndDouble + min; 
      return rndInt; 
     }   
    } 

    class stackOverflow { 
    public static void main (String args[]) 
     { 
      GenerateRandomNumbers obj1 = new GenerateRandomNumbers(); //default Constructor will call with array lenth 100 
      obj1.fillNumberArrayWithRandomNumber(); 
      obj1.printAllNumbersInArray(); 

      GenerateRandomNumbers obj2 = new GenerateRandomNumbers(50); //overloaded Constructor will Call with array length 50 
      obj2.fillNumberArrayWithRandomNumber(); 
      obj2.printAllNumbersInArray(); 

     } 
} 

Answer 4

您可以用Random（和nextInt(int)）做到這一點，並在Java中8+一個lambda expression。這可能看起來像

int maxNumbers = 100; 
int min = 10; 
int max = 99; 
Random rand = new Random(); 
List<Integer> al = new ArrayList<>(); 
IntStream.range(0, maxNumbers).forEach(x -> { 
    al.add(rand.nextInt(max - min) + min); 
}); 
al.stream().forEach(x -> { 
    System.out.printf("%d%n", x); 
}); 

Answer 5

使用列表：

下面是一個例子類利用的對象列表來保存每個號碼。您可以使用參數化構造函數聲明最大大小，也可以使用將其設置爲100的默認構造函數。

setNumbers方法永遠不會執行多次（通過將大小檢查爲最大大小），以便列表永遠不會超過最大大小。此外，您可以將參數添加到setNumbers方法，以便您可以選擇每個隨機數字之間的範圍，而不僅僅是10-99。 getNumbers方法將返回包含所有數字的列表對象。

import java.util.ArrayList; 
import java.util.List; 

public class Example { 

    int maxNumbers; 
    List<Object> list = new ArrayList<Object>(); 

public Example(){ 
    this.maxNumbers = 100; 
} 

public Example(int max){ 
    this.maxNumbers = max; 
} 

private int getRandom(int min, int max) 
{ 
    int range = max - min + 1; 
    double rndDouble = Math.random() * range; 
    int rndInt = (int) rndDouble + min; 
    return rndInt; 
} 

public List<Object> getNumbers(){ 
    return this.list; 
} 

public void setNumbers(){ 

    if (list.size() >= maxNumbers){ 
     return; 
    } 

    for (int k = 0; k < this.maxNumbers; k++) 
     this.list.add(getRandom(10,99)); 


} 



} 

這裏是一個驅動類的例子。

public class ExampleDriver 
{ 
    public static void main (String args[]) 
    { 
     //Instantiates the object using the default constructor. 
     Example test = new Example(); 

     //Generates the numbers within the list. 
     test.setNumbers(); 

     //Stores the returned list from getNumbers() to exampleList 
     List<Object> exampleList = test.getNumbers(); 
    } 


} 

Answer 6

您可以創建自己的RandomList延伸ArrayList<Integer>：

public class RandomList extends ArrayList<Integer> { 
    private int size; 
    private int min; 
    private int max; 
    public RandomList(int size, int min, int max) { 
     super(size); 
     this.size = size; 
     this.min = min; 
     this.max = max; 
    } 

    /** 
    * Populate list with entries between min and max 
    */ 
    public void populate() { 
     Random rand = new Random(); 
     for (int t = 0; t < size; t++) { 
      this.add(rand.nextInt(max - min) + min); 
     } 
    } 

    public String toString() { 
     StringBuilder sb = new StringBuilder(); 
     for (Integer i:this) { 
      sb.append(i).append(" "); 
     } 
     return sb.toString(); 
    } 

    public static void main (String [] args) { 
     RandomList randomList = new RandomList(100, 10, 99); 
     randomList.populate(); 
     System.out.println(randomList); 
    } 
} 

Answer 7

你可以實現自己的List類。爲此，您應該定義一個Node，一個List類（將包含節點）和一個負責創建隨機數的服務。

此服務將以單例表示（不能由任何其他類實例化的類）。

public class MyRandom { 

     private static MyRandom rdn = new MyRandom(); 

     private MyRandom() {} 

     public static MyRandom getInstance() { 
      return rdn; 
     } 

     public int getRandom(int min, int max) { 
      int range = max - min + 1; 
      double rndDouble = Math.random() * range; 
      int rndInt = (int) rndDouble + min; 
      return rndInt; 
     } 

    } 

該節點將只包含一個值（隨機數）和對下一個節點的引用。這是節點類

public class MyNode { 

     private final int value; 
     private MyNode next; 

     public MyNode(int value) { 
      this.value = value; 
      next = null; 
     } 

     public void setNext(MyNode next) { 
      this.next = next; 
     } 

     public int getValue() { 
      return value; 
     } 

     public MyNode getNext() { 
      return next; 
     } 
    } 

List類將包含對根節點的引用，它也將負責將新節點添加到列表中。

請記住，您也可以使用泛型。

public final class MyList { 

     private MyNode root; 

     public MyList(int maxNumber) { 
      for (int i = 0; i < maxNumber; i++) { 
       addNode(MyRandom.getInstance().getRandom(0, 99)); 
      } 
     } 

     public boolean isEmpty() { 
      return root == null; 
     } 

     public void addNode(int value) { 
      if (isEmpty()) { 
       root = new MyNode(value); 
      } else { 
       MyNode aux = root; 

       while (aux.getNext() != null) 
        aux = aux.getNext(); 

       aux.setNext(new MyNode(value)); 
      } 
     } 

     public void printList() { 
      if (!isEmpty()) { 
       MyNode aux = root; 
       while (aux.getNext() != null) { 
        System.out.println(aux.getValue()); 
        aux = aux.getNext(); 
       } 
       System.out.println(aux.getValue()); 
      } 
     } 

    } 

和主只能實例化MYLIST類並調用的printList顯示列表。

public class Main { 
     public static void main(String[] args) { 
      MyList lista = new MyList(10); 
      lista.printList(); 
     } 
    } 

希望這可以幫助你。