Currency should implement Comparable<Currency>

[EJP286CRSKW]

It kind of does internally, but with a lot of extra mucking around. Proposed solution follows.

public class Currency
        // Added EJP 31/8/2023
        implements Comparable<Currency> {
	Long embeddedValue = null;

	/**
	 * constructor that takes a long already in COM representation
	 * 
	 * @param newValue New value.
	 */
	public Currency(long newValue) {
		embeddedValue = new Long(newValue);
	}

	/**
	 * constructor that takes a String already in COM representation
	 * 
	 * @param newValue New value.
	 */
	public Currency(String newValue) {
		embeddedValue = new Long(newValue);
	}

	/**
	 * Return the currency as a primitive long.
     * 
	 * @return the currency as a primitive long
	 */
	public long longValue() {
		return embeddedValue.longValue();
	}

	/**
	 * Getter to the inner Long so that {@link Comparable#compareTo} can work
	 * 
	 * @return the embedded Long value
	 */
	protected Long getLongValue() {
		return embeddedValue;
	}

	/**
	 * Compares the values of two currencies
	 * 
	 * @param anotherCurrency Currency object to compare to.
	 * @return the usual compareTo results
	 */
    @Override
	public int compareTo(Currency anotherCurrency) {
		return embeddedValue.compareTo(anotherCurrency.getLongValue());
	}

//	/**
//	 * standard comparison
//	 * 
//	 * @param o
//	 *            must be Currency or Long
//	 * @return the usual compareTo results
//   * Deleted EJP 31/8/2023 when I added 'implements Comparable<Currency>.
//   * The compiler will still generate this method as a bridge method. 
//	 */
//	public int compareTo(Object o) {
//		if (o instanceof Currency) {
//			return compareTo((Currency) o);
//		} else if (o instanceof Long) {
//			return embeddedValue.compareTo((Long) o);
//		} else
//			throw new IllegalArgumentException(
//					"Can only compare to Long and Currency not "
//							+ o.getClass().getName());
//	}

	/*
	 * {@inheritDoc}
	 */
    @Override
	public boolean equals(Object o) {
		if (o == null) {
			return false;
        // Modified EJP 31/8/2023
		} else if (o instanceof Currency && compareTo((Currency)o) == 0) {
			return true;
		} else {
			return false;
		}
	}
}

[freemansoft]

Implementing the Comparable<Currence> interface makes sense. Is any of the rest of this necessary? The compare should lock down on the most appropriate compareTo(Currency). Maybe the one line changed in equals() should be an addition, another if statement.

Do you have a test that shows these changes behave differently?

This is the first time I've looked at the code in maybe 8 years so I could be mistaken

[EJP286CRSKW]

The compiler will already synthesize compareTo(Object). You can't leave the existing one there as you will get a compiler error 'name clash'.

[freemansoft]

Can you create a test for this?

[EJP286CRSKW]

/*
 * Copyright (c) Esmond Pitt, 2024.
 * All rights reserved.
 */
package com.jacob.com;

import static junit.framework.TestCase.assertEquals;
import static junit.framework.TestCase.fail;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestName;

/**
 *
 * @author Esmond Pitt
 */
public class CurrencyTest
{
    @Rule
    public TestName testName = new TestName();
    
    @Before
    public void setUp()
    {
        System.out.println("CurrencyTest."+testName.getMethodName());
    }

    /**
     * Test of longValue method, of class Currency.
     */
    @Test
    public void testLongValue()
    {
        Currency instance = new Currency(1234567890123456L);
        long expResult = 1234567890123456L;
        long result = instance.longValue();
        assertEquals(expResult, result);
    }

    /**
     * Test of compareTo method, of class Currency.
     */
    @Test
    public void testCompareTo_Currency()
    {
        Currency anotherCurrency = new Currency(1234567890123456L);
        Currency instance = new Currency(1234567890000000L);
        int expResult = -1;
        int result = instance.compareTo(anotherCurrency);
        assertEquals(expResult, result);
    }

//    /**
//     * Test of compareTo method, of class Currency.
//       * This test should not compile.
//     */
//    @Test
//    public void testCompareTo_Object()
//    {
//        Object o = new Object();
//        Currency instance = new Currency(1234567890123456L);
//        int expResult = 0;
//        int result = instance.compareTo(o);
//        assertEquals(expResult, result);
//    }

    /**
     * Test of equals method, of class Currency.
     */
    @Test
    public void testEquals()
    {
        Object o = new Object();
        Currency instance = new Currency(1234567890123456L);
        boolean expResult = false;
        boolean result = instance.equals(o);
        assertEquals(expResult, result);
    }
    
}

This goes with the implementation above.

[freemansoft]

e1b2155