Quazi Irfan

Al Hobbs wrote:That's right. You can't put random bits of code in a class. It has to be in something.
The anonymous class gets its rules from the regular class for the most part.

Thank you very much for the clarification!

Al Hobbs wrote:They don't consider it to be a statement.

Technically, you might call it a member variable declaration.  

Makes sense. Out of curiosity I looked at the grammar and I've found why that is the case.
Source: https://docs.oracle.com/javase/specs/jls/se7/html/jls-18.html

A regular expression statement can be made out of the following rules,
Statement:    Block    ;    Identifier : Statement    StatementExpression ;    ...more StatementExpression:    Expression Expression:    Expression1 [AssignmentOperator Expression1]

But inside a class we can only reach to Expression rule only by following MemberDecl rule.

ClassBodyDeclaration:    ;    {Modifier} MemberDecl    [static] Block MemberDecl:    MethodOrFieldDecl    void Identifier VoidMethodDeclaratorRest    Identifier ConstructorDeclaratorRest    GenericMethodOrConstructorDecl    ClassDeclaration    InterfaceDeclaration MethodOrFieldDecl:    Type Identifier MethodOrFieldRest MethodOrFieldRest:      FieldDeclaratorsRest ;    MethodDeclaratorRest FieldDeclaratorsRest:      VariableDeclaratorRest { , VariableDeclarator } VariableDeclaratorRest:    {[]} [ = VariableInitializer ] VariableInitializer:    ArrayInitializer    Expression Expression:    Expression1 [AssignmentOperator Expression1]

Does it mean no class accepts statements - not only anonymous class?

I am reading about anonymous class on Oracle java tutorial from here: https://docs.oracle.com/javase/tutorial/java/javaOO/anonymousclasses.html

Under `Syntax of Anonymous Classes` section, this page says the following about anonymous class,

The anonymous class expression consists of the following:

- The new operator

- The name of an interface to implement or a class to extend. In this example, the anonymous class is implementing the interface HelloWorld.

- Parentheses that contain the arguments to a constructor, just like a normal class instance creation expression. Note: When you implement an interface, there is no constructor, so you use an empty pair of parentheses, as in this example.

- A body, which is a class declaration body. More specifically, in the body, method declarations are allowed but statements are not.

But they also provide the following example of anonymous class that contains a statement,
       HelloWorld frenchGreeting = new HelloWorld() {            String name = "tout le monde"; // this is a statement            public void greet() {                greetSomeone("tout le monde");            }            public void greetSomeone(String someone) {                name = someone;                System.out.println("Salut " + name);            }        };

Can someone explain this contradiction?

@Ali Ro Sorry. The following would work.

You somehow need to check if additional -> is needed.

Try using for loop instead of for each and test if you are about to print the last item

if no, then print 'value ->'
if yes, then print 'value'

Instead of printing value + "->", try using "->" + value

Welcome to CodeRanch.

Stephan van Hulst wrote:
What type would o1.Inner refer to? What type would o2.Inner refer to? Are they different types? If not, why would you have different ways to refer to the same type?

I see object followed by a period as a scoping into another namespace, and they would mean the same thing. I was trying to think in terms of the language grammar.

Stephan van Hulst wrote:Another complication. Consider you have a method that accepts an object of type Inner. How would you declare the method parameter if you couldn't write Outer.Inner?

This one makes a lot of sense. Thank you!

I am trying to understand why I can not create a reference of an inner class using the object of the outer class.

Here is the example classes,
class Outer{    public class Inner{    } }
I know I need to have an instance of outer class to be able to instantiate inner class. So the following makes sense,
Outer o = new Outer(); o.new Inner();
But I get an error saying 'can not resolve symbol' in the following code,

Outer o = new Outer(); // o.Inner i; // can not resolve symbol inner Outer.Inner i; // but this works i = o.new Inner();

I am assuming inner class is just like any other class members(field, methods) with public access modifier, so IMO I should be able to create a reference using the outer instance. But I can not do it. What is the justification behind having a using class name instead of an instance?

Outer.Inner feels like I am referring to a static member named Inner in the Outer class.

For example, the following works,
class Outer {    static class Inner{    } } Outer.Inner i; // allows me to create a reference of inner

So by looking at `Outer.Inner i` we can not tell if Inner is a static or non-static member of Outer.

Paul Clapham wrote:In your original example you had an array of int. Here you have an array of Integer.

Trying to understand why that would make a difference since the body of asList is the following,

public static <T> List<T> asList(T... a) {        return new ArrayList<>(a); }

Matthew Bendford wrote:Varargs T... is not just eyecandy to T[]

But then why the following code snippet works as expected?

Integer[] s = {1,2,3}; System.out.println(Arrays.asList(s)); // Prints [1, 2, 3] as expected System.out.println(Arrays.asList(1,2,3)); //  Prints [1, 2, 3] as expected

I understand that varargs (i.e. T...) is a syntactical sugar for T[]. But Arrays.asList, that accepts varargs, behaves differently when passed T... and T[].

For example,

System.out.println(Arrays.asList(1,2,3)); // output [1, 2, 3]; Expected System.out.println(Arrays.asList(new int[]{1,2,3})); // I expect the same output as before but I get [[I@7cca494b]

I am passing a int[] where T[] is expected, but the behavior is different. But why the behavior is different if T... is just a syntactical sugar for T[] ?

Thanks.

Thanks for the insight.

I can not seem to access variable declared in a static block, but I can do when it's declared as a class static variable.

For example, the following code do not work since it can not find a,

public class Solution {    static {        int a = 10;    }        public static void main(String[] args)    {        System.out.println(a); // Can not find a, why not?    } }

But this solution works because a is declared as class static,
public class Solution {    public static int a = 10;        public static void main(String[] args)    {        System.out.println(a); // Works    } }

I was under the impression that static block is similar to static statement. We need to use static block if we need to execute more than one expression. But clearly I am wrong.

Some insight would be appreciate. Thanks!

To reiterate, during compilation "HelloWorld" is put in the String pool, and during runtime, intern() is executed and results in str2 pointing to the "HelloWorld" string that was already in the string pool. Am I correct?

Ok, so I get false since str2 is assigned a value during runtime, and to have it in the String pool, I have to intern it.

So, I tried the following and it is working even if things appears out of order,

String str0 = "Hello"; String str1 = "World"; String str2 = (str0 + str1).intern(); String str3 = "HelloWorld"; System.out.println(str2 == str3);

The output returns true, since "HelloWorld" is in the string pool. But isn't it weird that the interning operation occurs before placing "HelloWorld" to the string pool? The code still returns true when I move line 4 at the top.

Is it an indication that the compiler is going over the code over multiple passes, and "HelloWorld" is already in the pool before entering operation takes place in line 3?

That means that a call to a non-private instance method will always call the version provided by the actual runtime type of the object

But isn't the runtime type changed to A by the cast in line 34?