java programming language please help ASAP

Question

public abstract class Resit {

private int row;

private int column;

public int[ ][ ] table;

public Resit(int r, int c) {

row = r;

column = c;

table = new int[row][column];

}

public void hi() {

System.out.println("hi");

}

public abstract void fillTable();

public abstract int[][] transformTable();// if table elements greater than or equal to the “key” value, replace

// them with “1”, otherwise replace with “0”

/*for example, if table has following elements and the key=5:

10 2 3

4 5 6

3 8 1

Your method should return:

1 0 0

0 1 1

0 1 0

*/

public abstract int countOneTable(int[][] table); // returns total number of “1” in the transformed table

} // end of the Resit class

/*

* Write a class that uses the Resit abstract class defined above.

* The class should fill the table with random numbers between “0” and “upper bound” value.

* So, the class should have properties to hold the “upper bound” value and the “key”.

* Implement your class constructor considering (it means your constructor must get the upper bound value and the key) all cases and test all methods given in the “Resit” class.

* For invalid input, you should throw exceptions. */

Answer 1

public abstract class Resit

{

protected int row;

protected int column;

public int[][]table;

public Resit(int r,int c)

{

row=r; column=c;

table = new int [row][column];

}

public void hi()

{

System.out.println("hi");

}

public abstract void fillTable();

public abstract int[][] transformTable();

public abstract int countOneTable(int [][]table);

public int GetRows() { return(row); }

public int GetColumn() { return(column); }

}

//*****************************************************************

import java.util.Scanner;

import java.util.Random;

class PResit extends Resit

{

protected int maxUpperBound;

protected int iKeyValue;

PResit(int r, int c, int maxVal, int keyVal)

{

super(r,c);

maxUpperBound = maxVal;

iKeyValue = keyVal;

}

public void Input()

{

try

{

Scanner scanner = new Scanner(System.in);

for (int rowLoop=0; rowLoop<row; rowLoop++)

{

for (int columnLoop=0; columnLoop<column; columnLoop++)

{

int iNum=-1;

while (iNum<0 || iNum>maxUpperBound)

{

System.out.print(" Please input cell value between ZER0 and " + maxUpperBound + " at row " + (rowLoop+1) + " : column " + (columnLoop+1) + " :> ");

iNum = scanner.nextInt();

if (iNum>maxUpperBound || iNum<0)

{

System.out.println(" Invalid Input ");

}

else

{

table[rowLoop][columnLoop] = iNum;

}

} //while

} //columnLoop

} //rowLoop

scanner.close();

} //try

catch(Exception ex)

{

System.out.println("Input excpetion error occurs");

row=column=0;

table=null;

}

}

public Integer IndexerGetAtIndex( int iRow, int iColumn)

{

Integer intObjReturn=null;

if (iRow>=0 && iRow<row && iColumn>=0 && iColumn<column)

{

intObjReturn = new Integer(this.table[iRow][iColumn]);

}

return(intObjReturn);

}

public int[][] transformTable()

{

int matrixReturn[][] = new int[row][column];

for (int rowLoop=0; rowLoop<row; rowLoop++)

{

for (int columnLoop=0; columnLoop<column; columnLoop++)

{

matrixReturn[rowLoop][columnLoop] = (table[rowLoop][columnLoop]>=iKeyValue) ? 1 : 0;

}

}

return(matrixReturn);

}

public int countOneTable(int [][]table)

{

int hitCount=0;

for (int rowLoop=0; rowLoop<table.length; rowLoop++)

{

for (int columnLoop=0; columnLoop<table[rowLoop].length; columnLoop++)

{

if (table[rowLoop][columnLoop]==1) { hitCount++; }

}

}

return(hitCount);

}

public void fillTable()

{

Random myRandom = new Random();

for (int rowLoop=0; rowLoop<row; rowLoop++)

{

for (int columnLoop=0; columnLoop<column; columnLoop++)

{

int iNum = myRandom.nextInt()%maxUpperBound;

this.table[rowLoop][columnLoop] = (iNum<0) ? -iNum : iNum ;

}

}

}

public void dumpMatrix(int A[][],int rows, int columns, String strMsg)

{

if (strMsg!=null)

{

System.out.println("**************************************");

System.out.println(strMsg);

}

System.out.println("**************************************");

for (int rowLoop=0; rowLoop<rows; rowLoop++)

{

for (int columnLoop=0; columnLoop<columns; columnLoop++)

{

System.out.println(" row " + (rowLoop+1) + " : column " + (columnLoop+1) + " :> " + A[rowLoop][columnLoop]);

}

}

}

public void getMatrix(int A[][])

{

for (int rowLoop=0; rowLoop<row; rowLoop++)

{

for (int columnLoop=0; columnLoop<column; columnLoop++)

{

A[rowLoop][columnLoop] = this.table[rowLoop][columnLoop];

}

}

}

}

//***************************************************************

class PresitMain

{

public static void main(String args[])

{

int numRows,numColumns,maxVal,keyVal;

numRows=numColumns=3;

maxVal=12;

keyVal=5;

PResit x = new PResit(numRows,numColumns,maxVal,keyVal);

x.Input();

int bitMatrix[][] = x.transformTable();

x.dumpMatrix(bitMatrix,numRows,numColumns,null);

System.out.println(" # of 1s = " + x.countOneTable(bitMatrix));

System.out.println("*****************************");

PResit y = new PResit(numRows,numColumns,maxVal,keyVal);

y.fillTable();

int A[][] = new int[numRows][numColumns];

y.getMatrix(A);

y.dumpMatrix(A,numRows,numColumns,"Random");

}

}