Thread: problem with interface

i seem to have a syntax error or am not calling my interface correctly. can someone help please?


file one ...

================================================== =====

import java.util.Scanner;
 
public class AnagramFinderApp {
 
	private static final AnagramFinder True = null;
 
	/**
	* Determines if two strings are anagrams. Whitespace is ignored, but all other characters
	*/
 
     public static void main(String[] args) {
 
    //	 boolean match = false;
 
         Scanner sc = new Scanner(System.in);
 
         System.out.print("Enter first string:");
         String s1 = sc.nextLine();  
 
         System.out.print("Enter second string:");
         String s2 = sc.nextLine(); 
 
  //       AnagramFinder anagramFinder = new AnagramFinder();
         AnagramFinder match = areAnagrams(s1, s2);
 
         if (match == True)        		 
        	 System.out.println("The strings are the same");
         else
    		 System.out.println("The strings are different");
     }
 
}

file two ...

================================================== =====

	 public interface AnagramFinder{
 
	 /**
	 * Determines if two strings are anagrams. Whitespace is ignored, but all other characters
	 * (including punctuation) count.
	 * @param s1 first string to compare
	 * @param s2 second string to compare
	 * @return true if s1 and s2 are anagrams, false otherwise
	 */
		boolean areAnagrams(String s1, String s2);
 
	 }

file tree ...

================================================== =====

import java.util.Arrays;
 
class areAnagramsx implements AnagramFinder{
 
	public boolean areAnagrams(String s1, String s2){
 
	 String ss1 = (s1.replaceAll(" ", "")); // remove blank spaces
	 String ss2 = (s2.replaceAll(" ", ""));
 
	 System.out.println(ss1); // print strings
	 System.out.println(ss2);
 
     char[] arr1 = s1.toCharArray(); // convert string to a character array
     char[] arr2 = s2.toCharArray();
 
     Arrays.sort(arr1); // sort arrays
     Arrays.sort(arr2);
 
     boolean a = Arrays.equals(arr1, arr2);  
 
	 return a;
   }
 
}

That's pretty much it, although to be more precise:

AnagramFinder finder = declare a reference variable called 'finder', of type AnagramFinder
finder = new areAnagramsx(); = create a new object of type areAnagramsx and assign it to finder (set finder to point to it)

In Java all variables for objects are references (generally known as 'pointers' in other languages). They must be declared to have a particular type, e.g. AnagramFinder, or areAnagramsx, or Object. This means they can reference ('refer to' or 'point to') any object of that type - including subclasses of that type - so an AnagramFinder variable can point to an areAnagramsx object (and an Object variable can point to objects of any class, because all classes are subclasses of Object). Bear in mind that the variable type determines what you can do with it; for example, an AnagramFinder variable can point to an areAnagramsx object, but you can only use it to access the AnagramFinder methods of the object. Similarly, an Object variable can point to an areAnagramsx object, but can only be used to access the Object methods it has.

If you don't assign an object to them, reference variables are null because they don't point to an object, and the only thing you can do with them when they are null is to check if they are null or point them to an object of a compatible type - anything else will cause a NullPointerException (one of the few examples in Java that explicitly describes reference variables as pointers!).

This means that you can only ever access objects (call methods on them, etc) indirectly, via these reference variables, and more than one variable can reference the same object. When you pass a variable to a method, the method receives a local copy of that variable that points to the same object.

boolean areAnagrams = finder.areAnagrams(s1, s2)

boolean = keyword declaring the type of variable areAnagrams (to match the type of the return value of the interface method).

Note that, for various reasons, Java has a few primitive types as well as object types. Primitive types aren't based on classes and methods, they're just 'built in' to the language. Their keywords start with a lowercase letter to make this clear: int, long, boolean, float, etc. However, because objects are often required in code, each primitive type has been given a corresponding wrapper class: Integer, Long, Boolean, Float, etc. Recent versions of Java provide an automatic mechanism called 'autoboxing', that converts between a primitive type and its wrapper class whenever necessary, so you can use them interchangeably without any hassle.