Empfohlen
Weitere ähnliche Inhalte
Ähnlich wie Writing clean code with modern Java
Ähnlich wie Writing clean code with modern Java (20)
Mehr von Miro Cupak
Mehr von Miro Cupak (20)
Kürzlich hochgeladen
Kürzlich hochgeladen (20)
Writing clean code with modern Java
- 1. @mirocupak Writing clean code with modern Java Miro Cupak Co-founder & VP Engineering, DNAstack May 24, 2019
- 2. @mirocupak !2 Features • Private methods in interfaces. • Improved try-with-resources. • Switch expressions. • Local variable type inference.
- 3. @mirocupak !3 Clarity, simplicity, brevity, humanity https://theamericanscholar.org/writing- english-as-a-second-language/ http://www.osnews.com/story/19266/WTFs_m https://xkcd.com/1695/
- 5. @mirocupak Private methods in interfaces !5
- 6. @mirocupak !6 Private methods in interfaces • Default methods, like all other methods, should be short. • Use private methods to keep default methods short. • DRY. • Use private methods to extract shared core of default methods. • Use default methods for providing standard implementations for new interface code. • Don’t use default methods to extend existing interfaces unless it’s necessary.
- 8. @mirocupak !8 Improved try-with-resources • Always prefer try-with-resources, don’t use try-finally and definitely don’t use finalizers to close resources. • Be aware of convenience methods, such as InputStream.transferTo. • Don’t create unnecessary helper objects.
- 10. @mirocupak !10 Switch expressions • Preview feature in JDK 12 — be careful about using in a production system! • switch statement can now be used as either a statement or an expression. • Both forms can use either a traditional or simplified scoping and control flow behaviour. • Prefer the simplified form — concise and convenient! • Multiple comma-separated labels supported in a single switch label - aggregate your cases. • Remember that cases must be exhaustive - don’t forget default! • Give break statements arguments to return values after statements. • Poly expressions, work well with local variable type inference.
- 11. @mirocupak Local variable type inference !11
- 12. @mirocupak !12 Local variable type inference • Does not replace static typing. • Generally good - reduces boilerplate, improves readability, and helps with maintenance and refactoring. • Use for local variables with initializers (especially constructors) and for loops. • Use for complex types when breaking chained or nested expressions with local variables. • Can’t use for declarations without explicit initialization, null or array initializers, compound declarations, method signatures, class fields, catch formals, lambdas or method references.
- 13. @mirocupak !13 Local variable type inference • Consider whether to use when the generated type is not obvious. • Primitive types might surprise you, be careful (e.g. byte, short, long all inferred as int). • Code to the interface pattern does not work, but that’s kind of OK. • Be very careful about combining with <> and generic methods (e.g. var list = new ArrayList<>()). • Works with non-denotable types (e.g. intersection types), but be careful! • Capture variables are projected to supertypes that do not mention capture variables. • Probably not the best idea to use with anonymous classes.
- 14. @mirocupak !14 Local variable type inference • Use carefully chosen and expressive variable names. • Don’t use var as names of variables, methods, enums (even if it works). • Don’t use Hungarian notation. • Don’t rely on IDEs. • Minimize the scope of local variables. • Declare variable when it’s first used. • Declaration not containing an initializer (i.e. you can’t use var) often indicates the scope is not minimal. • Prefer for loops to while loops. • Keep methods small and focused.