Re: ERROR: exceded the 65,535 byte limit
Lew wrote:
Aeris wrote:
"add()" is not a static method, so you can't call it outside another
method. Try instead:
You can't call any method except 'static void main(String [])' from
outside another method. Being static or not is not relevant.
Wrong:
public class MyClass {
private final int value = Integer.parseInt(String.valueOf("14"));
}
This class is valid, "parseInt" and "valueOf" are methods, called outside a
method, but allowed in variable declaration because static.
public class MainApplication extends WebApplication {
private List<C> cheeses = new ArrayList<C>() {
{
this.add(new C(???));
Use of 'this.' to qualify a method is pointless and also contrary to the
spirit of object orientation.
Remove it if you want :)
This is a very unusual idiom, to declare a subclass of 'ArrayList' and
fill it within the subclass initializer.
Sure, but this is the only way to declare and initialize a Collection in
same time.
There is some others ways (in the constructor for example), but thoses not
work on all cases.
The idiom will break on 'final' classes or those with private
constructors.
Yes, but ArrayList is not final.
And private constructor is not a problem in this case, as shown by this
test:
public class MyClass {
private class MyCollection extends ArrayList<String> {
private MyCollection() {
}
}
public final List<String> values = new MyCollection() {
{
this.add("test");
}
};
public static void main(final String[] args) {
System.out.println(new MyClass().values);
}
}
It's also rather advanced to present to someone who is clearly struggling
with the very basics of Java.
It's advanced, but this is the only way to do the job.
What's wrong with filling the 'ArrayList' (or whatever), not a subtype, in
the constructor or an 'init()' method of 'MainApplication'?
This is not wrong, but depends on the behaviour of the other parts of the
application. This way is guaranteed to work in all cases.
In the given exemple, i see WebApplication, which often say generic proxy
factory, and other very advanced java behaviour for object handling. This is
so risky to override constructor or implements other methods.
And what's wrong to do the job in 3 lines instead of refactor all
constructors and add a new method, especially in test code?