Richard Hayward

Thank you for the explanation Mike, I think I understand the situation now.

Mike Simmons wrote:So here, you're trying to call getClass() on a reference of type Inner.  Which is a private class.  The compiler won't let you call any methods on a private class, from outside the top-level class containing the private declaration.  

Evidently even those methods which are inherited unchanged from a non-private ancestor.

In this case, Inner descends directly from non-private Object, which is where getClass() is defined. Inner doesn't override getClass() and yet because Inner is private getClass() can't be called in this example.

Hi Campbell,

Campbell Ritchie wrote:That is equivalent to calling new outer.Inner().getClass().... where the Inner class is not a true inner class because it is static. You can't access members of such a private nested class from outwith its enclosing class.

Could you expand on that a bit?

Referring to lines 13-15 of my initial post, I still don't see why these two lines compile
Object obj = (new Outer()).getInner();           //Inner constructor                                                                                                                         out.println(obj.getClass().getSimpleName());     //Inner  
But written as a single line, javac gives an error.
out.println((new Outer()).getInner().getClass().getSimpleName()); //error  
I don't see the connection you mention with static classes. The inner class in my original example isn't static.

Campbell Ritchie wrote:That is equivalent to calling new outer.Inner().getClass().... where the Inner class is not a true inner class because it is static. You can't access members of such a private nested class from outwith its enclosing class.

Hi Campbell. Apologies, but are you referring to the code I posted, or that of Piet?

This code doesn't compile:

GetInner.java
import static java.lang.System.out;                                                                                                                                                                                                                                                                                                                                                             class Outer{                                                                                                                                                                                      private class Inner{                                                                                                                                                                              Inner(){out.println("Inner constructor");}                                                                                                                                                    }                                                                                                                                                                                              Inner getInner(){return new Inner();}                                                                                                                                                         }                                                                                                                                                                                                                                                                                                                                                                                               public class GetInner{                                                                                                                                                                            public static void main(String[] args){                                                                                                                                                          (new Outer()).getInner();                        //Inner constructor                                                                                                                            Object obj = (new Outer()).getInner();           //Inner constructor                                                                                                                            out.println(obj.getClass().getSimpleName());     //Inner                                                                                                                                        out.println((new Outer()).getInner().getClass().getSimpleName()); //error                                                                                                                    }                                                                                                                                                                                             }    

Without line 15, it compiles & runs
$ java GetInner Inner constructor Inner constructor Inner

But with line 15, which to me just combines the two previous legal lines into one, compilation fails.

$ javac GetInner.java GetInner.java:15: error: Object.getClass() is defined in an inaccessible class or interface    out.println((new Outer()).getInner().getClass().getSimpleName()); //error                                        ^ 1 error

Could anyone tell me why?

Stephan van Hulst wrote:
Polymorphism allows you to swap the actual type of an object that a variable refers to without changing the validity of the program.

So maybe I have a mistaken idea of what polymorphism means. Here, I 'swap the actual type of an object that a variable refers to'.
import static java.lang.System.out;                                                                                                                                                                                                                                                                       class BreakPolymorphism2 {                                                                                                                            static class Animal {                                                                                                                                  void makeNoise(String... noises){                                                                                                                      for(String string:noises) out.print(string);                                                                                                        out.println(" Animal makeNoise");                                                                                                                  }                                                                                                                                                  }                                                                                                                                                    static class Dog extends Animal {                                                                                                                      @Override          //confirm this is indeed an override                                                                                              void makeNoise(String[] noises){                                                                                                                      for(String string:noises) out.print(string);                                                                                                        out.println(" Dog makeNoise");                                                                                                                    }                                                                                                                                                  }                                                                                                                                                    public static void main(String[] args) {                                                                                                                                                                                                                                                                                                                                                         //  Animal animal = new Animal();                                                                                                                        Animal animal = new Dog();                                                                                                                          animal.makeNoise(new String[] {"A", "B"});     //AB Dog makeNoise                                                                                    animal.makeNoise("C", "D");                    //CD Dog makeNoise                                                                                  }                                                                                                                                                   }  

At line 18, instead of using a new Animal(), I use a new Dog() and the code still works.

It still seems weird though. By referencing the Dog via an Animal variable, I can invoke the Dog's makeNoise method with arguments that it shouldn't accept.
The compiler wouldn't allow:
Dog dog = new Dog();                                                                                                                             dog.makeNoise("A", "B");

I've noticed a similar thing with interfaces. An interface method with an int... parameter can be implemented by a method with an int[] parameter.

For example
public class VarArgsInterface{                                                                                                                        interface CanAdd {                                                                                                                                    void add(int... ia);                                                                                                                              }                                                                                                                                                    static class Adder implements CanAdd{                                                                                                                  public void add(int[] ia){                                                                                                                            int sum=0;                                                                                                                                          for(int i:ia){sum += i;}                                                                                                                            System.out.printf("sum=%d\n", sum);                                                                                                                };                                                                                                                                                }                                                                                                                                                    public static void main(String[] args){                                                                                                                //use the interface                                                                                                                                  CanAdd canAdd = new Adder();                                                                                                                        canAdd.add(new int[]{4, 5, 6});        //15                                                                                                          //The following works, even though the implementing method couldn't accept these arguments                                                          canAdd.add(100, 200, 300);             //600                                                                                                      }                                                                                                                                                   }
$ java VarArgsInterface sum=15 sum=600

Carey Brown wrote:No, that is not an override

ok, I thought @Override at least gave a compile time message if the annotated method wasn't overriding something.

For example
import static java.lang.System.out;                                                                                                                                                                                                                                                                                                                                                             public class OverrideTest {                                                                                                                                                                                                                                                                                                                                                                      private static class Animal {                                                                                                                                                                    public void eat() {                                                                                                                                                                              out.println("Animal eats");                                                                                                                                                                  }                                                                                                                                                                                            }                                                                                                                                                                                                                                                                                                                                                                                              private static class Dog extends Animal {                                                                                                                                                        @Override                                                                                                                                                                                      public void eat() {                                                                                                                                                                              out.println("Dog eats");                                                                                                                                                                      }                                                                                                                                                                                              @Override   //error: method does not override or implement a method from a supertype                                                                                                            public void bark(){                                                                                                                                                                              out.println("woof!");                                                                                                                                                                        }                                                                                                                                                                                            }                                                                                                                                                                                                                                                                                                                                                                                              public static void main(String[] args) {                                                                                                                                                          new Dog().bark();                                                                                                                                                                            }                                                                                                                                                                                                                                                                                                                                                                                             }    

Line 12 is ok because Dog.eat() does indeed override Animal.eat()

but javac gives an error at line 16 because Dog.bark() isn't overriding anything.

$ javac OverrideTest.java OverrideTest.java:16: error: method does not override or implement a method from a supertype    @Override   //error: method does not override or implement a method from a supertype    ^ 1 error

A Dog is an Animal, so I'm expecting that anything an Animal can do, a Dog should be able to do.

import static java.lang.System.out;                                                                                                                                                                                                                                                                       class BreakPolymorphism {                                                                                                                              static class Animal {                                                                                                                                  void makeNoise(String... noises){                                                                                                                      for(String string:noises) out.print(string);                                                                                                  out.println(" Animal makeNoise");                                                                                                                  }                                                                                                                                                  }                                                                                                                                                    static class Dog extends Animal {                                                                                                                      @Override          //confirm this is indeed an override                                                                                              void makeNoise(String[] noises){                                                                                                                      for(String string:noises) out.print(string);                                                                                                  out.println(" Dog makeNoise");                                                                                                                    }                                                                                                                                                  }                                                                                                                                                    public static void main(String[] args) {                                                                                                              Animal animal = new Animal();                                                                                                                        animal.makeNoise(new String[] {"A", "B"});     //AB Animal makeNoise                                                                                animal.makeNoise("C", "D");                    //CD Animal makeNoise                                                                                Dog dog = new Dog();                                                                                                                                dog.makeNoise(new String[] {"K", "L"});        //KL Dog makeNoise                                                                                    //dog.makeNoise("M", "N");                     //error: method makeNoise in class Dog cannot be applied to given types;                              ((Animal) dog).makeNoise("O", "P");            //OP Dog makeNoise                                                                                  }                                                                                                                                                   }
But here, that seems to not be the case. Although I can call animal.makeNoise("C", "D"), that same method call on dog won't compile.

Does that not break polymorphism?

Campbell Ritchie wrote:I suggest you add a retention to your annotation and see what happens.

Changing the annotation so as to include that:

MyExercise.java
package com.mydomain.ocp11.ch13.p0558;                                                                                                                                                                                                                                                                                                                                                     import java.lang.annotation.Retention;                                                                                                                                                           import java.lang.annotation.RetentionPolicy;                                                                                                                                                                                                                                                                                                                                                     @Retention(RetentionPolicy.RUNTIME)                                                                                                                                                             public @interface MyExercise {}

PrintMyAnnotations.java
package com.mydomain.ocp11.ch13.p0558;                                                                                                                                                                                                                                                                                                                                                     import java.lang.annotation.Annotation;                                                                                                                                                         import static java.lang.System.out;                                                                                                                                                                                                                                                                                                                                                             @MyExercise                                                                                                                                                                                     public class PrintMyAnnotations{                                                                                                                                                                  public static void main(String[] args) {                                                                                                                                                          Class myClass = PrintMyAnnotations.class;                                                                                                                                                      Annotation[] annotations = myClass.getAnnotations();                                                                                                                                            out.printf("annotations.length = %d\n", annotations.length);                                                                                                                                    for(Annotation annotation:annotations){                                                                                                                                                          out.println(annotation.toString());                                                                                                                                                          }                                                                                                                                                                                            }                                                                                                                                                                                             }  

It works!

$ java com.mydomain.ocp11.ch13.p0558.PrintMyAnnotations annotations.length = 1 @com.mydomain.ocp11.ch13.p0558.MyExercise() $

Seems that without RetentionPolicy.RUNTIME, the annotation doesn't exist at runtime.

Thanks Campbell

I'm reading Jeanne & Scott's complete OCP 11 study guide, chapter 13 about Annotations.

Following the syntax they give, I define an Annotation:

Exercise.java
package com.mydomain.ocp11.ch13.p0558;                                                                                                                                                                                                                         public @interface Exercise {}  

I then create a class, with that Exercise annotation applied, than can print out it's own annotations:

PrintMyAnnotations.java
package com.mydomain.ocp11.ch13.p0558;                                                                                                                                                                                                                                 import java.lang.annotation.Annotation;                                                                                               import static java.lang.System.out;                                                                                                                                                                                                                                         @Exercise                                                                                                                           public class PrintMyAnnotations{                                                                                                        public static void main(String[] args) {                                                                                                Class myClass = PrintMyAnnotations.class;                                                                                            Annotation[] annotations = myClass.getAnnotations();                                                                                  out.printf("annotations.length = %d\n", annotations.length);                                                                          for(Annotation annotation:annotations){                                                                                                out.println(annotation.toString());                                                                                                }                                                                                                                                  }                                                                                                                                   }

but nothing gets printed
$ java com.mydomain.ocp11.ch13.p0558.PrintMyAnnotations annotations.length = 0 $

If, instead of @Exercise, I use a @Deprecated annotation
package com.mydomain.ocp11.ch13.p0558;                                                                                                                                                                                                                                 import java.lang.annotation.Annotation;                                                                                               import static java.lang.System.out;                                                                                                                                                                                                                                         @Deprecated                                                                                                                           public class PrintMyAnnotations{                                                                                                        public static void main(String[] args) {                                                                                                Class myClass = PrintMyAnnotations.class;                                                                                            Annotation[] annotations = myClass.getAnnotations();                                                                                  out.printf("annotations.length = %d\n", annotations.length);                                                                          for(Annotation annotation:annotations){                                                                                                out.println(annotation.toString());                                                                                                }                                                                                                                                  }                                                                                                                                   }

I get, as expected, an annotation reported:
$ java com.mydomain.ocp11.ch13.p0558.PrintMyAnnotations annotations.length = 1 @java.lang.Deprecated(forRemoval=false, since="") $

Could anyone tell me why, in the case of @Exercise, I'm not getting any annotation reported?

Thanks to all for your help on this thread.

Seems I should spend a bit of time exploring what levels of access are given to objects when reflection is used, as opposed to when it's not.

So could I clarify this?

Stephan van Hulst wrote:The error message tells you exactly why it can't create an instance of NewInstanceTest1$Dog: It has the private access modifier.

I didn't understand Stephan's response here because I thought that as far as inner classes are concerned, the outer class can see members of an inner class, even if they are declared private. For example:

class PrivateInnerAccessTest{  private static class Dog{    private void bark(){System.out.println("woof!");}  }  public static void main(String[] args){    Dog dog = new Dog();    dog.bark();                           //woof!  } }
the dog barks. Therefore, from my initial post

class NewInstanceTest1{  private static class Dog{    void bark(){System.out.println("woof!");}  }  public static void main(String[] args){    Dog dog = new Dog();    dog.bark();                           //woof!    Class dogClass = dog.getClass();    try{      Object o = dogClass.newInstance();  //IllegalAccessException    } catch(Exception e) {      System.out.println(e);    }  } }
I was thinking that because Dog is an inner class, the outer class should be able access all it methods. Is the problem that it's Dog that's the inner class, not dogClass?

Thanks for the tips about Date. It's not primarily Date I was interested in, any class would do. I just came across that code snippet when googling for an example of the use of newInstance().

Campbell Ritchie wrote: It also doesn't tell you that you oughtn't to use newInstance() any more.

ok. That link for the java 12 api shows newInstance as deprecated since java 9. I'm using a java 8 compiler.

Campbell Ritchie wrote:
So  tried your code and didn't get any exceptions.

Should still work though shouldn't it?

richard@ProBook-450-G2:~/projects/test$ javac -version javac 1.8.0_211 richard@ProBook-450-G2:~/projects/test$ javac NewInstanceTest1.java richard@ProBook-450-G2:~/projects/test$ java NewInstanceTest1 woof! java.lang.IllegalAccessException: Class NewInstanceTest1 can not access a member of class NewInstanceTest1$Dog with modifiers "private" richard@ProBook-450-G2:~/projects/test$

Could anyone tell me why one of these examples works and the other doesn't?

My first example compiles but throws an exception.
class NewInstanceTest1{  private static class Dog{    void bark(){System.out.println("woof!");}  }  public static void main(String[] args){    Dog dog = new Dog();    dog.bark();                           //woof!    Class dogClass = dog.getClass();    try{      Object o = dogClass.newInstance();  //IllegalAccessException    } catch(Exception e) {      System.out.println(e);    }  } }
According to the api for Class
'IllegalAccessException is thrown  if the class or its nullary constructor is not accessible.'

I'm thinking that the fact that the dog barks at line 7 demonstrates that neither of those things is true.

My second example, (simplified from the example at TutorialsPoint ) compiles and runs ok.

import java.util.Date; public class NewInstanceTest2 {  public static void main(String[] args) {    Date date = new Date();    System.out.println(date);                //ok    Class dateClass = date.getClass();    try {      Object o = dateClass.newInstance();      System.out.println(o);                 //ok    } catch(Exception e) {      System.out.println(e);    }    } }
Seems to me however that the second example is doing the same thing.

I'm thinking of doing the upgrade exam from java 6 to 8.

I liked the Sierra/Bates book when I did the java 6 exam, so I thought I'd stick with those authors.

Could anyone with experience of that book comment on a couple of questions?

Assuming I have a good grasp of the material required for the java 6 exam, is it reasonable to start with volume II? Or, would I find that volume II assumed knowledge of some post java 6 feature that had already been explained in the first volume?

Secondly, does the book contain a checklist of what pages/chapters need to be mastered for the upgrade exam? The preview at Amazon cuts off at the point where my guess is that any such table would be.

Liutauras Vilda wrote:
But that is really what would happen. s[0] trying to access very first element within an array, while s isn't referring to an array of Strings, but rather a singular String.

oops.. apologies!  I should have said that the test had several questions  like this:
void m(int i){  String[] s = null;  System.out.println(s[0] + i); }
Key point being that an isolated bit of code like this won't compile. Put it inside a class and it will compile but throw an exception at runtime.
I wasn't expecting incomplete code samples like this.