How to return a non const value?

Question

Hi,
I would like one of my methods to return a date object that should not be modified. How do I enforce this? I could create a 2nd object duplicating the original and return it, so any changes to the returned object will not mess up the original, but there must be a better way. What is it?
Thanks,
Carlo

Answer 1

That, sadly won't work because I still need to be able to modify the date internally to the class, just when I return it in a getter I want to enforce non modifyability.
Following is the code. Look at the getNextTime() method, this is the method that returns the date object that I want to enforce being non modifyable.
import java.util.GregorianCalendar;
import java.util.Timer;
import java.util.TimerTask;
import java.util.HashMap;
import java.util.Date;
* Any ClockListener may register itself with this object to be notified at
* specified times. This may for example be usefull for a job that needs to
* be run at certain times or time intervals.
* To schedule notifications:
* 1. Create the class that implements the ClockListener interface.
* 2. Add this class as a listener to the clock, using one of the schedule
*    methods.
* To stop notification:
* 1. Use remove method.
* To change a notification schedule
* 1. Reschedule the listener. If added previously the instance will
*    automatically be rescheduled.
* NOTE: The granularity of this timer is 1 minute. All timers will fire on
*       the minute, even if scheduled mid-way a minute.
* @see com.sorenson.utils.ClockListener
* @author carlo
* @since  Nov 21, 2001 - 9:49:31 AM
public class Clock
    private HashMap mSchedules;
    private HashMap mReminders;
    private static Clock mInstance = null;
    public static Clock getInstance()
        if (null == mInstance)
            mInstance = new Clock();
        return mInstance;
    private Clock()
        mSchedules = new HashMap();
        mReminders = new HashMap();
     * Every (minute) th minute(s)
    public void scheduleInterval(ClockListener listener, int minute)
        addSchedule(listener, -1, -1, -1, minute);
     * Every day at (hour):(minute)
    public void scheduleDaily(ClockListener listener, int hour, int minute)
        addSchedule(listener, -1, -1, hour, minute);
     * Every week on the (dayOfWeek) day at (hour):(minute)
    public void scheduleWeekly(ClockListener listener, int dayOfWeek, int hour, int minute)
        addSchedule(listener, -1, dayOfWeek, hour, minute);
     * Every month on the (dayofMonth) day at (hour):(minute)
    public void scheduleMonthly(ClockListener listener, int dayOfMonth, int hour, int minute)
        addSchedule(listener, dayOfMonth, -1, hour, minute);
    public Date getNextTime(ClockListener listener)
        return ((Schedule)mSchedules.get(listener)).mNextTime.getTime();
    private void addSchedule(ClockListener listener, int dayOfMonth , int dayOfWeek, int hour, int minute)
        // check for existance
        if (null != mSchedules.get(listener))
            remove(listener);
        // create a schedule for the listener based upon the specified parameters
        Schedule schedule = new Schedule(dayOfMonth, dayOfWeek, hour, minute);
        // link the listener to the schedule and store
        mSchedules.put(listener, schedule);
        // create a reminder for the next wake up time and store
        mReminders.put(listener, new Reminder(listener, schedule.updateNext()));
    public void remove(ClockListener listener)
        // cancel the current reminder
        ((Reminder)mReminders.get(listener)).cancel();
        // remove the schedule for the listener
        mSchedules.remove(listener);
        // remove the canceled reminder for the listener
        mReminders.remove(listener);
    private void wakeUp(ClockListener listener)
        // remove the old reminder
        mReminders.remove(listener);
        // create a new reminder with the next scheduled wake up time
        mReminders.put(listener, new Reminder(listener, ((Schedule)mSchedules.get(listener)).updateNext()));
        // notify listener
        listener.onWakeUpCall();
     * Defines a wake up schedule for a clock listener
    private class Schedule
        // the next date/time the listener for this schedule needs to be notified
        GregorianCalendar mNextTime;
        // schedule rule variables
        int mDayOfMonth;
        int mDayOfWeek;
        int mHour;
        int mMinute;
        Schedule(int dayOfMonth , int dayOfWeek, int hour, int minute)
            // set the initial next time to right now,
            mNextTime = BasicHelper.getGMTGregorianCalendar();
            mNextTime.set(GregorianCalendar.SECOND, 0);
            // save the schedule rules
            mDayOfMonth = dayOfMonth;
            mDayOfWeek = dayOfWeek;
            mHour = hour;
            mMinute = minute;
        long updateNext()
            // once a month
            if (-1 != mDayOfMonth)
                nextMonth();
            // once a week
            else if (-1 != mDayOfWeek)
                nextWeek();
            // once a day
            else if (-1 != mHour)
                nextDay();
            // every so many minutes
            else
                nextSoManyMinutes();
            // return the time in ms between the current time and the next scheduled wake up time
            return mNextTime.getTime().getTime() - BasicHelper.getGMTGregorianCalendar().getTime().getTime();
        private void nextMonth()
            mNextTime.add(GregorianCalendar.HOUR_OF_DAY, mHour - mNextTime.get(GregorianCalendar.HOUR_OF_DAY));
            mNextTime.add(GregorianCalendar.MINUTE, mMinute - mNextTime.get(GregorianCalendar.MINUTE));
            mNextTime.add(GregorianCalendar.DATE, mDayOfMonth - mNextTime.get(GregorianCalendar.DAY_OF_MONTH));
            // skip to next month if next time in the past
            if (BasicHelper.getGMTGregorianCalendar().after(mNextTime))
                mNextTime.add(GregorianCalendar.MONTH, 1);
        private void nextWeek()
            mNextTime.add(GregorianCalendar.HOUR_OF_DAY, mHour - mNextTime.get(GregorianCalendar.HOUR_OF_DAY));
            mNextTime.add(GregorianCalendar.MINUTE, mMinute - mNextTime.get(GregorianCalendar.MINUTE));
            mNextTime.add(GregorianCalendar.DATE, mDayOfWeek - mNextTime.get(GregorianCalendar.DAY_OF_WEEK));
            // skip to next week if next time in the past
            if (BasicHelper.getGMTGregorianCalendar().after(mNextTime))
                mNextTime.add(GregorianCalendar.DATE, 7);
        private void nextDay()
            GregorianCalendar newTime = new GregorianCalendar(
                    mNextTime.get(GregorianCalendar.YEAR),
                    mNextTime.get(GregorianCalendar.MONTH),
                    mNextTime.get(GregorianCalendar.DATE),
                    mHour,
                    mMinute);
            if (newTime.after(mNextTime))
                mNextTime = newTime;
            else
                newTime.roll(GregorianCalendar.DATE, true); // rolls one day ahead
                mNextTime = newTime;
        private void nextSoManyMinutes()
            mNextTime.add(GregorianCalendar.MINUTE, mMinute);
     * Internal class used to set reminders for the wake up schedules of the listeners
    private class Reminder
        Timer mTimer;
        ClockListener mListener;
        Reminder(ClockListener listener, long ms)
            mListener = listener;
            mTimer = new Timer();
            mTimer.schedule(new RemindTask(), ms);
        void cancel()
            mTimer.cancel();
        class RemindTask extends TimerTask
            public void run()
                // Terminate the timer thread
                mTimer.cancel();
                // Wake up the listener
                Clock.this.wakeUp(mListener);