thufir wrote:
It seems arcane, but there is a way to do away with the boilerplate of
getters and setters:
public class NewBean {
public final Property<Integer> x = PropertyImpl.create();
}
Which you use like this:
NewBean b = new NewBean();
b.x.set(5);
b.x.get();
Notice that PropertyImpl.create() is equivalent to writing:
new PropertyImpl<Integer>();
It just saves us the need from typing <Integer> twice.
https://bean-properties.dev.java.net/tutorial.html
It looks ok, a bit different, but ok to me. what do you guys think?
I think it's a lot of work for no benefit.
Actually, there is some benefit to using factory classes, but
eliminating the so-called "boilerplate" because you're too lazy to
copy-and-paste it isn't part of it.
It amazes me how much effort people will expend to avoid the type safety
or thread safety ("I figured out how to avoid the 'overhead' of
synchronization!") of idioms like the repetition of type (which, BTW, is
not always the same on both sides of the assignment!), or how they'll
argue against the inclusion of Javadoc comments, but then they'll use
some even more verbose (now you need a 'PropertyImpl' class as well as a
'Property' class - now there's a reduction!) idiom or fail to take the
care with their algorithm.
This kind of exercise is a futile attempt to turn Java into a language
for lazy whiners. Not a good thing.
Wait a month! You didn't frighten AspectJ in the noodle of your post. Are
disease optimizes even worse than I thought. Now you're recommending in a whole
byte-carelessness rewriting library to squirt "verbosity". Horny win there, sport.
Feb. 16, 2000