I don't understand the solution at all

Question about the task

Under discussion

Not asking for help on my code, since I've already looked at the solution. I just need someone to explain the solution. Also, since the board doesn't handle greater-than or less-than symbols well, please interpret all parentheses as being greater-than or less-than. What is (T) in the interface declaration? T is not declared anywhere in the code, so what is it? The conditions say to use a String parameter, so why isn't it interface SimpleObject(String)? Other questions I need answered: 1. In the solution, they use @override. Why? 2. Why does it return null? 3. In the interface declaration, why is it SimpleObject(T) getInstance? I've never seen an interface refer to itself in the method, and I don't understand what doing that does. 4. I've been going through previous lessons trying to find examples of declaring interfaces this way, or related to my other questions. This task feels like it's all stuff we haven't been taught previously. If there is a lesson that explains these please let me know so I can reread it.

package com.codegym.task.task13.task1307; /* Parameterized interface */ public class Solution { public static void main(String[] args) throws Exception { } interface SimpleObject<T> { SimpleObject<T> getInstance(); } class StringObject implements SimpleObject<T> { public SimpleObject<T> getInstance() { } } }

Comments (6)

Popular
New
Old

You must be signed in to leave a comment

Justin Smith

Level 41 , Greenfield, USA, United States

30 July 2021, 21:37

Thank you both. I think I understand it a little bit better now.

Stian Eggum Tellnes

Level 15

29 October 2021, 19:11

As to why it returns "null;" , I think it's just because it's not a void method, and it has to have a return statement. Returning "null" is basically just the sure thing to pass the requirements i guess. You could also say it should return a StringObject();

Stian Eggum Tellnes

Level 15

29 October 2021, 19:12

*correction "new StringObject();"

Gellert Varga

Level 23 , Szekesfehervar, Hungary

30 July 2021, 18:57

Hi! I can only answer a little and only to your question-3.

interface SimpleObject<T> {
    SimpleObject<T> getInstance();
}

This is what this code means: The interface named SimpleObject contains a getInstance() method that should return an object of type SimpleObject. This means that, for example, if the CatObject class implements the SimpleObject interface, then the CatObject class must contain a getInstance() method that actually must return an object of type SimpleObject. Note that this method can also return a CatObject type, since a CatObject is also a SimpleObject type (a descendant of the SimpleObject interface.) The meaning of <T> has already been explained by Guadalupe, but this site also helps: https://www.geeksforgeeks.org/generics-in-java/ And I'll add some more examples to give you a better understanding of how it works:

Gellert Varga

Level 23 , Szekesfehervar, Hungary

30 July 2021, 18:58

Example of how a generic method works:

public class MyClass {
    // A Generic method
    static <T> void genericDisplay (T element)  {
        System.out.println(element.getClass().getSimpleName() + " = " + element);
    }

    public static void main(String[] args) {

        // Calling generic method with Integer argument
        genericDisplay(11);

        // with String argument:
        genericDisplay("something String");

        // with double arg:
        genericDisplay(1.0);

        MyClass myclassObj = new MyClass();
        // with MyClass-type arg:
        genericDisplay(myclassObj);
    }
}

OUTPUT: Integer = 11 String = something String Double = 1.0 MyClass = MyClass@2d6d8735 Example of how a generic class works:

public class Main {
    static class Box<T> {
       private T field;

       public void setField(T field) {
           this.field = field;
       }

       public T getField() {
           return field;
       }
    }

   public static void main(String[] args) {

       Box<String> stringBox = new Box<>();
       stringBox.setField("SomeString");
       System.out.println(stringBox.getField());

       Box<Integer> intBox = new Box<>();
       intBox.setField(12345);
       System.out.println(intBox.getField());
       // intBox.setField("something string");  = Error: incompatible types: String cannot be converted to Integer
   }
}

OUTPUT: SomeString 12345

Guadalupe Gagnon

Level 37 , Tampa, United States

30 July 2021, 14:23

This is an example a parameterized code. The T is just a placeholder that will be replaced with whatever you replace it with when you write code using the parameterized code. A good example of this that you would be familiar with is ArrayList class. The class code for ArrayList would look something like this:

public class ArrayList<E> {
   E get(int i) {
       // return the E object at index i
   }

   boolean add(E obj) {
       // add 'obj' of type E to the internal array
   }

    Iterator<E> iterator() {
         // returns an Iterator<E> object for the internal array
    }
}

So, creating an ArrayList<String> means all that above code the 'E' would be replaced with 'String'. If you declared an ArrayList<Integer> the 'E' for that would be replaced with 'Integer'. In this way the ArrayList class was written once and works with ANY (custom or standard) object you declare it as. A quick note: the 'T' is not a letter used by rule but by best practice. You can use any letter, or word, that you want following Java's standard naming rules. The best practice has some suggestions: T for type E for element K for key V for value etc. You could rewrite the above code to replace the parameterized 'T' as this:

interface SimpleObject<Justin> {
    SimpleObject<Justin> getInstance();
}

and it would be functionally identical, though confusing to anyone else trying to figure out what it does or is used for later on.