I can't get my reflection to work in this project. [TicTacToe]

So I'm doing this assignment for my CS 2 class and we are supposed to use reflection to do tic tac toe. I'm trying to do reflection based off of the example given by the teacher on line. I have hit a wall. I was trying to connect everything together in a basic MVC fashion. Could somebody point me in the right direction to get my reflection to work? I've looked at a few examples and I'm trying to base my version off of one the teacher gave me.

I'll post my classes here:

marker class

public enum TTTMarker {

	EX, OH, NONE
}

Player class

public class TTTPlayer
{

	private String name;
	private int wins;
	private TTTMarker marker;

	public TTTPlayer( String name ) 
	{
		this.name = name;
	}
	
	public void reset() 
	{
		name = "";
		wins = 0;
	}

	public void addWin() 
	{
		wins++;
	}
	
	public void clearWins() 
	{
		wins = 0;
	}

	public int getWins()
	{
		return wins;
	}

	public String getName()
	{
		return name;
	}

	public void setName(String name)
	{
		this.name = name;
	}

	public TTTMarker getMarker()
	{
		return marker;
	}

	public void setMarker(TTTMarker marker)
	{
		this.marker = marker;
	}
}

model class:

public class TTTModel
{
	private int boardSize;
	private TTTMarker[][] board;
	
	private TTTPlayer player1;
	private TTTPlayer player2;
	
	private int numDraws;
	private boolean inProgress;
	private TTTMarker whoseTurn;

	
	public TTTModel( String xName, String oName, int dim ) 
	{
		player1 = new TTTPlayer(xName);
		player2 = new TTTPlayer(oName);
		boardSize = dim;
		board = new TTTMarker[dim][dim];
	}

	public boolean makeMove(int row, int col) 
	{
		if(board[row][col] != TTTMarker.NONE)
		{
			return false; 
		}
		else
		{
			board[row][col] = whoseTurn;
			return true;
		}
	}

	/**
	 * X always goes first
	 */
	public void startGame() 
	{
		resetBoard();
		// TBD
	}

	public void resetBoard() 
	{
		for(int i = 0; i <= boardSize; i++)
		{
			for(int j = 0; j <= boardSize; j++)
				board[i][j] = TTTMarker.NONE;
		}
	}
	public void setBoardSize(int B)/>/>
	{
		board = new TTTMarker[b][b];
		boardSize = b;
		resetBoard();
	}

	public boolean isValidMove(int row, int col) 
	{
		if(board[row][col] == TTTMarker.NONE)
			return true;
		else
			return false; 
	}

	public boolean haveWinner() 
	{
		//checks victories of columns
		if(board[0][0] == TTTMarker.EX && board[0][1] == TTTMarker.EX && board[0][2] == TTTMarker.EX)
			return true;
		else if(board[1][0] == TTTMarker.EX && board[1][1] == TTTMarker.EX && board[1][2] == TTTMarker.EX)
			return true;
		else if(board[2][0] == TTTMarker.EX && board[2][1] == TTTMarker.EX && board[2][2] == TTTMarker.EX)
			return true;
		
		else if(board[0][0] == TTTMarker.EX && board[1][0] == TTTMarker.EX && board[2][0] == TTTMarker.EX)
			return true;
		else if(board[0][1] == TTTMarker.EX && board[1][1] == TTTMarker.EX && board[2][1] == TTTMarker.EX)
			return true;
		else if(board[0][2] == TTTMarker.EX && board[1][2] == TTTMarker.EX && board[2][2] == TTTMarker.EX)
			return true;
		
		//checks victories of rows
		else if(board[0][0] == TTTMarker.OH && board[0][1] == TTTMarker.OH && board[0][2] == TTTMarker.OH)
			return true;
		else if(board[1][0] == TTTMarker.OH && board[1][1] == TTTMarker.OH && board[1][2] == TTTMarker.OH)
			return true;
		else if(board[2][0] == TTTMarker.OH && board[2][1] == TTTMarker.OH && board[2][2] == TTTMarker.OH)
			return true;
		
		else if(board[0][0] == TTTMarker.OH && board[1][0] == TTTMarker.OH && board[2][0] == TTTMarker.OH)
			return true;
		else if(board[0][1] == TTTMarker.OH && board[1][1] == TTTMarker.OH && board[2][1] == TTTMarker.OH)
			return true;
		else if(board[0][2] == TTTMarker.OH && board[1][2] == TTTMarker.OH && board[2][2] == TTTMarker.OH)
			return true;
		
		//checks diagnol victories
		else if(board[0][0] == TTTMarker.OH && board[1][1] == TTTMarker.OH && board[2][2] == TTTMarker.OH)
			return true;
		else if(board[0][0] == TTTMarker.EX && board[1][1] == TTTMarker.EX && board[2][2] == TTTMarker.EX)
			return true;
		else if(board[2][0] == TTTMarker.OH && board[1][1] == TTTMarker.OH && board[0][2] == TTTMarker.OH)
			return true;
		else if(board[2][0] == TTTMarker.EX && board[1][1] == TTTMarker.EX && board[0][2] == TTTMarker.EX)
			return true;
		
		return false; 
	}
	
	public boolean isDraw()	
	{
		boolean[] colO = new boolean[boardSize];
		boolean[] rowO = new boolean[boardSize];
		
		boolean[] colX = new boolean[boardSize];
		boolean[] rowX = new boolean[boardSize];
		
		for(int i = 0; i <= boardSize; i++)
		{
			if(board[i][0] == TTTMarker.EX)
				rowX[i] = true;
			if(board[i][0] == TTTMarker.OH)
				rowO[i] = true;
			
			for(int j = 0; j <= boardSize; j++)
			{
				if(board[i][j] == TTTMarker.EX)
					colX[j] = true;
				if(board[i][j] == TTTMarker.OH)
					colO[j] = true;
			}
		}
		
		int count = 0;
		int l;
		for(int n = 0; n <= boardSize; n++)
		{
			l = n+1;
			if(l > boardSize)
				l = 0;
			if(l == 0)
				l+=1;
			
			if(rowO[n] == true && rowX[n] == true)
			{
				count++;
				if(colO[n] == true && colX[n] == true)
					count++;
			}
			
		}
		
		if(board[0][0] == TTTMarker.EX && board[2][2] == TTTMarker.OH)
			count++;
		if(board[0][0] == TTTMarker.OH && board[2][2] == TTTMarker.EX)
			count++;
		if(board[2][0] == TTTMarker.EX && board[0][2] == TTTMarker.OH)
			count++;
		if(board[2][0] == TTTMarker.OH && board[0][2] == TTTMarker.EX)
			count++;
		
		if(count == 8)
		{
			numDraws++;
			return true;
		}
		else
			return false;
		
	}
	
	public TTTMarker getWhoseTurn() 
	{
		return whoseTurn; 
	}

	public void setWhoseTurn( TTTMarker marker ) 
	{
		whoseTurn = marker;
	}
	
	public boolean getInProgress() 
	{
		return inProgress;
	}
	
	public int getNumDraws() 
	{
		return numDraws;
	}
	
	public int getWinsPlayer1() 
	{
		return player1.getWins(); // TBD
	}
	
	public int getWinsPlayer2() 
	{
		return player2.getWins(); // TBD
	}

	public String getNamePlayer1() 
	{
		return player1.getName(); // TBD
	}

	public String getNamePlayer2() 
	{
		return player2.getName();
	}
}

viewer (i was told to use window builder, so I did. Now I don't know how to get reflection working):

import java.awt.EventQueue;

import javax.swing.JFrame;

import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.BorderLayout;
import javax.swing.GroupLayout;
import javax.swing.GroupLayout.Alignment;
import javax.swing.JButton;
import javax.swing.LayoutStyle.ComponentPlacement;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.event.MouseListener;

import javax.swing.JLabel;
import javax.swing.JMenuBar;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import java.awt.Font;
import java.lang.reflect.Method;

public class TTTView extends Frame{

	private JFrame frmTicTacToe;
	
	private TTTController controller;
	private TTTButtonListener listener0;
	private TTTButtonListener listener1;
	private TTTButtonListener listener2;
	private TTTButtonListener listener3;
	private TTTButtonListener listener4;
	private TTTButtonListener listener5;
	private TTTButtonListener listener6;
	private TTTButtonListener listener7;
	private TTTButtonListener listener8;
	private TTTButtonListener listenerNewGame;
	private TTTButtonListener listenerNewMatch;
	
	private JButton button0, button1, button2, button3, button4,button5,button6,button7,button8, btnNewGame, btnNewMatch;
	
	/**
	 * Launch the application.
	 */
	public static void main(String[] args) {
		
		final TTTController controller = new TTTController();
		
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				try {
					TTTView window = new TTTView(controller);
					window.frmTicTacToe.setVisible(true);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	/**
	 * Create the application.
	 */
	public TTTView(TTTController controller) 
	{
		this.associateListeners(controller);
		initialize();
	}

	/**
	 * Initialize the contents of the frame.
	 */
	private void initialize() 
	{
		frmTicTacToe = new JFrame();
		frmTicTacToe.setTitle("Tic Tac Toe");
		frmTicTacToe.setBounds(100, 100, 541, 254);
		frmTicTacToe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		button0 = new JButton("");
		button0.addMouseListener(listener0);
		
		button1 = new JButton("");
		button1.addMouseListener(listener1);
		button2 = new JButton("");
		button2.addMouseListener(listener2);
		button3 = new JButton("");
		button3.addMouseListener(listener3);
		button4 = new JButton("");
		button4.addMouseListener(listener4);
		button5 = new JButton("");
		button5.addMouseListener(listener5);
		button6 = new JButton("");
		button6.addMouseListener(listener6);
		button7 = new JButton("");
		button7.addMouseListener(listener7);
		button8 = new JButton("");
		button8.addMouseListener(listener8);
		
		JLabel lblPlayer1 = new JLabel("Player 1:");
		lblPlayer1.setFont(new Font("Tahoma", Font.BOLD, 11));
		
		JLabel lblPlayer2 = new JLabel("Player 2:");
		lblPlayer2.setFont(new Font("Tahoma", Font.BOLD, 11));
		
		JLabel lblNamePlayer1 = new JLabel("New label");
		
		JLabel lblNamePlayer2 = new JLabel("New label");
		
		JLabel lblPlayer1Wins = new JLabel("Wins:");
		lblPlayer1Wins.setFont(new Font("Tahoma", Font.BOLD, 11));
		
		JLabel lblPlayer2Wins = new JLabel("Wins:");
		lblPlayer2Wins.setFont(new Font("Tahoma", Font.BOLD, 11));
		
		JLabel lblP1NumberWins = new JLabel("New label");
		
		JLabel lblP2NumberWins = new JLabel("New label");
		
		JLabel lblDraws = new JLabel("Number of Draws:");
		lblDraws.setFont(new Font("Tahoma", Font.BOLD, 11));
		
		JLabel lblNumberDraws = new JLabel("New label");
		
		btnNewGame = new JButton("New Game");
		btnNewGame.addMouseListener(listenerNewGame);
		btnNewMatch = new JButton("New Match");
		btnNewMatch.addMouseListener(listenerNewMatch);
		
		GroupLayout groupLayout = new GroupLayout(frmTicTacToe.getContentPane());
		groupLayout.setHorizontalGroup(
			groupLayout.createParallelGroup(Alignment.LEADING)
				.addGroup(groupLayout.createSequentialGroup()
					.addGap(28)
					.addGroup(groupLayout.createParallelGroup(Alignment.LEADING)
						.addGroup(groupLayout.createSequentialGroup()
							.addComponent(button3, GroupLayout.PREFERRED_SIZE, 62, GroupLayout.PREFERRED_SIZE)
							.addPreferredGap(ComponentPlacement.RELATED)
							.addComponent(button4, GroupLayout.PREFERRED_SIZE, 62, GroupLayout.PREFERRED_SIZE)
							.addPreferredGap(ComponentPlacement.RELATED)
							.addComponent(button5, GroupLayout.PREFERRED_SIZE, 62, GroupLayout.PREFERRED_SIZE))
						.addGroup(groupLayout.createSequentialGroup()
							.addComponent(button0, GroupLayout.PREFERRED_SIZE, 62, GroupLayout.PREFERRED_SIZE)
							.addPreferredGap(ComponentPlacement.RELATED)
							.addComponent(button1, GroupLayout.PREFERRED_SIZE, 62, GroupLayout.PREFERRED_SIZE)
							.addPreferredGap(ComponentPlacement.RELATED)
							.addComponent(button2, GroupLayout.PREFERRED_SIZE, 62, GroupLayout.PREFERRED_SIZE))
						.addGroup(groupLayout.createSequentialGroup()
							.addPreferredGap(ComponentPlacement.RELATED)
							.addComponent(button6, GroupLayout.PREFERRED_SIZE, 62, GroupLayout.PREFERRED_SIZE)
							.addPreferredGap(ComponentPlacement.RELATED)
							.addComponent(button7, GroupLayout.PREFERRED_SIZE, 62, GroupLayout.PREFERRED_SIZE)
							.addPreferredGap(ComponentPlacement.RELATED)
							.addComponent(button8, GroupLayout.PREFERRED_SIZE, 62, GroupLayout.PREFERRED_SIZE)))
					.addGap(66)
					.addGroup(groupLayout.createParallelGroup(Alignment.LEADING)
						.addComponent(btnNewMatch)
						.addComponent(btnNewGame)
						.addGroup(groupLayout.createSequentialGroup()
							.addGroup(groupLayout.createParallelGroup(Alignment.LEADING)
								.addComponent(lblPlayer1)
								.addComponent(lblPlayer2))
							.addPreferredGap(ComponentPlacement.UNRELATED)
							.addGroup(groupLayout.createParallelGroup(Alignment.LEADING)
								.addComponent(lblNamePlayer2)
								.addComponent(lblNamePlayer1))
							.addPreferredGap(ComponentPlacement.UNRELATED)
							.addGroup(groupLayout.createParallelGroup(Alignment.LEADING)
								.addComponent(lblPlayer2Wins)
								.addComponent(lblPlayer1Wins))
							.addGap(18)
							.addGroup(groupLayout.createParallelGroup(Alignment.LEADING)
								.addComponent(lblP2NumberWins)
								.addComponent(lblP1NumberWins)))
						.addGroup(groupLayout.createSequentialGroup()
							.addComponent(lblDraws)
							.addPreferredGap(ComponentPlacement.RELATED)
							.addComponent(lblNumberDraws)))
					.addContainerGap(24, Short.MAX_VALUE))
		);
		groupLayout.setVerticalGroup(
			groupLayout.createParallelGroup(Alignment.LEADING)
				.addGroup(groupLayout.createSequentialGroup()
					.addContainerGap()
					.addGroup(groupLayout.createParallelGroup(Alignment.LEADING)
						.addGroup(groupLayout.createSequentialGroup()
							.addGroup(groupLayout.createParallelGroup(Alignment.BASELINE)
								.addComponent(lblPlayer1)
								.addComponent(lblNamePlayer1)
								.addComponent(lblPlayer1Wins)
								.addComponent(lblP1NumberWins))
							.addPreferredGap(ComponentPlacement.UNRELATED)
							.addGroup(groupLayout.createParallelGroup(Alignment.BASELINE)
								.addComponent(lblPlayer2)
								.addComponent(lblNamePlayer2)
								.addComponent(lblPlayer2Wins)
								.addComponent(lblP2NumberWins))
							.addGap(18)
							.addGroup(groupLayout.createParallelGroup(Alignment.BASELINE)
								.addComponent(lblDraws)
								.addComponent(lblNumberDraws))
							.addPreferredGap(ComponentPlacement.UNRELATED)
							.addComponent(btnNewGame)
							.addPreferredGap(ComponentPlacement.UNRELATED)
							.addComponent(btnNewMatch))
						.addGroup(groupLayout.createSequentialGroup()
							.addGroup(groupLayout.createParallelGroup(Alignment.LEADING)
								.addComponent(button1, GroupLayout.PREFERRED_SIZE, 43, GroupLayout.PREFERRED_SIZE)
								.addComponent(button0, GroupLayout.PREFERRED_SIZE, 43, GroupLayout.PREFERRED_SIZE)
								.addComponent(button2, GroupLayout.PREFERRED_SIZE, 43, GroupLayout.PREFERRED_SIZE))
							.addPreferredGap(ComponentPlacement.UNRELATED)
							.addGroup(groupLayout.createParallelGroup(Alignment.TRAILING)
								.addComponent(button4, GroupLayout.PREFERRED_SIZE, 43, GroupLayout.PREFERRED_SIZE)
								.addComponent(button5, GroupLayout.PREFERRED_SIZE, 43, GroupLayout.PREFERRED_SIZE)
								.addComponent(button3, GroupLayout.PREFERRED_SIZE, 43, GroupLayout.PREFERRED_SIZE))
							.addPreferredGap(ComponentPlacement.RELATED)
							.addGroup(groupLayout.createParallelGroup(Alignment.LEADING)
								.addComponent(button8, GroupLayout.PREFERRED_SIZE, 43, GroupLayout.PREFERRED_SIZE)
								.addComponent(button7, GroupLayout.PREFERRED_SIZE, 43, GroupLayout.PREFERRED_SIZE)
								.addComponent(button6, GroupLayout.PREFERRED_SIZE, 43, GroupLayout.PREFERRED_SIZE))))
					.addContainerGap(59, Short.MAX_VALUE))
		);
		frmTicTacToe.getContentPane().setLayout(groupLayout);
	}
	
	//this starts the reflection
	public void associateListeners(TTTController controller)
	{
		Class<? extends TTTController> controllerClass;
		Method makeMoveMethod, checkDrawMethod, checkWinMethod, newGameMethod, newMatchMethod;
		
		
		
		Object [] params = new Object[11];
		for(int i = 0; i < params.length; i++)
		{
			params[i] = i;
		}
		
		Class [] args = {int.class};
		
		controllerClass = controller.getClass();
		makeMoveMethod = null;
		checkDrawMethod = null;
		checkWinMethod = null;
		newGameMethod = null;
		newMatchMethod = null;
		
		try
		{

			makeMoveMethod = controllerClass.getMethod("makeMove", args);
			checkDrawMethod = controllerClass.getMethod("checkDraw", (Class<?>[])null);
			checkWinMethod = controllerClass.getMethod("checkWin", (Class<?>[])null);
			newGameMethod = controllerClass.getMethod("newGame", args);
			newMatchMethod = controllerClass.getMethod("newMatch", args);
			
			
		}
		catch(NoSuchMethodException exception)
		{
			String error;
			error = exception.toString();
			System.out.println(error);
		}
		catch(SecurityException exception)
		{
			String error;
			error = exception.toString();
			System.out.println(error);
		}
		
		
		
		//NEED TO NAME METHODS HEAR
		listener0  = new TTTButtonListener(controller, makeMoveMethod,0);
		listener1  = new TTTButtonListener(controller, makeMoveMethod,1);
		listener2  = new TTTButtonListener(controller, makeMoveMethod,2);
		listener3  = new TTTButtonListener(controller, makeMoveMethod,3);
		listener4  = new TTTButtonListener(controller, makeMoveMethod,4);
		listener5  = new TTTButtonListener(controller, makeMoveMethod,5);
		listener6  = new TTTButtonListener(controller, makeMoveMethod,6);
		listener7  = new TTTButtonListener(controller, makeMoveMethod,7);
		listener8  = new TTTButtonListener(controller, makeMoveMethod,8);
		listenerNewGame = new TTTButtonListener(controller,newGameMethod,9);
		listenerNewMatch = new TTTButtonListener(controller, newMatchMethod,10);
	}
	
	public void setButtonText(TTTMarker mark)
	{
		if(mark == TTTMarker.EX)
			button0.setText("X");
		else
			button0.setText("O");
	}
	
}

now the controller class(another area of contention for me with reflection)

public class TTTController 
{
	private TTTView myView;
	private TTTModel myModel;
	private int position;
	
	public TTTController()
	{
		myModel = new TTTModel("Bill", "Bob", 3);
		myView = new TTTView(this);
		
	}
	
	
	public void makeMove(int params)
	{
		
		if(params == 0)
		{
			myModel.makeMove(0, 0);
			myView.setButtonText(myModel.getWhoseTurn());
		}
			
		else if(params == 1)
		{
			myModel.makeMove(0, 1);
			myView.setButtonText(myModel.getWhoseTurn());
		}
		else if(params == 2)
		{
			myModel.makeMove(0, 2);
			myView.setButtonText(myModel.getWhoseTurn());
		}
		else if(params == 3)
		{
			myModel.makeMove(1, 0);
			myView.setButtonText(myModel.getWhoseTurn());
		}
		else if(params == 4)
		{
			myModel.makeMove(1, 1);
			myView.setButtonText(myModel.getWhoseTurn());
		}
		else if(params == 5)
		{
			myModel.makeMove(1, 2);
			myView.setButtonText(myModel.getWhoseTurn());
		}
		else if(params == 6)
		{
			myModel.makeMove(2, 0);
			myView.setButtonText(myModel.getWhoseTurn());
		}
		else if(params == 7)
		{
			myModel.makeMove(2, 1);
			myView.setButtonText(myModel.getWhoseTurn());
		}
		else if(params == 8)
		{
			myModel.makeMove(2, 2);
			myView.setButtonText(myModel.getWhoseTurn());
		}
	}
	
	public void newGame(int params)
	{
		if(params == 9)
			myModel.resetBoard();
	}
	public void newMatch(int params)
	{
		if(params == 10)
			myModel.resetBoard();
	}
	
	public void checkDraw()
	{
		myModel.isDraw();
	}
	
	public void checkWin()
	{
		myModel.haveWinner();
	}
	
	
	public void setPosition(int position)
	{
		this.position = position;
	}
	public int getPosition()
	{
		return position;
	}
}

now the button listener class. I know that my problem is between the last three classes and having the controller talk to the model.

import java.awt.event.MouseEvent;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.awt.event.MouseAdapter;
import java.lang.IllegalAccessException;

public class TTTButtonListener extends MouseAdapter
{
	private Object myController;
	private Method myMethod;
	private int myParams;
	
	public TTTButtonListener(Object controller, Method method, int param)
	{
		myController = controller;
		myMethod = method;
		myParams = param;
	}
	
	public void mouseReleased(MouseEvent event)
	{
		Method method;
		Object controller;
		int params;
		
		method = this.getMethod();
		controller = this.getController();
		params = this.getParam();
		
		try
		{
			method.invoke(controller, params);
		}
		catch(InvocationTargetException exception)
        {
            System.out.println("InvocationTargetException");
        }
        catch(IllegalAccessException exception)
        {
            System.out.println("IllegalAccessException");
        }
        catch(IllegalArgumentException exception)
        {
            System.out.println("IllegalArgumentException");
        }
	}

	private Object getController() 
	{
		return myController;
	}

	private Method getMethod() 
	{
		return myMethod;
	}
	
	private int getParam()
	{
		return myParams;
	}
	
	public void setParam(int pos)
	{
		myParams = pos;
	}
	
	public void setMethod(Method method)
	{
		myMethod = method;
	}
	public void setController(Object controller)
	{
		myController = controller;
	}
}

Thanks for taking the time to look this over.

Much Abliged,
Fixer