• X(twitter): @kis • blog: きしだのHatena • (nowokay.hatenablog.com) • Writing Java book「プロになるJava」 • not only for Java introduction but also Programming introduction
it is just notation • Importance is I/O or UI definition and architecture • we don't design each procedure. Just follow the architecture. • we decide the detail of design during coding perhaps with test • (the term 'design' refers to the pre-code outline)
written as obj.method() • I doubt whether it is effective enough to make a big trend • OO if you use classes • structure enough? • OO if you write data and functions together • Abstract Data Type • OO if you create objects • To avoid static, to create objects for object-oriented laundering • All good ideas for development is OO • Software engineering branding failure...
commutative • Objects with no attribute and single method can be treated as a function • Java lambda expression • A function that returns an element binding giving name can be treated as an object Function<String, Integer> myObj(int a, int b) { return name -> switch(name) { case "a" -> a; case "b" -> b; case "mul" -> a * b; case "add" -> a + b; default -> throw new RuntimeException(); }; } class MyFunc() { int apply(int a, int b) { return a + b; } }
the missing feature of the language • Something is wrong on memorizing patterns and writing them by hands • Many patterns are no longer necessary with some of language feature • The patterns of higher-order functions are reproduced using class and inheritance • ex Template methods
void proc(Runnable before, Runnable after) { before.run(); println("Hello"); after.run(); } proc(() -> println("Stand up"), () -> println("Sit down")); ※ Runnable is used to represent a function with no arguments and no return value
conditions • Thinking about the cart summarization • Calculation is different between Packed and Bulk sealed interface Type { record Bulk(int price, int unit) implements Type {} record Packed(int price) implements Type {} } record Item(Type type, int amount) {} var cart = List.of( new Item(new Packed(300), 3), new Item(new Bulk(250, 100), 230));
List.of( new Item(new Packed(300), 3), new Item(new Bulk(250, 100), 230)); int total = cart.stream() .mapToInt(item -> switch(item) { case Item(Packed(int price), int amount) -> price * amount; case Item(Bulk(int price, int unit), int amount) -> price * amount / unit; }).sum();
streamlined • no change the calc part even if another Type added sealed interface Type { int calc(int amount); record Bulk(int price, int unit) implements Type { int calc(int amount) { return price * amount / unit; } } record Packed(int price) implements Type { int calc(int amount) { return price * amount; } } } var cart = List.of( new Item(new Packed(300), 3), new Item(new Bulk(250, 100), 230)); int total = cart.stream() .mapToInt(item -> item.type().calc(item.amount())) .sum();
multiple classes • It is difficult to write when the condition is not only Type • Time zone, etc • branching is required within the Type • It is a problem if there is Type that you don't know • In business processing, it is better to have all in one place
OO is a technique for modularization • But modularization is already done • Browser - WebServer • Micro Service • No need to further modularize our programs • Data Oriented • treat a data as data(not object) • define characteristics of data as a type • https://www.infoq.com/articles/data-oriented-programming-java/
effect • Same return value for same arguments • Pure data type(Coined word in this session) • No side effects outside of the data type • Same return value for same arguments and same attributes
catch (IOException | InterruptedException ex) • inherit • Possible patterns are additive • boolean | byte • 2 + 256 = 258 patterns • sealed sealed interface Op { record AddOp(int a, int b) implements Op {} record SubOp(int a, int b) implements Op {} }
type and as modules • Class as data type • Multiple instance • The fields hold another data that contains • Class as module • basically Singleton • fields hold another module that depends • Becomes a subsystem • Collection of procedures class Name { String first; String last; Name(String first, String last) { this.first = first; this.last = last; } String toString() { return first + " " + last; } } @RestController class Greeting { @GetMapping("/hello") String hello() { return "hello"; } @GetMapping("/myname") Name myName() { return new Name("Naoki", "Kishida"); } }
Class has a characteristic of type and a characteristic of module Classification Role Characteristic Note System boundary External interactions like I/O Module + Type Fit for Object Oriented. but already provided by frameworks and libraries Data Retain a data Type Procedure Describe the procedure Module not treated as a type
the end of the module • Ex: DOM、HTTP、DB connections requre state management • Intermediate processing can be stateless GUI logic data store user application DOM HTTP DB conn
MySQLConnection and OracleConnection, it good to use object-oriented • but MySQLConnection and OracleConnection are required as only one implementation • If browser manages GUI state, GUI framework can be stateless • Structured GUI definition and event handlers
processing is stateless • Module is a collection of functions • Dividing function, use layer • avoiding infinite loops • Data flows on layers • Data-oriented programming
management • Words other than object-oriented can be used for other than inheritance • Easy to communicate technically because there is no confusion • Object-Oriented rarely appears in application • Managing state on terminal, the middle will be stateless=Functional • Required for frameworks and middleware • Let's study object-oriented and create frameworks and middleware!
kishida
hugobarauna
cut0
satoshi256kbyte
kddnewton
noppefoxwolf
objectiveaudio
susisu
uhooi
chobishiba
shinyaigeek
makenowjust
kubode
cherdarchuk
shlominoach
chriscoyier
panda_program
holman
phodgson
maltzj
mraible
tanoku
keavy
deanohume
shpigford
