import java.awt.DisplayMode;
import java.util.Scanner;



public class mainClass {
	
	private static String[][] Cell;
	final static String normal="white";
	final String abnormal="green";
	final static String temp="red";
	
	
	public static void main(String []args){
	
		Scanner w = new Scanner(System.in);
		Cell c1 = new Cell();
		   //please implement the main method
			
			System.out.println("Please enter the size of the array: ");
			int size = w.nextInt();
			
			displayArray();

			c1.initializeColor(size);
			
			System.out.print("Please enter the the cordinates to chek: ");
			
			System.out.println("r: ");
			int x = w.nextInt();
			
			System.out.println("c: ");
			int y = w.nextInt();
			
			countCells( x, y);
			
			

	}//end main
	
	
	/*
	 *The method countCells is a RECURSIVE method whose job is to find
	 *how many cells are in the same blob as a given cell (i.e cell with
	 *specified coordinates x and y). The variable int size represents the
	 *size of the two-dimensional array. This value would have been provided
	 *by the user at the beginning of the main method.
         *Do NOT make any changes to the method declartion.
	 */
	
	public static int countCells( int x, int y){
		int count=0;
		
		for(int x1=0; x1<Cell.length; x1++)
			for(int y1=0; y1<Cell.length; y1++){
				 Cell[x][y]=normal;
			}
		
		for(int x1=0; x1<Cell.length; x1++)
			for(int y1=0; y1<Cell.length; y1++){
				if(getblobsize(x,y, Cell) > 0)
					count++;
			}
		System.out.print("The number of blobs: " + count);
		return count;
	
	}//countCells()
	



	private static int getblobsize(int r, int c, String Cell[][]) {
		
		if(r<0 || r>=Cell.length || c<0 || c>=Cell.length){
		return 0;
		}
		
		if(Cell[r][c] == temp || Cell[r][c] == normal){
			return 0;
		}
		
		else{
			int time=1;
			
			time += getblobsize( r - 1, c + 1, Cell);
			time += getblobsize( r, c + 1, Cell);
			time += getblobsize( r + 1, c + 1, Cell);
			time += getblobsize(r + 1, c, Cell);
			time += getblobsize( r + 1, c - 1, Cell);
			time += getblobsize( r, c - 1, Cell);
			time += getblobsize( r - 1, c - 1, Cell);
			time += getblobsize( r - 1, c, Cell);
			return time;

		}
	}
	


	
	/*
	 * The method diplayArray is provided for you to call when you want to
	 * display your array on the screen. You should know how and when to 
	 * to use this method in your program by looking at its declaration and
	 * the expected output.Do NOT make any changes to this method.
	 */

	public static void displayArray(Cell [][] ,int size){
		for(int i=0;i<size;i++){
			System.out.println();
			System.out.print("-");
			for(int j=0;j<size;j++){
				System.out.print("-+");
			}
			System.out.println();
			for (int j=0;j<size;j++){
				String color=cells[i][j].getColor();
				System.out.print("|"+color.charAt(0));
				
			}
			System.out.print("|");
			
		}//outer
		System.out.print("\n-");
		for(int j=0;j<size;j++){
			System.out.print("-+");
		}
	}//end displayArray()
	
}//end mainClass




This is the Cell class >>>>




public class Cell implements Interface1{
	
	private String color;
	final String normal="white";
	final String abnormal="green";
	final String temp="red";
	private int column;
	private int row;
	
	/*Please implement this class. Remember this class
	 * must implement all the methods declared in the interface
	 * Interface1.
	 */

	/**
	 * Method initializeColor will be used to initialize the color
	 * of each cell in the two-dimensional array.
	 * The cell can be one of two colors: "green" or "white". Whether 
	 * a cell will be "white" or "green" should be decided randomly.
	 * Since the assignment specifies that there should be more normal 
	 * (white) cells than abnormal (green) cells, you should devise an 
	 * algorithm that assigns:
	 * white: 70% of the time
	 * green: 30% of the time
	 * (hint:you can use Math.random() for this purpose)
	 */
	
	public void initializeColor(int size) {
		// TODO Auto-generated method stub
		Cell[][] Cell = new Cell[row][column];
		int d=(size*(70/100));
		int b=(size*(30/100));
		for (int size1 = 0; size1 < row; size1++){
			while(row <= d);{
				do([row] = setColor(normal););
				}
		}
			  for (int size1 = 0; size1 < column; size1++) {
					while(column <= b);{
						do([column] = setColor(abnormal););
						}
			  }
	}
	
	public String getColor() {
		// TODO Auto-generated method stub
		return null;
	}

	public void setColor(String color) {
		// TODO Auto-generated method stub
		this.normal;
		this.abnormal;
	}

	public void initializeColor() {
		// TODO Auto-generated method stub
		
	}


}

And this is the interface <>>>>




/**
 * Interface1 defines some constants and declares
 * some methods that must be implemented by the
 * class "Cell". The purpose of each method is
 * described below. Note the statement that says
 * public class Cell implements Interface1
 */
public interface Interface1 {
	final String normal="white";
	final String abnormal="green";
	final String temp="red";
	
	/**
	 * Method initializeColor will be used to initialize the color
	 * of each cell in the two-dimensional array.
	 * The cell can be one of two colors: "green" or "white". Whether 
	 * a cell will be "white" or "green" should be decided randomly.
	 * Since the assignment specifies that there should be more normal 
	 * (white) cells than abnormal (green) cells, you should devise an 
	 * algorithm that assigns:
	 * white: 70% of the time
	 * green: 30% of the time
	 * (hint:you can use Math.random() for this purpose)
	 */
	public void initializeColor();
	
	/**
	 * The method setColor is a typical setter method that
	 * sets the color of a given cell to a certain color.
	 * This method is needed especially to re-color a cell
	 * to a temporary color (i.e "red")
	 */
	public void setColor(String color);
	
	/**
	 * The method getColor will return the color of the 
	 * specified cell. This method is called to identify
	 * the color of the cell.
	 */
	public String getColor();

}