How do I make a super class call in this situation?

Question

I'm trying to figure out how I will make a superclass call with the following situation I have.

As you will see below, the subclass of the class I'm extending only has one parameter in its constructor, while the superclass has two.

Below is my code:

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

    public class DirectorySize extends DirectoryProcessor
    {
        /*
        Dan Czarnecki
        October 29, 2013

        Class variables:
            private HashMap<File, DirectoryStatistics> directory
                A HashMap object that will contain the files and folders
                within a directory

        Constructors:
            public DirectorySize(File startingDirectory) throws FileNotFoundException
                Creates a DirectorySize object, takes in a pathname (inherited from DirectoryProcessor class,
                and has a single hashmap of a DirectoryStatistics object to hold the files and folders
                within a directory

        Methods:
            public void processFile(File file)
                A method that searches for all the files and folders
                within a directory and calculated the total size
                for each of them
            public void run()
                Calls the processFile() method and prints out
                the files and folders (along with their sizes)
                in the directory
            public String toString()
                Returns each element in the directory Vector


        Modification History
            October 29, 2013
                Original version of class
                Implemented run() and processFile() methods
            October 30, 2013
                Added implementation of FileFilter to processFile() method
        */
        private HashMap<File, DirectoryStatistics> directory;

        public DirectorySize(File startingDirectory) throws FileNotFoundException
        {
            super(startingDirectory);
            directory = new HashMap <File, DirectoryStatistics>();
        }


        public void processFile(File file, FileFilter fileFilter) throws FileNotFoundException
        {
            DirectoryStatistics parent;
            int index;
            File parentFile;
            boolean find;


            parentFile = file.getParentFile();
            parent = new DirectoryStatistics(parentFile);
            find = directory.containsValue(parent);

            if(find)
            {
                directory.put(parentFile, parent);
                directory.get(parentFile).setSizeInBytes(file.length());
                directory.get(parentFile).incrementFileCount();
            }


            if(find)
            {
                directory.get(find).addToSizeInBytes(file.length()); //increments the total size of the directory
                directory.get(find).incrementFileCount(); //increments the number of files in the directory
            }


        }

        public void run() throws FileNotFoundException
        {
            File file;
            file = directoryLister.next();


            while(file != null) //the following will be called when the File object is not null
            {
                processFile(file, fileFilter);
                file = directoryLister.next();
            }

        }

        public String toString()
        {
            Set<File> parentFile = directory.keySet();
            File[] parentFileArray = parentFile.toArray(new File[0]);

            String str; //creates a new string that will hold the file or directory name
            str = "";

            for(int i = 0; i < parentFileArray.length; i++)
            {
                str = str + directory.get(parentFileArray[i]).toString();
            }

            return str;
        }
    }
import java.io.*;

abstract public class DirectoryProcessor extends DirectoryLister
{
    /*
    Dan Czarnecki
    October 14, 2013

    Class variables:
        private DirectoryLister directoryLister
            A variable of type DirectoryLister that will list all the directories from a given pathname

    Constructors:
        public DirectoryProcessor(File startingDirectory) throws FileNotFoundException
            Makes a super call to the startingDirectory variable, creates a new DirectoryLister object

    Methods:
        abstract public void processFile(File file, FileFilter fileFilter)
            This abstract method's function is implemented in the TotalFileSize class to process each file within a directory and return the total size of them

        public void run()
            Basically takes the functionality what was originally done with our FileLister and DirectoryLister class (within the driver class)
            but has now moved to its own method

    Modification History:
        October 14, 2013
            Original version of class

        October 16, 2013
            Class and processFile() method have been made abstract

        October 30, 2013

    */

    public DirectoryLister directoryLister;
    public FileFilter fileFilter;

    public DirectoryProcessor(File startingDirectory, FileFilter fileFilter) throws FileNotFoundException
    {
        super(startingDirectory);
        directoryLister = new DirectoryLister(startingDirectory);
        fileFilter = this.fileFilter;
    }

    abstract public void processFile(File file, FileFilter fileFilter) throws FileNotFoundException;


    public void run() throws FileNotFoundException
    {
        File file;
        file = directoryLister.next();

        while(file != null) //the following will be called when the File object is not null
        {
            processFile(file, fileFilter);
            file = directoryLister.next();
        }

    }
}

How can I make the superclass call in this situation?

Answer 1

If i am understanding you correctly, you are referring DirectorySize as Sub Class DirectoryProcessor as Super class, if you want to call the super class constructor DirectoryProcessor(File startingDirectory, FileFilter fileFilter) inside the constructor of DirectorySize, Then you will have to add super(startingDirectory, fileFilter) as the first statement.

With super(parameter list), the superclass constructor with a matching parameter list is called.

Answer 2

Your question isn't clear, but if you're referring to calling super() in the derived class constructor, yes you have to supply both parameters required.