Interface in the constructor parameters

[Ruben1]

I have an assignement for Data Structures and Algorithms and I am confused because I have the interface class in the class constructor and I do not understand how it works or how to use it. Here is my code,

// THIS IS THE CLASS
public class FindMin<E>  {

  public FindMin(Compare<E> comp) {
        if(smaller(min,(E)comp)){
            min = (E)comp;
            counter++;

        }
  }

// THIS IS THE INTERFACE
    public interface Compare<E> {
        public boolean equal(E e,E f);
        public boolean smaller (E e,E f);
    }

 

[AbydosOne]

5 minutes ago, Ruben1 said:

I have an assignement for Data Structures and Algorithms and I am confused because I have the interface class in the class constructor and I do not understand how it works or how to use it.

To be clear, are you having issues with Java interfaces, Java classes, or the algorithm you're trying to implement using Java?

 

(I assume it's Java; walks like Java, talks like Java, must be Java)

[Ruben1]

1 minute ago, AbydosOne said:

To be clear, are you having issues with Java interfaces, Java classes, or the algorithm you're trying to implement using Java?

 

(I assume it's Java; walks like Java, talks like Java, must be Java)

This is what they ask me to do : the constructor takes as input an object implementing the Compare<E> interface. This object should be used to determine the smallest element insert. Hence, the ADT should work with all elements of a given class E for which we provide an object implementing the Compare<E> Interface. and I dont understand how the part of the object of the interface what does it mean and when I initialise the object what am I supposed to put in the constructor. Sorry if I wasnt clear in the first place.

[Slottr]

1 minute ago, Ruben1 said:

This is what they ask me to do : the constructor takes as input an object implementing the Compare<E> interface. This object should be used to determine the smallest element insert. Hence, the ADT should work with all elements of a given class E for which we provide an object implementing the Compare<E> Interface. and I dont understand how the part of the object of the interface what does it mean and when I initialise the object what am I supposed to put in the constructor. Sorry if I wasnt clear in the first place.

This example from W3 should help.

 

// Interface
interface Animal {
  public void animalSound(); // interface method (does not have a body)
  public void sleep(); // interface method (does not have a body)
}

// Pig "implements" the Animal interface
class Pig implements Animal {
  public void animalSound() {
    // The body of animalSound() is provided here
    System.out.println("The pig says: wee wee");
  }
  public void sleep() {
    // The body of sleep() is provided here
    System.out.println("Zzz");
  }
}

class Main {
  public static void main(String[] args) {
    Pig myPig = new Pig();  // Create a Pig object
    myPig.animalSound();
    myPig.sleep();
  }
}

 

https://www.w3schools.com/java/java_interface.asp

[Ruben1]

1 minute ago, Slottr said:

This example from W3 should help.

 

// Interface
interface Animal {
  public void animalSound(); // interface method (does not have a body)
  public void sleep(); // interface method (does not have a body)
}

// Pig "implements" the Animal interface
class Pig implements Animal {
  public void animalSound() {
    // The body of animalSound() is provided here
    System.out.println("The pig says: wee wee");
  }
  public void sleep() {
    // The body of sleep() is provided here
    System.out.println("Zzz");
  }
}

class Main {
  public static void main(String[] args) {
    Pig myPig = new Pig();  // Create a Pig object
    myPig.animalSound();
    myPig.sleep();
  }
}

 

https://www.w3schools.com/java/java_interface.asp

Thanks for the example but my confussion is in the parameters of the constructor I dont understand what has to go there because it seems as if it was an object from the interface but an interface doesnt have objects itself so I am really confused.

[Alvin853]

Interface and "implements" works the same as "extends" for classes. So if a function requires an interface as parameter, it will accept an object of any class that implements this interface. 

[Eigenvektor]

public class FindMin<E> {
    public FindMin(Compare<E> comp) {
    }
}

This constructor accepts any class that implements the "Compare<E>" interface. Your current implementation seem very weird though. Since you are constructing a new instance of FIndMin, where does "min" come from? You are also calling "smaller" as if it was a method in FindMin, but it is actually a method of the compare interface, so you need to call it on whatever object is passed into your constructor.

 

Casting the argument to E doesn't really make sense either. The interface guarantees that the object you have can be compared to E, but it isn't necessarily of type E itself. So this could actually result in a class cast exception. My example below shows a type-safe alternative to this.

 

The way to use your interface would be to implement it:

public class Number implements Compare<Number> {
    …
}

You can now pass an instance of the Number class into your constructor. The constructor accepts any class that implements the Compare interface, which Number does, so it is acceptable.

Here's a concrete example that is usable:

public interface Compare<E> {
    // no need to use 'public' here, this is implicit for interface methods
	boolean smaller(E other);
	boolean equal(E other);
}

// Instead of using the interface as type argument, we use an object that implements the interface.
// This way we can return concrete objects rather than interfaces.
public class FindMin<E extends Compare<E>> {

    private final E min;

    public FindMin(final E e1, final E e2) {
        if (e1.smaller(e2)) {
            min = e1;
        } else {
            min = e2;
        }
    }

    public E getMin() {
        return min;
    }
}

// Here's an example class implementing the interface
public class Number implements Compare<Number> {

	private final int value;

	public Number(final int value) {
		this.value = value;
	}

	@Override
	public boolean smaller(final Number other) {
		return value < other.getValue();
	}

	@Override
	public boolean equal(final Number other) {
		return value == other.getValue();
	}

	public int getValue() {
		return value;
	}
}

// Some test code
final Number one = new Number(1);
final Number two = new Number(2);

final FindMin<Number> findMin = new FindMin<>(one, two);

final Number min = findMin.getMin();

assert min.equal(one) : "min and one should have the same value";
assert min == one : "min and one should actually be the same instance";