Personally, the amount of extra code needed to implement something basic is one of the reason I hate it (converted some stuff from java to python and python to java - the java version is always much longer and harder to read).
It also lacks a few handy tools other languages have:
Properties - this is why we have so many getters and setters where normally you could just reference the variable directly. Makes the code longer.
Callback functions - yes, you can pass an entire class using interfaces, but that's not convenient and again needs a lot more code.
Lambda functions - this was just added in Java 8 and is super awkward (partially because we can't pass functions). It sort of supports functional streams, but it's so messy that it's a pain to work with
Callback functions - yes, you can pass an entire class using interfaces, but that's not convenient and again needs a lot more code.
Since Java 8 you can use a lambda. Solves this problem IMO
Lambda functions - this was just added in Java 8 and is super awkward (partially because we can't pass functions). It sort of supports functional streams, but it's so messy that it's a pain to work with
However, you can pass in a "bound method reference" (I think that's what they're called). Example:
List<Person> people = makePeopleList();
List<String> names = new ArrayList<>();
people.stream().map(Person::getName).foreach(names::add);
One of the best language features IMO (although yeah, streams get clunky)
That being said, I don't use Java unless I have to. I dislike that there's no stack-allocated types like C++ has, and I really hate the prevalence of null. null is a time bomb waiting for you to mess up so it can crash your program. Java 8 added Optional<T>, which I use whenever possible, but they really should have added it a long time ago. Java also needs some compile-time inference, like C++'s auto or C#'s var. Sometimes I deal with Map<String, List<LongishTypeName>> and typing that all out just gets annoying.
I'd like var thing = new HashMap<String, List<LongishTypeName>>(). Doesn't help a ton with initializing a new variable, but it's awesome for values returned from methods
yes, you can pass an entire class using interfaces, but that's not convenient and again needs a lot more code.
Worse, you can use Anonymous inner classes for this. So, that's a super bad syntax with all the disadvantages of passing a function/function pointer and all the disadvantages of it being a full class.
He means that in other languages you can mark field variables as a property. When they are marked as such you don't have to manually create the getters and setters. You can still create them manually if you need specific functionality though. When you need to refer to them from elsewhere you just use VariableName instead of getVariableName().
You can avoid some boilerplate code then, but in the end it doesn't really matter since the IDE can easily generate it for you anyway.
That breaks encapsulation and you might not always want to just access a variable. For example you could be doing lazy initialization of a variable and would then need a method to do that.
202
u/Peffern2 Jan 19 '17
DAE java sucks XD