Refreshing Java

Java 101 refresher for those who want to get into Android but feel uncertain in Java.

For demo resource, see https://github.com/RobGThai/JavaRefresher

1. Refreshing Java ☕
2. Object-Oriented Programming
3. Object-Oriented Programming Object-oriented programming (OOP) is a programming language model organised around objects rather than actions and data rather than logic. Historically, a program has been viewed as a logical procedure that takes input data, processes it, and produces output data. — Google
4. Class & Object • Class: A class can be defined as a template/blue print that describes the behaviors/states that object of its type support. • Object: Objects have states and behaviors. Example: A dog has states - color, name, breed as well as behaviors - wagging, barking, eating. An object is an instance of a class.
5. Example • Class: หมา มีชื่อ มีขา เห่าได้ หมุนตัวได้ ลองขอมือได้ • Object: อีแดง หมาพันธุ์ไทยหลังอาน ชอบเห่า จะหมุนตัวเวลาคลุกขี้ ขอมือจะกัด public class Dog{ private String name, bark, spin, giveHand; private int legs; } Dog อีแดง = new Dog();
6. Access Modifiers Modifiers limit ability to access each member (property/ method/class) from external class. • private: No entry. • protected: Accessible via Child class. • public: Accessible from everywhere. • default: Accessible via classes within the same package.
7. Demo 1 Object-Oriented Programming
8. Class Hierarchy
9. Class Hierarchy Class Hierarchy: In object-oriented programming, a class is a template that defines the state and behaviour common to objects of a certain kind. A class can be defined in terms of other classes. For example, a truck and a racing car are both examples of a car. Some famous example, car-truck, canine-dog-wolf. Still confused?
10. Class Hierarchy
11. Demo 2 Heirarchy
12. Inheritance
13. Inheritance Inheritance is when an object or class is based on another object or class, using the same implementation (inheriting from a class) or specifying implementation to maintain the same behaviour (realizing an interface; inheriting behavior). The relationships of objects or classes through inheritance give rise to a hierarchy.
14. Inheritance
15. Demo 3 Inheritance
16. Interface
17. Interface Interface enables 3rd-party to interact with an object without knowing its implementation.
18. Interface
19. Demo 4 Interface
20. Generics
21. Generics Generics allow you to abstract over types and add stability to your code by making more of your bugs detectable at compile time.
22. Generics
23. Demo 5 Generics
24. Collection
25. Collection A Collection is an object that can hold references to other objects. The collection interfaces declare the operations that can be performed on each type of collection. You can NOT create fully functional app without using some form of Collection.
26. Collection Well known Java Collections are as following: • Stack • LinkedList • ArrayList • Set • HashMap • TreeMap
27. Demo 6 Collection
28. Thread
29. Thread A Thread of execution is the smallest sequence of programmed instructions that can be managed independently by a scheduler. In mobile world, there's always one main thread (aka UI thread). Any long duration or intensive process should be ran on background thread only. This is to ensure UI thread get all the cycle it wants to draw the screen.
30. Thread Common thread implementation include using Thread, Runnable, or Executor. Thread-safe implementation is also available by the framework such as AtomicInteger, AtomicLong, and Atomic*.
31. Demo 7 Thread
32. Exception Handling
33. Exception Handling Exception handling is the process of responding to the occurrence, during computation, of exceptions – anomalous or exceptional conditions requiring special processing. There are three main components involved in Exception Handling in Java, Throwable, Exception, Error.
34. Demo 8 Exception Handling
35. SOLID
36. S
37. Single Responsibility principle A class should have only one single responsibility.
38. Single Responsibility principle: Don't ! public class PostingActivity { private void prepareLayout() { ... } private void bindData() { ... } private boolean validateForm() { ... } private View generateAttributes() { ... } }
39. Single Responsibility principle: Do ! public class ViewController { // My job is to control components for the view private ViewBinder binder; // Let me handle the binding then public void bindData(Data data) { binder.bind(data); } }
40. O
41. Open/Closed principle Should be open for extension, but closed for modification.
42. Open/Closed principle: Don't ! public class ViewBinder { public void binData(Data d) { ... if(isLandscapeMode && screenSize > 680) { useTabletView(); } if(isPrettify) { prettify(); } } private void prettify() { ... } private void useTabletView() { ... } }
43. Open/Closed principle: Do ! public class ViewBinder { public void binData(Data d) { ... } } public class PrettyViewBinder extends ViewBinder { @Override public void binData(Data d) { // By doing this we ensure ViewBinder still working properly ... prettify(); } }
44. L
45. Liskov Substitution principle Objects in a program should be replaceable with instances of their subtypes without altering the correctness of that program.
46. Liskov Substitution principle: Don't ! public class ViewBinder { public void binData(Data d) { ... } } public class PrettyViewBinder extends ViewBinder { @Override public void binData(Data d) { if(isLoading) { return ; } ... } }
47. Liskov Substitution principle: Do ! public class ViewBinder { public void binData(Data d) { ... } } public class PrettyViewBinder extends ViewBinder { @Override public void binData(Data d) { if(isLoading) { // Use placeholder instead of loading image } ... // These task will be execute regardless. // This ensure you get the view with data binded just like inside ViewBinder } }
48. I
49. Interface segregation principle Many client-specific interfaces are better than one general- purpose interface.
50. Interface segregation principle: Don't ! public interface IDisplayView { public Data loadData(String url); public View bindData(Data d); public void onViewClick(); public void onViewSwipe(); }
51. Interface segregation principle: Do ! public interface IDisplayView { public View bindData(Data d); } public interface IDataLoader { public Data loadData(String url); } public interface IViewInteract { public void onViewClick(); public void onViewSwipe(); }
52. D
53. Dependency Inversion principle One should “Depend upon Abstractions. Do not depend upon concretions.”
54. Dependency Inversion principle: Don't ! public class ViewController { private ViewBinder binder; public ViewController(ViewBinder binder) { this.binder = binder; } public void bindData(Data data) { binder.bind(data); } }
55. Dependency Inversion principle: Do ! public class ViewController { private IDisplayView binder; public ViewController(IDisplayView binder) { this.binder = binder; } public void bindData(Data data) { binder.bind(data); } } public class ViewBinder implements IDisplayView { @Override public void bind(Data d) { ... } }
56. Q & A ! " #
57. Thank you Poohdish Rattanavijai thisisrobg@gmail.com +RobGThai