A bunch of questions on different topics

[Dmitry Zhuravlev]

Guys, how can you explain the following from the point of view of language grammar and internal logic.

(1) Why these do NOT compile? Can I use the super keyword in Type declaration?

class GenClass<E extends A> {
	public <T super E> void doit1() {	// error:  ', after super expected'
	}
	public <T super Integer> void doit2() {	// error:  ', after super expected'	
	}
}

(2) ref. to non-static from static context error arises... or not arises. From this I dont understand, whether method in static class is considered to be a static context or not?

class Parent{
	int g;	
	static class SubParent {		
	}
	static class A1 extends SubParent{
		public void run() {
			System.out.println(g); //error: static ref to non-static var
		}
	}	
	static class A2 implements Runnable {
		public void run() {
			System.out.println(g); //error: static ref to non-static var
		}
	}
	static class A3 extends Parent{
		public void run() {
			System.out.println(g); // no error. WHY? WHATS THE DIFFERENCE?
		}
	}	
}

(3) Just nice observation. Any comments, additions?

public class Main{
	static <T extends Number> T generic(T t) {
		return t;
	}
public static void main(String[] args)  {    	
    	generic(new Double(5.0)); //compiles
	<Double>generic(new Double(5.0)); //doesn't compile! 
    	Main.<Double>generic(new Double(5.0)); //compiles
}
}

(4) Why cant I run the go() function? What is the meaning of my declaration of go()? It works only if there is a go() function in the Enum itself.

public class Main {	
	enum MyEnum{
		A,B,C {void go() {System.out.println(555);}};
	}	
public static void main(String[] args)  {
    	MyEnum me1 = MyEnum.C;
        me1.go(); //error:
}
}

(5) Can anyone advice a FREE mock exam with the same level of complexity as ExamLab and Master Exams?

[Deepak Bala]

Do let us know the source of these questions.

You can find more mock exams here -> SCJPMockTests

[Devaka Cooray]

Deepak Bala wrote:You can find more mock exams here -> SCJPMockTests

...and there are couple of mock exams in Deepak's signature.

[Edwin Dalorzo]

For your first question, what you need to understand is the difference between a type variable (JLS 4.4. p. 49) and a type argument (JLS 4.5.1. p.52).

If you read the JLS, you will notice that it says that type variables are used on generic class and interface declarations and in generic method declarations. And this type of declarations only accept "extends" clause, and not the "super". For instance, your method could be declare as follows:

public <T extends Jedi  & Serializable & Closeable>  void doit1(Collection<T> i){}

Now, type argument is a different thing and they are allowed to use wildcards. Your confusion is based on the fact that one of the wildcards is named also "extends", a clear example of Java language polymorphism. In this case, the clause is used for two different things.

As its name suggest, you can use this to declare the expected type of arguments. For instance, you can say:

Collection<? super String> characters = new ArrayList<CharSequence>();

Or in a method declaration.

public void doIt(Collection<? super String> characters){}

You can combine both, like this:

public <T> void doItAgain(Collection<? super T> characters){}

Later I will try to reply to your other questions, because this takes time.

[Edwin Dalorzo]

Your second question is a bit simpler. The class named A3 has access to the g field because it inherited it from its parent class (named Parent), whereas the classes A1 and A2 do not inherit from Parent and therefore do not have access to it.

You could also change your static inner classes to inner classes to have access to the variables declared in the outer class. Like this.

     class Parent{
		int g = 100;
		
		class A1{
			public void run(){
				System.out.println(g);
			}
		}
		
		class A2{
			double g = Math.PI;
			
			public void run(){
				System.out.println(Parent.this.g); //another way to do it.
				System.out.println(this.g);
			}
		}
		
	}

Regarding your third example I have not comments. I think it is fairly obvious what is the right syntax for this.

Regarding your final question about enums. The JLS 8.9 about Enums, page 249 states that the optional class body of a en enum constant implicitly defines an anonymous inner class declaration. If you compile this code and review the class files generated by the compiler you will validate that this is true.

What you are doing there is equivalent to this:

               Object y = new Object(){
			public void go(){
				System.out.println();
			}
		};

How do you invoke the "go" method in y? The answer is: it is not possible.

You can, however, do somewhat like this:

       enum MyEnum {
		A{
			public void go() {
				System.out.println("Hello from A");
			}
		}, 
		B{
			public void go() {
				System.out.println("Hello from B");
			}
		}, 
		C {
			public void go() {
				System.out.println("Hello from C");
			}
		};
		
		public abstract void go();
	}

Now you can invoke the go method.