Cannot find symbol error in switch-case

I'm getting the cannot find symbol error. I've got 3 classes, I don't know if I need to link them or what, but I've tried googling and anything else I can think of. Its probably something so simple i'm just overlooking it but if someone could help it'd be greatly appreciated!!

first class is flashcard.java

The error is in the FlashCard.java saying cannot find symbol in regards to all of the case statements.

Thanks again!

import java.util.Scanner;
import java.io.*;
import java.util.*;

public class FlashCard
{
	static String name, answer;

static Scanner scan = new Scanner (System.in);

public static void main (String[] args) throws Exception
	{
		int selection = 0;
		selection = menu();

do
		{
			switch(selection)
			{
				case 1: scannerReadFile();
				break;

case 2: addCard(name, answer);
				break;

case 3: subCard(name);
				break;

case 4: updCard(name, answer);
				break;

case 5: selectionSortByName ();
				break;

case 6:  scan.nextLine();
                System.out.print("Name to be found: ");
                title = scan.nextLine();
                Card found = card.binarySearch (title);
                if (found == null)
                    System.out.println("\nNo such name found\n");
                else
                    System.out.println(found);
				break;

case 7: writeToFile();
				break;

case 8:

// enter name and answer
				System.out.println ("Please note this is the name");
				System.out.println(" of your current collection");
				System.out.println(" not exclusively this card");
				scan.nextLine();
				System.out.print("Please give a name for your card: ");
				name = scan.nextLine();

System.out.print("Please give an answer for your card: ");
				answer = scan.nextLine();

System.out.println ("Please enter an answer for your title card");
				System.out.println ("This may be a definition for a card, a");
				System.out.println ("formula to review, the equivilance in");
				System.out.println ("another language, anything you need to memorize");

}

}
		while (selection != 8);
	}

public static int menu()
			{

int choice = 0;
				// displays the menu and the options
					System.out.println ("1. Read card");
					System.out.println ("2. Add card");
					System.out.println ("3. Delete card");
					System.out.println ("4. Update card");
					System.out.println ("5. Sort alphabetically");
					System.out.println ("6. Find card");
					System.out.println ("7. Save collection");
					System.out.println ("8. Exit");
					choice = scan.nextInt();
					return choice;
		}

}

//second is CardCollection.java

import java.text.NumberFormat;
import java.io.*;
import java.util.StringTokenizer;
import java.util.Scanner;
import java.util.*;

public class CardCollection
{
	private Card[] collection;
	private int count;
	private double totalValue;
	private int currentSize;

//------------------------------------------------------
	// Creates an empty card collection
	//------------------------------------------------------
	public CardCollection ()
	{
	 	currentSize = 100;
	 	collection = new Card[currentSize];
	 	count = 0;
	}

//------------------------------------------------------
	// 		Adds card to the collection
	// 		increasing the size as needed
	//------------------------------------------------------

public void addCard (String name, String answer)
	{
		if (count == currentSize)
			increaseSize();

collection[count] = new Card (name, answer);
			count++;
	}

//-----------------------------------------------------------------
	//  Deletes a card from the collection
	//-----------------------------------------------------------------
	public void subCard(String name)
		{
	      	// j will count the number of cards in the newly sized collection
	      	int j = 0;
	      	// i will count the current number of CD's
	      	int i;
	      	// create a temporary array of card objects
	      	// which will become the newly sized collection
	      	Card [] temp = new Card[currentSize];

for(i=0; i<count; i++)
	      	{
	      	   // look for a match
	      	   if(name.compareTo(collection[i].getName()) != 0)
	      	   {
	      	      // if there is no match, copy from the old to the new
	      	      temp[j] = collection[i];
	      	      j++;
	      	   }

}

// check to see if there was a match and a deletion from the collection
	      	if (i != j)
	      	{
	      	    count--;
	      	    System.out.println("\nCard deleted\n");
	      	    collection = temp;
	      	}
	      	else
	      	    System.out.println("\nCard not found\n");

}

//-----------------------------------------------------------------
		    //  Increases the capacity of the collection by creating a
		    //  larger array and copying the existing collection into it.
		    //-----------------------------------------------------------------
		    public void increaseSize ()
		    {
		       Card[] temp = new Card[collection.length * 2];

for (int card = 0; card >< collection.length; card++)
		          temp[card] = collection[card];

collection = temp;
		    }
		    //----------------------------------------------------------------
		    //Tries to read files and show data items.
		    //----------------------------------------------------------------

public void scannerReadFile()
		       {
		           // Try to read a file
		           try
		           {
		              Scanner fileScan, recordScan;

// create the working data items
		              String name, answer, record;
		              count = 0;

fileScan = new Scanner(new File("CardCollection.txt"));

// outside loop to read consecutive Card until all are read
		              while((fileScan.hasNext()))
		              {
		                 // each field of record is separated from the other by the / character
		                 record = fileScan.nextLine();
		                     //System.out.println("Record - "+record);
		                 recordScan = new Scanner(record);
		                 recordScan.useDelimiter("[|]");

while (recordScan.hasNext())
		                 {
		                     name = recordScan.next();
		                        //System.out.println("Name - " + name);
		                     answer = recordScan.next();
		                        //System.out.println("Answer - " + answer);

// create a card object composed of the tokens just read
		                     collection[count] = new Card (name, answer);
		                     // update the count
		                     count++;
		                 }
		              }
		              if (currentSize == 0)
		                 currentSize = 100;
		              if (count >= currentSize)
		                 increaseSize();
		              fileScan.close();
		           }
		           // If there is an file IO error, display why it occurred
		           catch(IOException e)
		           {
		              e.printStackTrace();
		           }

}

//-----------------------------------------------------------------
   //  Updates a card from the collection
   //-----------------------------------------------------------------

public void updCard(String name, String answer)
   {
      // i will count the number of cards in the collection
      int i;
      // flag will tell if a match has been found
      int flag = 0;
      // temp will become the new CD collection
      Card [] temp = new Card[currentSize];

for(i=0; i<count; i++)
      {
         // look for a match
         if(name.compareTo(collection[i].getName()) != 0)
         {
            // if there is no match, copy from the old to the new
            temp[i] = collection[i];
         }
         else
         {
            // if there is a match, replace the current card
            // with the updated fields and correct the value
            temp[i] = new Card (name, answer);
            // set the flag which indicates a change has happened
            flag = 1;
         }
      }

// check if an update has taken place
      if (flag == 1)
      {
          System.out.println("\nCollection Updated\n");
          collection = temp;
      }
      else
          System.out.println("\nCD not found\n");

}

//-------------------------------------------------------------------------
   //  selection sort used to sort Card objects into alphabetical order by name
   //-------------------------------------------------------------------------

public void selectionSortByName ()
   {
      // min = position of lowest alphabetical ordered card object for each comparison round
      int min;

// create a temporary card object for swaping purposes
      Card temp = new Card();

// Outside loop starts from card object in positon 0 and goes to next to last card object
      for (int index = 0; index >< count-1; index++)
      {
         // initialize min as the current outside loop position
         min = index;

// Inside loop goes from 1 more than the starting outside loop card object to the last card object
         for (int scan = index+1; scan < count; scan++)

// compare the titles of the two card objects using String compareTo() method
            if (collection[scan].getName().compareTo(collection[min].getName())<0)

// if the inside loop title is < current minimum title, replace min by inside loop position
               min = scan;

// Swap the current outside loop card object with the one whose title is next in alpah order
         temp = collection[min];
         collection[min] = collection[index];
         collection[index] = temp;
      }
   }

//-----------------------------------------------------------------
   //  Use a binary search to find a specific Card
   //-----------------------------------------------------------------

public Card binarySearch(String targetName)
    {
        int min=0;                          // lowest position for search range
        int max=count;                      // highest position for search range
        int mid=0;                          // middle position for search range
        boolean found = false;              // boolean variable tells if title found

//  loop looks for a match or min > max
        while (!found && min <= max)
        {
            // calculate middle position in the range
            mid = (min+max)/2;
            // compare the title entered to the title of the mid position card
            if(collection[mid].getName().compareTo(targetName) == 0)
                found = true;               // we have a match - found is true
            else if (collection[mid].getName().compareTo(targetName) > 0)
                max = mid-1;                // too high, use max 1 lower than mid
            else
                min = mid+1;                // too low, use min 1 higher than mid
        }

// determine if there was a match
        if (found) return collection[mid];  // if so, return the card that matches
        else return null;                   // if not, return an empty card object
   }

//-----------------------------------------------------------------
   //  Writes card collection to disk file
   //  Overlay any existing data
   //  Create a new file if one does not exist and then write to it
   //-----------------------------------------------------------------

public void writeToFile()
   {
       // Try to write to a file
       try
       {
          // create a file writer object called fw which will overlay any existing data
          FileWriter fw = new FileWriter("CardCollection.txt", false);

// create a file buffered writer object called w
          // in which to place what will be written to the disc
          BufferedWriter w = new BufferedWriter (fw);

// String s will contain one card
          String s;

for(int i=0; i<count; i++)
          {
              // create a string s composed of fields separated by | character
	          s = "";
              s += collection[i].getName() + "|";
              s += collection[i].getAnswer() + "|";
              // write the string containing one card object to the write buffer
              w.write (s);
          }

// Transfer a partially filled buffer to the disc
          w.flush();
          // Close the file (also empties the buffer)
          w.close();
          System.out.println("\nWrite to file is complete\n");
       }

// If there is an file IO error, display why it occurred
       catch(IOException e)
       {
          e.printStackTrace();
       }
   }

}

//and last is just Card.java

import java.text.NumberFormat;

public class Card

{
	public String name, answer;

public Card ()
	{
		name = "";
		answer = "";
	}

//------------------------------------------
	//	Creates a new Card with specified info
	//------------------------------------------
	public Card (String question, String response)
	{
		name = question;
		answer = response;
	}

//------------------------------------------
	// 	Returns a string description of the card
	//------------------------------------------

public String toString()
	{
		NumberFormat fmt = NumberFormat.getCurrencyInstance();

String description;

description = name + "\t" + answer;

return description;
	}

public String getName()
	{
		return name;
	}

public String getAnswer()
	{
		return answer;
	}

}

>

Welcome to the Ranch

I have split your post from its previous location because it is a new question. Please supply more details, eg line number, which "symbol" it can't find.

It looks like your switch statement is in the FlashCard class, but all the methods you're calling in it are in the CardCollection class.

I thought there was something wrong with all those static methods. You ought to be creating objects of your classes, then you won't need to mark those methods static.