☑ Java Grundlagen: 04.05.-08.05.15 (KW 19), 29.06.-03.07.15 (KW 27), 07.09.-11.09.15 (KW 37), 02.11.-06.11.15 (KW 45)
☑ Java für Fortgeschrittene: 18.05.-22.05.15 (KW 21), 20.07.-24.07.15 (KW 30), 28.09.-02.10.15 (KW 40), 23.11.-27.11.15 (KW 48)
☑ Java für C#-/C++-Umsteiger: 13.04.-17.04.15 (KW 16), 08.06.-12.06.15 (KW 24), 17.08.-21.08.15 (KW 34), 19.10.-23.10.15 (KW 43)
Das waren die Vorbereitungen, jetzt können wir zum eigentlichen Java-Programm kommen. Zum Testen soll einfach nur die Orientierung (also der Winkel zur Kinect) in den Winkel einer 3D-Box übertragen werden – dreht man sich vor der Kinect, wird die Box sich mitdrehen. Gleichzeitig gibt es noch einen Text, sodass man den Winkel gleich ablesen kann.
Fertig sieht das so aus:
import javafx.application.Application;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.shape.Box;
import javafx.scene.text.Text;
import javafx.scene.transform.Rotate;
import javafx.stage.Stage;
import edu.ufl.digitalworlds.j4k.J4KSDK;
import edu.ufl.digitalworlds.j4k.Skeleton;
public class MovingBody extends Application {
private final Box box = new Box( 200, 200, 200 );
private final Text text = new Text( 200, 200, "#" );
class SkeletonTracker extends J4KSDK {
@Override
public void onSkeletonFrameEvent( boolean[] skeletonTracked, float[] positions,
float[] orientations, byte[] jointStatus ) {
int skeletonId = 0;
while ( !skeletonTracked[ skeletonId ] )
skeletonId++;
Skeleton skeleton = Skeleton.getSkeleton( skeletonId, skeletonTracked, positions,
orientations, jointStatus, this );
box.setRotate( (int) skeleton.getBodyOrientation() ); // reduce "noise" with (int)
text.setText( "" + (int) skeleton.getBodyOrientation() );
text.setRotate( (int) skeleton.getBodyOrientation() );
}
@Override
public void onColorFrameEvent( byte[] colorData ) { }
@Override
public void onDepthFrameEvent( short[] depthFrame, byte[] playerIndex, float[] xyz, float[] uv ) { }
}
public MovingBody() {
new SkeletonTracker().start( J4KSDK.SKELETON );
}
@Override
public void start( Stage primaryStage ) {
Group root = new Group();
primaryStage.setScene( new Scene( root, 400, 400 ) );
primaryStage.show();
box.setTranslateX( 200 );
box.setTranslateY( 200 );
box.setTranslateZ( 200 );
box.setRotationAxis( Rotate.Y_AXIS );
root.getChildren().addAll( box, text );
}
public static void main( String[] args ) {
launch( args );
}
}
RoboVM erlaubt es, Java-Anwendungen für iOS und auch Android zu compilieren.
Ankündigung unter http://robovm.com/robovm-1-0-released-commercial-licenses-a-look-under-the-hood/.
Gegenüber der alten Version:
- The debugger has received another round of updates. All JDWP functionality is now implemented.
- Support for RAM disk caches. This can help speed up the compilation and linking process on slow HDDs.
- Support for HFS+ file compression. All files put into the cache are now compressed, further speeding up the compilation process and reducing the amount of space used for the RoboVM cache.
- Initial project template and Maven archetype support.
- A new Eclipse project wizard, using the templates project
- Support for invoking tools via robovm.xml. We currently support the TextureAtlas tool, with more to come.
- Cleanup and simplification of Objective-C bindings, see the binding status page
Neu ist eine kommerzielle Lizenz:
Our commercial license scale with the size of your business, covering solo developers, startups, SMEs and big enterprises. Depending on your plan, you’ll get access to the following features and services:
- JDWP compliant debugger for both simulator and on-device debugging
- Improved crash reporting
- Private e-mail support, with and without SLA
- JavaFX support
- Hotfix support
- Alpha channel access to new commercial features
Die Digitale Erlebnis-Center GmbH beschäftigt sich seit April 2011 intensiv mit dem Aufbau eines PC-/und Spiel-Konsolen-Museums.
Aufgaben
– Gestaltung und Entwurf interaktiver Oberflächen unter Berücksichtigung existierender Frameworks
– Auswahl und Integration von Emulatoren für Computer und Spiel-Konsolen in der musealen Gestaltung
– Recherchetätigkeiten und Erstellung von Texten über Hardware und Software
Qualifikation
– Kreativität und eine hohe Internetaffinität, praktische Erfahrung in HTML, CSS3, JavaScript. Java ist von Vorteil
– Praktische Erfahrung in Linux, Windows und grundlegender Systemkonfiguration
– Systematische, strukturierte und selbstständige Arbeitsweise mit hohem Qualitätsbewusstsein
– Team- und Kommunikationsfähigkeit, gut und sicher im Ausdruck
– Hintergrundwissen über Computer der 1980er Jahre und der Computerspielszene sind von Vorteil
Wir bieten
– Freundliche Arbeitsatmosphäre und Unterstützung bei beruflicher und persönlicher Weiterentwicklung
– Eigenverantwortliche Gestaltung des Aufgabenbereichs unter Einbringung eigener Präferenzen
– Freie Arbeitszeitgestaltung durch Heimarbeit
– Das Praktikum wird gering vergütet
Schöne Neuerungen in GWT 2.8 und der kommenden Version GWT 3.0.
Folien unter http://gwtcreate.com/slides/. Google Inbox nutzt auch GWT und für iOS den Compiler J2ObjC. Cool! Siehe auch https://github.com/Sfeir/jhybrid.
… den Pi-Day (https://de.wikipedia.org/wiki/Pi-Tag).
Er findet jedes Jahr am 14. März statt und geht zurück auf die US-amerikanische Datumsschreibweise 3/14 oder die ISO-Schreibweise -3-14, denn der numerische Wert von π auf zwei Dezimalen gerundet ist 3,14. Besonders genaue Anhänger dieses Tages feiern um 1 Uhr 59 und 26 Sekunden und erreichen die Kreiszahl damit bis zur siebten Nachkommastelle, 3,1415926. Im Jahr 2015 wird Pi um 9 Uhr 26 und 53 Sekunden sogar das erste mal, durch die Passende 15 der Jahreszeit bis zur neunten Nachkommastelle erreicht.
Details bei http://hirt.se/blog/?p=646. Bestes Feature, keine Schalter mehr beim Start der JVM, das kommt “dynamisch”:
http://www.oracle.com/technetwork/java/javase/8u40-relnotes-2389089.html.
Und es sind interessante Neuerungen dabei.
The endorsed-standards override mechanism and the extension mechanism are deprecated and may be removed in a future release. There are no runtime changes. Existing applications using the ‚endorsed-standards override‘ or ‚extension‘ mechanisms are recommended to migrate away from using these mechanisms. To help identify any existing uses of these mechanisms, the
-XX:+CheckEndorsedAndExtDirscommand-line option is available.
Grund dafür ist das neue Modulsystem,was in Java 9 kommt.
Und:
Starting with JDK 8u40 release, JavaFX controls are enhanced to support assistive technologies, meaning that JavaFX controls are now accessible. In addition, a public API is provided to allow developers to write their own accessible controls.
JDK 8u40 release includes new JavaFX UI controls; a spinner control, formatted-text support, and a standard set of alert dialogs.
Viele Bugs wurden gefixt: http://www.oracle.com/technetwork/java/javase/2col/8u40-bugfixes-2423829.html
The JDK itself can help us to count the lines of code, we just need to parse the source and get the method bodies in a String representation–then we can count the lines. A quick statistic from the new Java 8 Stream API will give us the numbers.
Code first:
import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.*;
import javax.tools.JavaCompiler;
import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import com.sun.source.tree.CompilationUnitTree;
import com.sun.source.tree.MethodTree;
import com.sun.source.util.JavacTask;
import com.sun.source.util.TreeScanner;
public class AverageNumberOfLinesInJDKFinder {
public static void main( String[] args ) throws IOException {
String[] files = findAllJavaSourceFiles( "C:/Program Files/Java/jdk1.8.0/src/" );
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
try ( StandardJavaFileManager fileManager = compiler.getStandardFileManager( null, null, null ) ) {
CompilationTask task = compiler.getTask( null, fileManager, null, null, null,
fileManager.getJavaFileObjects( files ) );
JavacTask javacTask = (JavacTask) task;
Iterable<? extends CompilationUnitTree> trees = javacTask.parse();
LineCountingVisitor lineCountingVisitor = new LineCountingVisitor();
for ( CompilationUnitTree compilationUnitTree : trees )
compilationUnitTree.accept( lineCountingVisitor, null );
DoubleSummaryStatistics stats = lineCountingVisitor.numberOfLines.stream().mapToDouble( d -> d ).summaryStatistics();
System.out.println( stats );
}
}
static String[] findAllJavaSourceFiles( String base ) throws IOException {
final List<String> result = new ArrayList<String>();
Files.walkFileTree( Paths.get( base ), new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult visitFile( Path path, BasicFileAttributes attribs ) {
if ( path.toString().endsWith( ".java" ) )
result.add( path.toString() );
return FileVisitResult.CONTINUE;
}
} );
return result.toArray( new String[result.size()] );
}
}
class LineCountingVisitor extends TreeScanner<Void, Void> {
final List<Integer> numberOfLines = new ArrayList<Integer>( 2048 );
@Override
public Void visitMethod( MethodTree node, Void p ) {
if ( node.getBody() != null ) {
int lines = new StringTokenizer( node.getBody().toString(), "\n" ).countTokens() - 1 /* { */ - 1 /* } */;
if ( lines != 0 ) // ignore empty bodies
numberOfLines.add( lines );
}
return super.visitMethod( node, p );
}
}
Result:
DoubleSummaryStatistics{count=84695, sum=576427,000000, min=1,000000, average=6,805915, max=1716,000000}
Exercise for the readers:
Mal wieder geht ein Java-Oracle-Projekt den Bach runter, dieses mal Avatar/Avatar.js (Quelle https://blogs.oracle.com/theaquarium/entry/project_avatar_update).
https://avatar-js.java.net/, https://avatar.java.net/
Avatar ist/war eine Art Node.js Implementierung in JavaScript auf der JVM.
http://nodyn.io/ ist eine spannende Altarnative, läuft aber auf einer eigenen JavaScript-Umgebung namens DynJS, nicht auf Nashorn.
Statische Schnittstellenmethoden erlauben eine neue Möglichkeit zur Deklaration der main(…)-Methode:
interface HelloWorldInInterfaces {
static void main( String[] args ) {
System.out.println( „Hallo Welt einmal anders!“ );
}
}
Das Schlüsselwort interface ist vier Zeichen länger als class, doch mit der Einsparung von public und einem Trenner ergibt sich eine Kürzung von drei Zeichen – wieder eine neue Möglichkeit zum Längefeilschen.
http://www.topjavablogs.com/ aggregiert diverse Java-Blogs und bietet einen guten Einblick in die Java-Welt.
Mustache (Apache). Sehr performantes Mustache-Templating-System für Java, benötigt Java 8.
Capsule (EPL). “Dead-Simple Packaging and Deployment for JVM Apps”. Im Kern ein Fat-Jar-Builder. Ermöglicht auch ausführbare WARs und Capsules können in Docker-Images konvertier werden. Alaternativ: One-JAR.
Pegdown Doclet (GPL 3). Markdown in Javadoc-Kommentaren statt HTML nutzen, inklusive PlantUML und Syntax Highlighting mit highlight.js.
The Checker Framework (GLP 2/MIT). Hängt sich in den Java-Compiler und führt zusätzliche Typ-Prüfungen (Null-Pointer, SQL-Injections, …) durch. Funktioniert toll mit Java 8, da nun an jeder Deklaration eine Annotation erlaubt ist.
Gradle (Apache). Gradle ist Ant in Groovy 🙂
Vor einiger Zeit hat MS begonnen die Quellen ihrer Laufzeitumgebung, Bibliotheken und Compiler auf ein Git-Repository (sync mit NET Framework TFS Server innerhalb von Microsoft) zu setzen – ein großartiger Zug! Alles steht unter der MIT-Lizenz.
Zum Einlesen:
Ich freue mich auf die spannenden Entwicklungen aus dem CLR-Lager. Hätte MS diesen Zug schon 10 Jahre früher gemacht, könnte ich gar nicht ausmalen, wie es mit der Verbreitung von Java heute aussehen würde.
Hier eine Auswahl von Produkten:
§ Enterprise Architect (http://www.sparxsystems.de/) ist ein Produkt von Sparx Systems; es unterstützt UML 2.5 und bietet umfangreiche Modellierungsmöglichkeiten. Für die Business & Software Engineering Edition Standard License sind 599 USD fällig. Eine 30-tägige Testversion ist frei. Das Tool ist an sich eine eigenständige Software, die Integration in Eclipse (und MS Visual Studio) ist möglich.
§ MyEclipse (https://www.genuitec.com/products/myeclipse/) von Genuitec besteht aus seiner großen Sammlung von Eclipse-Plugins, unter anderem auch mit einem UML-Werkzeug. Einblick in das kommerzielle Werkzeug gibt https://www.genuitec.com/products/myeclipse/learning-center/uml/myeclipse-uml2-development-overview/.
§ ObjectAid UML Explorer for Eclipse (http://www.objectaid.com/) ist ein kleines und kompaktes Werkzeug, das Klassen aus Eclipse einfach visualisiert. Es entwickelt sich langsam zu einem größeren kommerziellen Produkt.
§ TOPCASED/PolarSys (http://www.topcased.org/) ist ein umfangreicher UML-Editor für Eclipse.
§ Together (http://www.borland.com/products/together/) ist ein alter Hase unter den UML-Tools – mittlerweile ist der Hersteller Borland bei Micro Focus gelandet. Es gibt eine 30-tägige Demoversion. Die Version 12.7 basiert auf Eclipse 4.4, ist also hinreichend aktuell.
§ Rational Rose (http://www-01.ibm.com/software/de/rational/design.html) ist das professionelle UML-Werkzeug von IBM. Es zeichnet sich durch seinen Preis aus, aber auch durch die Integration einer ganzen Reihe weiterer Werkzeuge, etwa für Anforderungsdokumente, Tests usw.
§ UMLet (http://www.umlet.com/) ist ein UML-Zeichenwerkzeug und geht auf ein Projekt der Vienna University of Technology zurück. Es kann alleinstehende eingesetzt oder in Eclipse eingebettet werden. Auf Google Code liegt der offene Quellcode: https://code.google.com/p/umlet/.
§ Der quelloffene UML Designer (https://obeonetwork.github.io/UML-Designer/) greift auf viele Eclipse-Projekte zurück.
§ UML Lab von yatta (http://www.uml-lab.com/de/uml-lab/).
Viele Werkzeuge kamen und gingen, unter ihnen:
§ eUML2 (http://www.soyatec.com/euml2/) und EclipseUML von Omondo (http://www.omondo.com/) sind Eclipse-basierte UML-Tools. Es gibt ältere freie, eingeschränkte Varianten. eUML2 basiert auf Eclipse 4.3, die letzte Version ist von Dezember 2013. Bei EclipseUML hält das Unternehmen sogar an Eclipse 3.7 fest, und schreibt „Omondo will not anymore deliver builds for Eclipse 4 because it was a technological failure.“
§ ArgoUML (http://argouml.tigris.org/) ist ein freies UML-Werkzeug mit UML 1.4-Notation auf der Basis von NetBeans. Es ist eigenständig und nicht in Eclipse integriert – Ende 2011 stoppte die Entwicklung, die letzte Version ist 0.34.
§ NetBeans hatte lange Zeit ein schönes UML-Werkzeug, das jedoch nicht auf die neuen Versionen portiert wurde.
Fehlt was?
Da null viel zu oft vorkommt, null-Referenzierungen aber vermieden werden müssen, gibt es viel Code der Art: o != null ? o : non_null_o.
Diverse Programmiersprachen bieten für dieses Konstrukt eine Abkürzung über den sogenannten null coalescing operator (Coalescing, zu Deutsch verschmelzend), der geschrieben wird mal als ?? oder als ?:, für unser Beispiel: o ?? non_null_o. Besonders hübsch ist dass bei sequenziellen Tests der Art o ?? p ?? q ?? r, wo es dann sinngemäß lautete: Liefere die erste Referenz ungleich null.
Java-Programmierer kommen nicht zu diesem Glück, können aber tricksen (http://stackoverflow.com/a/28306286/388317):
If there are only two references to test and you are using Java 8, you could use
Object o = null;
Object p = "p";
Object r = Optional.ofNullable( o ).orElse( p );
System.out.println( r ); // pIf you import static Optional the expression is not too bad.
Unfortunately your case with „several variables“ is not possible with an Optional-method. Instead you could use:
Object o = null; Object p = null; Object q = "p"; Optional<Object> r = Stream.of( o, p, q ).filter( Objects::nonNull ).findFirst(); System.out.println( r.get() ); // p
Im folgenden Beispiel deklariert die main(…)-Methode eine innere Klasse Snowden mit einem Konstruktor, der auf die finale Variable PRISM zugreift:
public class NSA {
public static void main( String[] args ) {
final int PRISM = 1;
int tempora = 2;
tempora++; // (*)
class Snowden {
Snowden() {
System.out.println( PRISM );
// System.out.println( tempora ); // Auskommentiert ein Compilerfehler
}
}
new Snowden();
}
}
Die Deklaration der inneren Klasse Snowden wird hier wie eine Anweisung eingesetzt. Ein Sichtbarkeitsmodifizierer ist bei inneren lokalen Klassen ungültig, und die Klasse darf keine Klassenmethoden und allgemeinen statischen Variablen deklarieren (finale Konstanten schon).
Jede lokale Klasse kann auf Methoden der äußeren Klasse zugreifen und zusätzlich auf die lokalen Variablen und Parameter, die final sind. Das ist die Variable PRISM auf jeden Fall, tempora ist nicht final (tempora++ ist ein Schreibzugriff), und daher führt eine Konsolenausgabe mit println(tempora) auch zu einem Compilerfehler – Eclipse meldet: „Local variable tempora defined in an enclosing scope must be final or effectively final”. Der letzte Teil der Fehlermeldung gibt einen Hinweis auf eine kleine Änderung seit Java 8, dass Variablen nicht zwingend mit dem Modifizierer final ausgezeichnet werden müssen, um final zu sein. Gibt es keinen Schreibzugriff auf Variablen, sind sie effektiv final. Im Beispiel kann das einfach getestet werden: Wird die Zeile (*) mit tempora++; auskommentiert, so ist tempora effektiv final und Snowden kann auf tempora zugreifen.
Liegt die innere Klasse in einer statischen Methode, kann sie keine Objektmethoden der äußeren Klasse aufrufen.
https://6to5.org/docs/learn-es6/. JavaScript wird eine starke Sprache, im Juni 2015 soll die Spezifikation final sein. Der Vorgänger, ES5 stammt von 2009.
https://6to5.org/ ist ein Konverter, der ES6-Code in ES5-Code konvertiert, soweit es möglich ist. CoffeeScript wird dann nicht mehr nötig sein.
Wieder eine Menge Interessantes dabei, vieles adressiert die Entwicklung von Web-Anwendungen: http://wiki.netbeans.org/NewAndNoteworthyNB81. NB ist heute schon lange keine reine Java-IDE mehr.
Es ist angeraten die Updates zu installieren:
Oracle stuft die Fehler als kritisch ein.
http://www.oracle.com/technetwork/topics/security/cpujan2015-1972971.html