Question

This is for a java lab, in class instruction we are not allowed to use "this". if anyone can help, and explain the importance of "this" and as to why we should or should not use it. Thank you in advanced.

A: Create a class called Tile. * An object of this class represents a tile in the game called Qwirkle. You can look up the description and game play instructions online A Qwirkle tile has two attributes: 1. · color-implement this as an integer between 1 and 6 (inclusive). The colors are orange, green, yello, red, blue, and purple. 2. shape- implement this as an integer between 1 and 6 (inclusive). The shapes are four-pointed star, clover, eight-pointed star, diamond, square, and circle A Qwirkle tile has typical object-oriented behaviors (only these) 1. create a tile with a given color and given shape 2. access the color of the tile 3. access the shape of the tile 4. change the color of the tile S. change the shape of the tile 6. provide a String representation of the tile 7. compare one tile for equality with another 8. clone a tile Reminder: Incremental Programming Write a little bit of code. Compile, debug. Repeat. B: Create a test program for the QwirkleBag class (.. .coming up in part C). Name your program QwirkleTester java. e Write a main method . Inside the main method, start with the statements QwirkleBag game1-new QwirkleBag) ystem.out.printin( "I created a new QwirkleBag. Here's what's in it:n") System.out.printin (game1)i * Now go to part C and do the steps at least up to the toString method. Then come back, compile, and run the test program.

Intarraybag.java:

public class IntArrayBag implements Cloneable
{

// instance variables

private int[ ] data;
private int manyItems;

// constructor : behavior #1

public IntArrayBag( )
{
final int INITIAL_CAPACITY = 10;

manyItems = 0;

data = new int[INITIAL_CAPACITY];
}

// another constructor : behavior #1

public IntArrayBag(int initialCapacity)
{
if (initialCapacity < 0)

throw new IllegalArgumentException
("The initialCapacity is negative: " + initialCapacity);

data = new int[initialCapacity];
manyItems = 0;
}
  

// add one item : behavior #2

public void add(int element)
{
if (manyItems == data.length)
{ // Ensure twice as much space as we need.
ensureCapacity((manyItems + 1)*2);
}

data[manyItems] = element;
manyItems++;
}

// add many items : behavior #3

public void addMany(int... elements)

// this is a variable arity method. We can specify as many parameters
// as needed

{
if (manyItems + elements.length
> data.length)
{ // Ensure twice as much space as we need.
ensureCapacity((manyItems + elements.length)*2);
}

System.arraycopy(elements, 0, data, manyItems, elements.length);
manyItems += elements.length;
}

public void addAll(IntArrayBag addend)
{
ensureCapacity(manyItems + addend.manyItems);

System.arraycopy(addend.data, 0, data, manyItems, addend.manyItems);
manyItems += addend.manyItems;
}

public IntArrayBag clone( )
{ // Clone an IntArrayBag object.
IntArrayBag answer;
  
try
{
answer = (IntArrayBag) super.clone( );
}
catch (CloneNotSupportedException e) {
throw new RuntimeException
("This class does not implement Cloneable");
}  
answer.data = data.clone( );
  
return answer;
}

// see the remainder of the IntArrayBag.java file in
// the Sept 7 notes

public int countOccurrences(int target)
{
int count = 0;
  
for (int index = 0; index < manyItems; index++)
if (target == data[index])
count++;

return count;
}
public void ensureCapacity(int minimumCapacity)
{
int biggerArray[ ]; // declaration
  
if (data.length < minimumCapacity)
{
biggerArray = new int[minimumCapacity]; // allocate space

System.arraycopy(data, 0, biggerArray, 0, manyItems);

data = biggerArray;  
}
}

  

public int getCapacity( )
{
return data.length;
}

  
public boolean remove(int target)
{
int index; // must declare before the loop

for (index = 0; (index < manyItems) && (target != data[index]);
index++)
;

if (index == manyItems) // target was not found
return false;
else
{  
manyItems--;
data[index] = data[manyItems];
return true;
}
}

public int size( )
{
return manyItems;
}


public void trimToSize( )
{
int trimmedArray[ ];
  
if (data.length != manyItems)
{
trimmedArray = new int[manyItems];
System.arraycopy(data, 0, trimmedArray, 0, manyItems);
data = trimmedArray;
}
}
  

public static IntArrayBag union(IntArrayBag b1, IntArrayBag b2)
{

// a call to this method would look like
// IntArrayBag.union( first IntArrayBag, second IntArrayBag )

// If either b1 or b2 is null, then a NullPointerException is
// thrown.
// In the case that the total number of items is beyond
// Integer.MAX_VALUE, there will be an arithmetic overflow and
// the bag will fail.

IntArrayBag answer = new IntArrayBag(b1.getCapacity( ) +   
b2.getCapacity( ));
  

// Dr. Steiner replaced the calls to System.arraycopy
// with two simple loops

for (int i = 0; i < b1.manyItems; i++)
answer.data[i] = b1.data[i];

for (int j = 0; j < b2.manyItems; j++)
answer.data[b1.manyItems + j] = b2.data[j];

answer.manyItems = b1.manyItems + b2.manyItems;
  
return answer;
}
  
}

Answer 1

"this" keyword works as a reference to the current object of the class. It is like a reminder to other programmers of the scope of variables. There are some arguments for and against the use of "this".Majorly it is to flag/tag the scope of any variable in a class.

One place where "this" is commonly used is constructors and setters. If you have started using "this" in your program make sure that this convention is strictly followed as it will be considered a local variable by other programmers if not marked "this".

it is necessary in some cases like:

class Test{
  int field1;

  public Test(int field1) {
    this.field1=field1;
  }
}

So if there are any common names among local variables(of any method of a class) and class variables, then only I would prefer use of this.