java: why comp. error when I initialize an array using {} not during declaration

why do I get a compilation error if I try to initialize an array using braces on a statement other than the declaration statement

Because it's just not valid to do that in Java, basically. The compiler is just enforcing the rules of the Java Language Specification. You need to specify the array type:

myName = new String[] { ... };

From the Java Language Specification, section 10.6:

An array initializer may be specified in a declaration (§8.3, §9.3, §14.4), or as part of an array creation expression (§15.10), to create an array and provide some initial values.

The various sections on declarations include this production:

VariableInitializer:
    Expression
    ArrayInitializer

Whereas an array creation expression (section 15.10) is:

ArrayCreationExpression:
    new PrimitiveType DimExprs Dimsopt
    new ClassOrInterfaceType DimExprs Dimsopt
    new PrimitiveType Dims ArrayInitializer 
    new ClassOrInterfaceType Dims ArrayInitializer

DimExprs:
    DimExpr
    DimExprs DimExpr

DimExpr:
    [ Expression ]

Dims:
    [ ]
    Dims [ ]

Later:

what's the point of having to initialize using braces only in the declaration statement?

I suspect it simplifies the language specification in other aspects. I agree it looks like you should be able to do this - you might expect the compiler to be able to infer the array type from the variable type, as it does at declaration time. But bear in mind that in general, for most of the language, the type of the expression on the right hand side of the assignment operator is not affected by the target of the assignment. It's generally neater in language terms for each expression's type within a normal statement to be well-defined without reference to other expressions in the same statement.

It's fairly easy fix to fix your code with an array creation expression, so I would just live with it.

The syntactically correct way to write what you're trying to write is:

myName = new String[]{"AA", "BB", "CC"};

I suspect the reason Java doesn't allow omitting new String[] is that in many contexts there's no way for the compiler to figure out the desired type of the array from the types of the elements. Let's say you were allowed to write:

{1, 2, 3}

Is that int[], Integer[], Number[] or Object[]?

The only place where are you're allowed to omit new String[] is initializers, where the compiler already knows the array type.