Quick Look at Design Patterns - GDG Dnipro-Art

Brief presentation about GOF Design Patterns, with short overview of Android applications of the patterns and other types of patters in software development (non-GOF). Made for the First Meetup of GDG Dnipro-Art in April 2017

Transcript

1. Quick Look at Design Patterns in Android Development Constantine Mars Team Lead, Senior Developer @ DataArt
2. #gdg_dnipro_art Patterns everywhere
3. #gdg_dnipro_art What do “GOF Patterns” mean? "Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice" - Christopher Alexander
4. #gdg_dnipro_art Pattern structure 1. Pattern name 2. Problem 3. Solution 4. Consequences
5. #gdg_dnipro_art Bricks and clay 1. Interface 2. Instantiation 3. Subtype - Type - Supertype 4. Dynamic binding 5. Polymorphism 6. Encapsulation
6. #gdg_dnipro_art Principles 1. Class versus Interface Inheritance 2. Program to an interface, not an implementation 3. Favor object composition over class inheritance 4. Aggregation -> having or being part of 5. Acquaintance -> knows of (association, using) 6. Delegation 7. Inheritance versus Parameterized Types (generics, templates)
7. #gdg_dnipro_art Applications of reuse 1. Toolkits - code reuse -> you write the main body of the application and call the code you want to reuse 2. Frameworks - design reuse -> you reuse the main body and write the code it calls
8. Pattern categorieS8 - GOF Be together, not the same!
9. #gdg_dnipro_art Creational Patterns - Create objects - Hide creation logic - Do not use operator “new” Give program more flexibility to decide which objects to create
10. #gdg_dnipro_art Structural Patterns Class and object composition Inheritance, interfaces and ways to compose objects = obtain new functionalities
11. #gdg_dnipro_art Behavioral Patterns It’s all about communication
12. #gdg_dnipro_art A Mesh of XXIII
13. #gdg_dnipro_art Table of Design Patterns by Vince Huston :) Illustration from http://www.vincehuston.org/dp/
14. #gdg_dnipro_art Organizing patterns space by GOF
15. Free your creativity while patterns work for you :) Creational Patterns
16. #gdg_dnipro_art Factory method Define an interface for creating an object, but let subclasses decide which class to instantiate
17. #gdg_dnipro_art Abstract Factory Captures how to create families of related product objects without instantiating classes directly Image from https://sourcemaking.com
18. #gdg_dnipro_art Builder Separate the construction of a complex object from its representation so that the same construction process can create different representations
19. #gdg_dnipro_art In Android new AlertDialog.Builder(this) .setTitle("Metaphorical Sandwich Dialog") .setMessage("Metaphorical message to please use the spicy mustard.") .setNegativeButton("No thanks", new DialogInterface.OnClickListener() { … }}) .setPositiveButton("OK", new DialogInterface.OnClickListener() {...}}) .show(); Builder
20. #gdg_dnipro_art Prototype Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype
21. #gdg_dnipro_art Singleton Ensure a class only has one instance, and provide a global point of access it
22. #gdg_dnipro_art In Android public class ExampleSingleton { private static ExampleSingleton instance = null; private ExampleSingleton() { // customize if needed } public static ExampleSingleton getInstance() { if (instance == null) { instance = new ExampleSingleton(); } return instance; } } ExampleSingleton.getInstance(); Singleton
23. Building is under construction :) Structural Patterns
24. #gdg_dnipro_art Adapter Convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.
25. #gdg_dnipro_art public class TribbleAdapter extends RecyclerView.Adapter { private List mTribbles; public TribbleAdapter(List tribbles) { this.mTribbles = tribbles; } @Override public TribbleViewHolder onCreateViewHolder(ViewGroup viewGroup, int i) { LayoutInflater inflater = LayoutInflater.from(viewGroup.getContext()); View view = inflater.inflate(R.layout.row_tribble, viewGroup, false); return new TribbleViewHolder(view); } @Override public void onBindViewHolder(TribbleViewHolder viewHolder, int i) { viewHolder.configure(mTribbles.get(i));} @Override public int getItemCount() { return mTribbles.size(); } } Adapter
26. #gdg_dnipro_art Bridge Allows separate class hierarchies to work together even as they evolve independently Image from https://sourcemaking.com
27. #gdg_dnipro_art Composite Captures the essence of recursive composition in object-oriented terms.
28. #gdg_dnipro_art Decorator Captures class and object relationships that support embellishment by transparent enclosure
29. #gdg_dnipro_art Facade Provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher- level interface that makes the subsystem easier to use
30. #gdg_dnipro_art public interface BooksApi { @GET("/books") void listBooks(Callback<List> callback); } RestAdapter restAdapter = new RestAdapter.Builder() .setConverter(new CustomGsonConverter(new Gson())) .setEndpoint("http://www.someurl.com") .build(); return restAdapter.create(BooksApi.class); Facade
31. #gdg_dnipro_art Proxy Provide a surrogate or placeholder for another object to control access to it.
32. All about communication, change and interchange :) Behavioral Patterns
33. #gdg_dnipro_art Command Abstract class to provide an interface for issuing a request. The basic interface consists of a single abstract operation called "Execute."
34. #gdg_dnipro_art public class MySpecificEvent { /* Additional fields if needed */ } eventBus.register(this); public void onEvent(MySpecificEvent event) {/* Do something */}; eventBus.post(event); Command
35. #gdg_dnipro_art Chain of Responsibility Chain the receiving objects and pass the request along the chain until an object handles italgorithm in an object
36. #gdg_dnipro_art Iterator General interface for access and traversal
37. #gdg_dnipro_art Mediator Define an object that encapsulates how a set of objects interact
38. #gdg_dnipro_art Memento (Token) Without violating encapsulation, capture and externalize an object's internal state so that the object can be restored to this state later
39. #gdg_dnipro_art Flyweight Use sharing to support large numbers of fine-grained objects efficiently.
40. #gdg_dnipro_art Observer Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically
41. #gdg_dnipro_art apiService.getData(someData) .observeOn(AndroidSchedulers.mainThread()) .subscribe (/* an Observer */); Observer
42. #gdg_dnipro_art State Allow an object to alter its behavior when its internal state changes. The object will appear to change its class
43. #gdg_dnipro_art Strategy Encapsulating an algorithm in an object
44. #gdg_dnipro_art Interpreter Define a represention for language grammar along with an interpreter that uses the representation to interpret sentences in the language
45. #gdg_dnipro_art Visitor Refer generally to classes of objects that "visit" other objects during a traversal and do something appropriate
46. Android Patterns Bald, mad and superperformant! =)
47. #gdg_dnipro_art Dependency Injection
48. #gdg_dnipro_art @Module public class AppModule { @Provides SharedPreferences provideSharedPreferences(Application app) { return app.getSharedPreferences("prefs", Context.MODE_PRIVATE); } } @Component(modules = AppModule.class) interface AppComponent { … } @Inject SharedPreferences sharedPreferences; Dependency Injection
49. #gdg_dnipro_art Model-View-Controller (MVC) • Model: your data classes. • View: your visual classes • Controller: the glue between the two
50. #gdg_dnipro_art Model-View-ViewModel (MVVM) • Model: your data classes. • View: your visual classes • ViewModel: exposes properties • Binder: generates ViewModel properties
51. #gdg_dnipro_art Model-View-Presenter (MVP) • Model - interface defining the data • Presenter - retrieves data from repositories (model), and formats it for display in the view • View - passive interface that displays data (the model) and routes user commands (events) to the presenter
52. #gdg_dnipro_art Other Patterns... Loaders, AsyncTasks, Broadcast Receivers, Intents, Media Framework = Facade, Object Pools, Batching and caching And many other...
53. UI Design Patterns Have very similar rules, but are yet different
54. #gdg_dnipro_art Links and books on GOF - Joshua Kerievsky - Refactoring To Patterns - Bruce Eckel - Thinking in Patterns with Java - Eric Freeman - Head First Design Patterns - Erich Gamma - Design Patterns: Elements of Reusable Object-Oriented Software - https://sourcemaking.com/design_patterns - https://dzone.com/refcardz/design-patterns - https://github.com/iluwatar/java-design-patterns
55. #gdg_dnipro_art Links and books on Android Patterns - Android Design Patterns https://unitid.nl/androidpatterns/ - Alex Lockwood http://www.androiddesignpatterns.com/ - Android Performance Patterns https://www.youtube.com/playlist?list=PLWz5rJ2EKKc9CBxr3BVjPTPoDPLdPIFCE - TutsPlus https://code.tutsplus.com/articles/introduction-to-android-design-patterns--cms-20808 - Ray Wenderlich https://www.raywenderlich.com/109843/common-design-patterns-for-android
56. #gdg_dnipro_art Links and books on UI Patterns - Material Design Guidelines https://material.io/guidelines/material-design/introduction.html# - UI Patterns http://ui-patterns.com/patterns - UI Pttrns https://pttrns.com/android-patterns
57. “ Patterns are everywhere - from enterprise applications to games and even devices, the most important is to see them Alexey Rybakov, DataArt Technical Evangelist
58. Constantine Mars @ConstantineMars +ConstantineMars Q&A Thank you!