How to convert this procedural programming to object-oriented programming?

Question

I have a source code that is needed to be converted by creating classes, objects and methods. So far, I've just done by converting the initial main into a separate class. But I don't know what to do with constructor and which variables are supposed to be private. This is the code : ``` import java.util.*; public class Card{ private static void shuffle(int[][] cards){ List randoms = new ArrayList(); Random randomizer = new Random(); for(int i = 0; i < 8;) { int r = randomizer.nextInt(8)+1; if(!randoms.contains(r)) { randoms.add(r); i++; } } List clonedList = new ArrayList(); clonedList.addAll(randoms); Collections.shuffle(clonedList); randoms.addAll(clonedList); Collections.shuffle(randoms); int i=0; for(int r=0; r < 4; r++){ for(int c=0; c < 4; c++){ cards[r][c] = randoms.get(i); i++; } } } public static void play() throws InterruptedException { int ans = 1; int preview; int r1,c1,r2,c2; int[][] cards = new int[4][4]; boolean[][] cardstatus = new bo…

Accepted Answer

But I don't know what to do with constructor and which variables are supposed to be private.

Whatever can be, should be `private`. To determine this, it's often easiest to mark everything `private`, and then when you hit a "pain point" promote it to `public`.

As for what classes you need, take a look at the existing code for "smells" such as:

```
int[][] cards = new int[4][4];
```

You have a "named primitive"1 there - and it's used quite often. This makes it an important noun to your program. Encapsulate it into a class:

```
public class Cards {
   private int[][] cards = new int[4][4];
}
```

Now, look for where you're manipulating that named primitive:

```
shuffle(cards);

for (int i = 0; i < 4; i++){
   for (int j = 0; j < 4; j++){
       System.out.print(cards[i][j]);
       System.out.print(" ");
   }
   System.out.println("");
   System.out.println("");
}
```

Those are prime targets for methods:

```
public class Cards {
   private int[][] cards = new int[4][4];

public void shuffle() {
      // existing shuffle method goes here - but works with private cards
   }

public void print() {
      for (int i = 0; i < 4; i++){
        for (int j = 0; j < 4; j++){
           System.out.print(cards[i][j]);
           System.out.print(" ");
        }
      System.out.println("");
      System.out.println("");
   }
}
```

And, then - look at easy ways to generalize. `Cards` currently is hardcoded to a 4 x 4 board - let's parameterize that:

```
public class Cards {
   private int width;
   private int length;
   private int[][] cards;

public void shuffle() {
      // existing shuffle method goes here - but works with private cards
   }

public void print() {
      for (int i = 0; i < length; i++){
        for (int j = 0; j < width; j++){
           System.out.print(cards[i][j]);
           System.out.print(" ");
        }
      System.out.println("");
      System.out.println("");
   }
}
```

Now we need someone to provide the `length` and `width` - that's what constructors are for:

```
public class Cards {
    private int width;
    private int length;
    private int[][] cards;

public Cards(int length, int width) {
      this.length = length;
      this.width = width;
      this.cards = new int[length][width];
   }

public void shuffle() {
      // existing shuffle method goes here - but works with private cards
   }

public void print() {
      for (int i = 0; i < length; i++){
        for (int j = 0; j < width; j++){
           System.out.print(cards[i][j]);
           System.out.print(" ");
        }
      System.out.println("");
      System.out.println("");
   }
}
```

And, then we realize that `Cards` isn't such a good name for this...It's more of a `Board` - rename it and move on to the next "named primitive" or smell2.

1 I use "named primitive" to indicate the same primitive type that is either global or passed around between methods with the same name. Since there is no class, the semantic meaning is purely in the name - often that name is a great starting point for a class. It's related to the well-known "primitive obsession" code smell, but slightly different in that it doesn't require a large number of primitive types masquerading as a class. A single named primitive can be promoted to a class.

2 A lot of the code smells are particular to OOP code. For looking at procedural code that you're trying to convert to OO, I think "primitive obsession", "data clumps", "message chains", and "long parameter lists" are the most relevant.

How to convert this procedural programming to object-oriented programming?

Solution

Problem