So you just want the overridden version to use a different delimiter pattern for the Scanner? I suggest taking a look at the Scanner API as it documents how to use a different delimiter pattern.

public boolean openRead() throws FileNotFoundException
{
    boolean result = super.openRead();
    sc.useDelimiter(DELIMITERS);
    return result;
}

edit

Or perhaps you just don't know what overriding is in Java, and for that you should read more in the Java tutorials.

But essentially, if you had some class:

public class ScannerUserParent
{
    protected Scanner sc;
    private String filename = null;

    // all that other stuff like constructors...

    public boolean openRead() throws FileNotFoundException
    {
        sc = new Scanner(new File(fileName));

        if (fileName != null)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

Then you subclass that class (or extends):

public class ScannerUserChild extends ScannerUserParent
{
    protected final String DELIMITERS = "[\\s[^'a-zA-Z]]";

    // stuff like constructors...

    public boolean openRead() throws FileNotFoundException
    {
        boolean result = super.openRead(); // we are calling the parent's openRead() method to set up the Scanner sc object

        sc.useDelimiter(DELIMITERS);
        return result;
    }
}

However, there are other things that can prevent you from doing exactly this. For example, if the sc member was private scope, then the subclass could not use it directly in the manner I have shown.

In my example, sc uses protected access, so the class and its subclasses can use it.

In case there's a private Scanner, and assuming the parent has a getScanner() method that returns you the Scanner, you could do this:

    public boolean openRead() throws FileNotFoundException
    {
        boolean result = super.openRead(); // we are calling the parent's openRead() method to set up the Scanner sc object
        Scanner sc = getScanner();
        sc.useDelimiter(DELIMITERS);
        return result;
    }

To answer the question, which is specifically how overriding is implemented in the virtual machine, there's a write up available in Programming for the Java Virtual Machine (Google Books link).

The VM will look for an appropriate method definition in the referenced class, and then work its way up through the inheritance stack. Obviously at some stage various optimisations will apply.

See here for a description of the relevant bytecode instruction invokevirtual:

invokevirtual looks at the descriptor given in , and determines how many arguments the method takes (this may be zero). It pops these arguments off the operand stack. Next it pops objectref off the stack. objectref is a reference to the object whose method is being called. invokevirtual retrieves the Java class for objectref, and searches the list of methods defined by that class and then its superclasses, looking for a method called methodname, whose descriptor is descriptor.

As gustafc has highlighted below, various optimisations can apply, and no doubt the JIT will introduce further.

Ok, from what I can see, you have 2 main questions here.

1. What does it mean to override a method?
2. How to I override a method?

Lets think up a new class, so that I can avoid doing your homework for you.

We have a class called Student, that stores 3 Strings.

• First Name
• Last Name
• GPA

It might look something like this.

public class Student {
    String firstName;
    String lastName;
    String gpa

    public Student(String firstName, String lastName, String gpa){
        this.firstName = firstName;
        this.lastName = lastName;
        this.gpa = gpa;
    }

    // Perhaps some methods here

    public String getIdentity(){
        return this.lastName + ", " + this.firstName;
    }
}

You like the Student class, but you decide that it would be much better if you could keep track of a College studentId as well. One solution would be to extend the Student class.

By extending the class, we get access all of the methods (and constructors) that Student had, and we get to add some of our own. So lets call our new class CollegeStudent, and add a String for the studentId.

public class CollegeStudent extends Student{

    String studentId;

}

Now, with no additional work, I can create a CollegeStudent, and get it's identity.

// Code
CollegeStudent myCollegeStudent = new CollegeStudent("Dennis", "Ritchie", "2.2");
String identity = myCollegeStudent.getIdentity();
// Code

Ok, enough setup. Lets answer your questions.

So lets assume that instead of returning "Ritchie, Dennis", you would prefer getIdentity() to return the "studentId" for that college student. You could then override the getIdentity method.

By overriding the method, you will get to re-write getIdentity() so that it returns the studentId. The CollegeStudent class would look something like this.

public class CollegeStudent extends Student{

    String studentId;

    @Override
    public String getIdentity(){
        return this.studentId;
    }
}

To override a method, you must return the same type of object (String in our example), and you must accept the same parameters (our example did not accept any parameters)

You can also override constructors.

So how does this apply to your assignment? .equals(), .compareTo(), and .toString() are already defined because of the classes that you will be extending (such as Object). However you will want to re-define or override those methods so that they will be useful for your class. Perhaps your implementation of toString() will return the word "four" instead of "IV". Probably not, but the point is that you now have the freedom to decide how the method should be coded.

Hope this helps.

If you make a new method bark for your Dog class instead of overriding speak, then you also have to add code to detect that youre dealing with a dog, then cast it to a Dog type, then call bark. You get a program that has a bunch of very specific code that has to handle each concrete type individually, and the workflow has to be updated every time you add a new subclass. There is no abstraction or generality.

The idea behind polymorphism is that your program shouldn't have to worry about which objects are dogs and which are cats, it just handles animals, and lets the subclasses take care of the details for themselves. The program stays at a high level and tells the animals to speak, the specific animals' subclasses decide whether to bark or meow. So if you introduce a new animal subclass the code handling animals doesn't change.

Override means that you change the functionality of a method (you overwrite what that method does).

Overload means that you keep the method name and return type , but you have different input paremeters.

The two concepts are very different.

While in override you have a different functionality for the SAME method, with overload you have two DIFFERENT methods with the SAME name .

!EDIT

You can overload a method to have a different return type only if you have different input parameters. You cannot overload a method by only changing it's return type.