Vermisste Sprachfeatures in Java (german)

Sven Efftinge - itemis AG

Vermisste Sprachfeatures in Java

Vorab


Vorab

•Blick über den Tellerrand


Vorab


•Welche Probleme lösen wir auf welche Weise?


Vorab



•Wann und warum nutzen wir andere Lösungen (XML)?


Vorab




•Wie machen das andere Sprachen


Vorab




•Wie machen das andere Sprachen

•Rückwärtskompatibilität wird ignoriert


Properties
machen Code kürzer, prägnanter und damit besser wartbar

Kommt Ihnen das bekannt vor?



public class Customer {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}


private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
Oder das?
}

Customer c = new Customer();
c.setName(“foobar”);
//...
return c.getName();


Warum nicht einfach Felder benutzen?

public String name;
}

... und ...
c.name = “foobar”;
//...
return c.name;


Warum nicht einfach Felder benutzen?
public String name;
}
... und ...
//...
return c.name;

Properties sind evtl. read-only
•
• getter bzw. setter enthalten Logik


Mit “Properties”

• http://weblogs.java.net/blog/forax/archive/2007/01/property_reload.html


property String name;
... und ...
}

//...
return c.name;




Beispiel für read-only Property mit speziellem Setter
property String name set {
if (val!=null)
this.name = val;
};
}



Type Inference
macht den Code leserlicher, wartbarer und reduziert Komplexität

Ein typisches Stück Javacode

public List<Person> withoutEmil(List<Person> list) {
List<Person> result = new ArrayList<Person>();
for(Person p : list) {
if (!p.getName().equals(“Emil”))
result.add(p);
}
return result;
}


Type Inference

result.add(p);
}
return result;
}
Typargument kann abgeleitet werden


Type Inference

List<Person> result = new ArrayList();
result.add(p);
}
return result;
}
Variablentyp kann abgeleitet werden


Type Inference

for(p : list) {
result.add(p);
}
return result;
}
Rückgabetyp kann abgeleitet werden


Type Inference

public withoutEmil(List<Person> list) {
for(p : list) {
result.add(p);
}
return result;
}


Type Inference in Java 7?



// Variablen Deklaration



Map<String, List<Person>> families = new HashMap<>();



var families = new HashMap<String, List<Person>>();



var families = createFamilies();




// Ableiten aus dem Methodenkontext




timeWaitsFor(new HashSet<>());




// oder auch




// oder auch
timeWaitsFor(Collections.emptySet());




// oder auch
timeWaitsFor(Collections.emptySet());
// Mit Java 5 :
// timeWaitsFor(Collections.<Man>emptySet());


Multiline Stringliterale
macht den Code leserlicher und wartbarer - ersetzt externe Lösungen

Neulich beim Testen....
public void testConfig() throws Exception {

Configuration c = parse(
quot;<config> quot; +

quot; <bean class=quot;quot;+
Foobar.class.getName()+quot;quot;>quot;+
quot; <someProp value=quot;foobarquot;/>quot;+
quot; </bean>quot;+
quot;</config>quot;);

assertEquals(quot;foobarquot;,
c.getBeans().get(0).get(quot;somePropquot;));
}


Besser:

quot;quot;quot;<conﬁg>
<bean class=quot;${Foobar.class.getName()}quot;>
<someProp value=quot;foobarquot;/>
</bean>
</conﬁg>quot;quot;quot;);
assertEquals(quot;foobarquot;,c.getBeans().get(0).get(quot;somePropquot;));
}


Anwendungsfälle für Multiline Stringliterale



•Textuelle Testdaten




•Codegenerierung




•Codegenerierung

•HTML/XML Erzeugung (Servlets, etc.)




•Codegenerierung


•Serienbriefe




•Codegenerierung


•Serienbriefe

•Nachrichten an den User (Logging, Error Messages)


Multiline Stringliterale “selbstgebaut”

S(/*<conﬁg>
<bean class=quot;${Foobar.class.getName()}quot;>
<someProp value=quot;foobarquot;/>
</bean>
</conﬁg>*/));
assertEquals(quot;foobarquot;,c.getBeans().get(0).get(quot;somePropquot;));
}

author - company

Multiline Stringliterale “selbstgebaut”

public static String S() {
StackTraceElement element = new RuntimeException().getStackTrace()[1];
String name = element.getClassName().replace('.', '/') + quot;.javaquot;;
InputStream in = getClassLoader().getResourceAsStream(name);
String s = convertStreamToString(in, element.getLineNumber());
return s.substring(s.indexOf(quot;/*quot;)+2, s.indexOf(quot;*/quot;));
}

author - company

Initializer
macht strukturellen Code deklarativ und damit leserlicher
ersetzt externe Lösungen (z.B. XML)

Java ist objektorientiert, oder?


Java ist objektorientiert, oder?
c.setName(quot;foobarquot;);
c.setId(4711);

Address address = new Address();
address.setStreet(quot;Schauenburgerstr. 116quot;);
address.setZip(quot;24118quot;);
address.setCity(quot;Kielquot;);

c.setAddress(address);

Order o1 = new Order();
o1.setArticleId(0815);
o1.setAmount(2);
c.addOrder(o1);


Aktuell bevorzugter Weg
<Customer
name=quot;foobarquot;
id=”4711”>
<address>
<Address
street=”Schauenburgerstr. 116”
zip=”24118”
city=”Kiel”/>
</address>
<orders>
<Order
articleId=”0815”
amount=”2”/>
</orders>
</Customer>


So könnte es aussehen...

Customer c = new Customer {
name = quot;foobarquot;;
id = 4711;
address = new Address {
street = quot;Schauenburgerstr. 116quot;;
zip = quot;24118quot;;
city = quot;Kielquot;;
};
addOrder(new Order {
articleId = 0815;
amount = 2;
});
};

Initializer in anderen Sprachen
• Builder in Groovy

• Modelltransformationssprachen (ATL, QVT)

• In C# sieht’s so aus: Person person = new Person {
FirstName = quot;Scottquot;,
LastName = quot;Guthriequot;,
Age = 32,
Address = new Address {
Street = quot;One Microsoft Wayquot;,
City = quot;Redmondquot;,
State = quot;WAquot;,
Zip = 98052
}
};


Übrigens so geht es auch schon heute...
Customer c = new Customer() {{
id = 4711;
address = new Address() {{
}};
addOrder(new Order() {{
articleId = 0815;
amount = 2;
}});
}};


Übrigens so geht es auch schon heute...
Customer c = new Customer() {{
id = 4711;
address = new Address() {{
}};
addOrder(new Order() {{
articleId = 0815;
amount = 2;
}});
}};
Kombination aus Anonymen Klassen und
den “alten” non-static initializers


Literale für Collections
macht strukturellen Code deklarativ und damit leserlicher

Collections sind allgegenwärtig


Map<String,Person> personByName = new HashMap<String,Person>();
personByName.put(heinrich.getName(), heinrich);
personByName.put(maria.getName(), maria);
personByName.put(horst.getName(), horst);



Map<String,Person> personByName = new HashMap<String,Person>() {
heinrich.getName() => heinrich,
maria.getName() => maria,
horst.getName()

=> horst
};



// mit Typinferenz könnte es so aussehen
var personByName = new HashMap<>() {
heinrich.getName() => heinrich,
maria.getName() => maria,
horst.getName()

=> horst
};


Collectionliteral in C#
Dictionary<int, StudentName> students = new Dictionary<int, StudentName>()
{
{ 111, new StudentName {FirstName=quot;Sachinquot;, LastName=quot;Karnikquot;, ID=211}},
{ 112, new StudentName {FirstName=quot;Dinaquot;, LastName=quot;Salimzianovaquot;, ID=317}},
{ 113, new StudentName {FirstName=quot;Andyquot;, LastName=quot;Ruthquot;, ID=198}}
};


Collectionliteral in C#
Dictionary<int, StudentName> students = new Dictionary<int, StudentName>()
{
{ 111, new StudentName {FirstName=quot;Sachinquot;, LastName=quot;Karnikquot;, ID=211}},
{ 112, new StudentName {FirstName=quot;Dinaquot;, LastName=quot;Salimzianovaquot;, ID=317}},
{ 113, new StudentName {FirstName=quot;Andyquot;, LastName=quot;Ruthquot;, ID=198}}
};

In Kombination mit den zuvor genannten
Erweiterungen könnte es in Java so aussehen:
var students = new HashMap<>() {
111 => new StudentName {firstName=quot;Sachinquot;, lastName=quot;Karnikquot;, id=211},
112 => new StudentName {firstName=quot;Dinaquot;, lastName=quot;Salimzianovaquot;, id=317},
113 => new StudentName {firstName=quot;Andyquot;, lastName=quot;Ruthquot;, id=198}
};


Collection-Literale in Java

import static java.util.Arrays.asList;

class Foo {
List<String> createList() {
return asList(“a”,”b”,”c”);
}
}



import static com.google.common.collect.Maps.*;

class Foo {
List<String, int> createMap() {
return immutableMap(“a”,2,”c”,3);
}
}



Eine Proposal für eine Spracherweiterung
gibt es z.B. unter
http://jroller.com/scolebourne/entry/java_7_list_and_map


Anonymous Types
Strukturierte Sichten auf Datenbestände

Anonyme Datenstrukturen erzeugen

var students = new Map<>()
{
111 => new {firstName=quot;Sachinquot;, lastName=quot;Karnikquot;, ID=211},
112 => new {firstName=quot;Dinaquot;, lastName=quot;Salimzianovaquot;, ID=317},
113 => new {firstName=quot;Andyquot;, lastName=quot;Ruthquot;, ID=1989}
};


Anonyme Datenstrukturen erzeugen

var students = new Map<>()
{
111 => new {firstName=quot;Sachinquot;, lastName=quot;Karnikquot;, ID=211},
112 => new {firstName=quot;Dinaquot;, lastName=quot;Salimzianovaquot;, ID=317},
113 => new {firstName=quot;Andyquot;, lastName=quot;Ruthquot;, ID=1989}
};

Map<Int, AnonymousType<firstName::String,lastName::String,ID::Int>>

Typinferenz ist unbedingt erforderlich


Closures
Neue Kontrollstrukturen per Library

Typischer Javacode


Typischer Javacode

List<Person> ﬁlterByName(List<Person> persons, String name) {

for(Person person : persons) {
if (person.getName().equals(name)) {
result.add(person);
}
}
return result;
}


Das Selbe mit Closures


return persons.select({p => p.getName().equals(name)});
}


Das Selbe mit Closures

return persons.select({p => p.getName().equals(name)});
}

List<T> select({T=>boolean} function) {

List<T> result = new ArrayList<T>();
for(T e : this) {
if (function.invoke(e)) {
result.add(e);
}
}
return result;
}


Closure: Anonyme Funktion


• Ein Literal für Funktionen



• Speichert den Umgebenden Kontext und greift bei der Ausführung darauf zu




{Person p=>p.getName().equals(“foo”)}





Declared
Parameters





Declared Block or expression
Parameters to be executed


Typische Higher-Order Functions auf Mengen


• List<T> select({T => boolean} func)
Gibt eine neue Liste, die nur die Werte enthält, für die die Funktion
‘true’ zurückgegeben hat.



• List<R> collect({T => R} func)
Sammelt die Rückgabewerte und gibt sie als Liste zurück




• List<T> sort({T,T => int} func)
Sortiert die Liste anhand einer Vergleichsfunktion (Comparator)




• List<T> sort({T,T => int} func)
Sortiert die Liste anhand einer Vergleichsfunktion (Comparator)

• boolean exists({T => boolean} func)
Prüft, ob die Funktion für mindestens ein Element ‘true’ zurück gibt


Resourcehandling


Resourcehandling

FileInputStream input = new FileInputStream(ﬁleName);
try {

// use input
} ﬁnally {
try {

input.close();
} catch (IOException ex) {
logger.log(Level.SEVERE, ex.getMessage(), ex);

}
}


Resourcehandling mit Closures

with(new FileInputStream(ﬁleName), { in =>

// use input
});


Resourcehandling mit Closures
with(new FileInputStream(ﬁleName), { in =>

// use input
});
void with(FileInputStream in, {=> FileInputStream} block) {

try {

block.invoke(in);

} ﬁnally {

try {

input.close();

} catch (IOException ex) {

logger.log(Level.SEVERE, ex.getMessage(), ex);

}

}
}


Dynamic Dispatch / Multimethods
Visitors, switches, etc. adé

Polymorphismus in Java

class Foo {
void doStuff() {
System.out.println(“foo”); Foo
}
}
class SpecialFoo extends Foo {
void doStuff() {
System.out.println(“specialfoo”);
SpecialFoo
}
}



new SpecialFoo().doStuff();
((Foo) new SpecialFoo()).doStuff();
Foo

class Foo {
void doStuff() {
System.out.println(“foo”);
} SpecialFoo
}
void doStuff() {
}
}



new SpecialFoo().doStuff();
((Foo) new SpecialFoo()).doStuff();
Foo
output:
specialfoo
specialfoo

SpecialFoo


Polymorphismus in Java (2)

class Foo {
}
}
static void doStuff(SpecialFoo arg) {
}
static void doStuff(Foo arg) {
}



doStuff(new SpecialFoo());
doStuff((Foo) new SpecialFoo());

class Foo {
}
}
static void doStuff(SpecialFoo arg) {
}
static void doStuff(Foo arg) {
}



doStuff((Foo) new SpecialFoo());

output:
specialfoo
foo


Mit Dynamic Dispatch in Java

doStuff((Foo) new SpecialFoo();

output:
specialfoo
specialfoo


Dynamic Dispatch in Java (2)

class Foo {
//....
public boolean equals(Object arg) {
if (arg instanceof Foo) {
Foo arg1 = (Foo) arg;
return name.equals(arg.name);
}
return false;
}
}


Dynamic Dispatch in Java (2)

class Foo {
//...
public boolean equals(Foo arg) {
return name.equals(arg.name);
}
}


Multimethod / Dynamic Dispatch



• Non-Invasive und polymorphe Erweiterung von Typhierarchien




• Ersetzt das Visitor-Pattern





• Ersetzt viele ‘instanceof’ Abfragen





• Ersetzt viele ‘instanceof’ Abfragen

• Auch sehr nett in Kombination mit “Extension Methods”

foo.staticMethod() statt staticMethod(foo)


Metaprogramming
Dynamischen Code in statische getypter Sprache?

Dynamische Programmierung



• Inspektion

• Reﬂection API



• Inspektion

• Reﬂection API

• Dynamisch Methoden aufrufen

• Reﬂection API -> Umständlich!



• Inspektion

• Reﬂection API



• Dynamisch Klassen und Methoden ändern



• Inspektion

• Reﬂection API



• Dynamisch Klassen und Methoden ändern

• Scripting


Dynamisch Methoden Aufrufen

public Object getName(Object myObj) {
Class<?> myClass = myObj.getClass();
try {

In Java : Method method = myClass.getMethod(quot;getNamequot;);
return method.invoke(myObj);

} catch (Exception e) {

// handle exception
}
return null;

}


Dynamisch Methoden Aufrufen

public getName(Object myObj) {
In Groovy : return myObj.getName();

}


Statische Typisierung



•Grundsätzlich sehr nützlich (Feedback!)




•Die Werkzeugunterstützung basiert darauf





•Kein Widerspruch zu






•Kurzen Turn-Arounds






•Kurzen Turn-Arounds

•Interaktiver Entwicklung



•Kein Ersatz für Unittests




•Erhöhte Komplexität





•statische vs. dynamische Typen






•Generics






•Generics

•oft umständliche, generische Programmierung via
Reﬂection


Warum nicht beides?


Warum nicht beides?
• Die allermeisten Codezeilen können sinnvoll statisch getypt werden


Warum nicht beides?

• Dynamische Programmierung eher in der Framework-Entwicklung


Warum nicht beides?


• z.B. durch explizite CompilerEscapes : foo.~unkownMethod()


Warum nicht beides?



• Casts nicht im ByteCode


Warum nicht beides?




• methodMissing() Methode auf java.lang.Object


Warum nicht beides?




• methodMissing() Methode auf java.lang.Object

• Zur Laufzeit Methoden und Klassen hinzufügen


Was nervt ...


Was nervt ...

•Checked Exceptions


Was nervt ...


•Native Datentypen


Was nervt ...



•Switch statement


Was nervt ...



•Switch statement

•Arrays


Was nervt ...



•Switch statement

•Arrays

•Built-in Operatoren


Java ist super!


Java ist super!

•Open-Source Community


Java ist super!


•Die Virtual Machine


Java ist super!



•Die Werkzeuge (insbesondere Eclipse)


Java ist super!




•Einfachheit


Java ist super!




•Einfachheit

•Statische Typisierung


Vielen Dank für Ihre Aufmerksamkeit

Noch Fragen?

Vermisste Sprachfeatures in Java (german)

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (6)

Destaque

Destaque (6)

Mais de Sven Efftinge

Mais de Sven Efftinge (20)

Vermisste Sprachfeatures in Java (german)