Lecture 04 agenda

1. Lecture 04 agenda • Go over QT exam. • Discuss OO • How to discover objects, properties, and methods (describe the problem in English -nouns and verbs) • Tetris game • Other examples

2. Object-Oriented Programming • Important step forward in programming because it allows you to model real world systems which is what programming is all about. You can think about your system in a way that is logical to humans (not machines). Smalltalk was an early OO programming language. • OO is about modeling a real-world system that is familiar to our way of thinking, by thinking about Objects.

9. Static context

10. Created dynamically at run-time Static context (only one), -created on load. Class file methods http://stackoverflow.com/questions/8387989 /where-is-a-static-method-and-a-static-variable -stored-in-java-in-heap-or-in-sta Objects on the heap (zero to many)

11. Class Objects See statics example

12. Heap and Stack The Heap is an area of memory reserved for data that is created at runtime -- that is, when the program actually executes. A heap has a big-O of Log(n) insert and seek times. Objects live on the heap. In contrast, the stack is an area of memory used for data whose size can be determined when the program is compiled. Variables on the stack can be local and their life is extremely short and their memory can be reclaimed quickly. http://www.webopedia.com/TERM/H/heap.html

15. Write a very simple application for a fictitious real-estate company that displays the houses it currently offers. Some of the data they'd like to display include; address, market-value, an image of the house, and if the house has been foreclosed. 1/ display all the houses to the console. 2/ Apply a 25% subprime crash on all of our houses. Then display all of our houses to the console. 3/ Determine the most expensive house and display it to the console. Note: All houses are by default for sale, and once they're sold, they are removed from the display list. There is plenty of other data, like: weeks on market, the owners of the house, cube footage, etc. that we don't care about for our simple app. OOAD - Program the house example

16. Write a very simple Tracker application for a fictitious company. Employees may be promoted to Manager, and Executive. The company also employs Student interns but they are not paid. All employees get paid a salary, and managers and executives can get a bonus, and executives getstock options. The application should track the name of all emloyees and interns. Also Uchicago students get a tuition waiver for 10k. OOAD - Program the employee example (optional)

17. //generate some sample sample employees //generate some sample student interns //for each person //if employee //print out the name and annual income of employee //if person is Student and is UChicago //apply 10k voucher

18. Modeling Tool in IntelliJ Cltrl+Shift+Alt+U (same on Mac) • F4 jump to code • You can create any classes from the modelling tool used in combination of code. • Constructors and Getters/Setters are better done in the code Editor.

19. Tetris is a game where the player is confronted with falling shapes called tetriminos. A tetrimino has seven variations; S, L, O, Z, J, I, and T. See http://en.wikipedia.org/wiki/Tetris for exact configurations. Tetriminos float down from the top of the gaming-environment. The starting column is random, but the tetrimino always starts at top row and floats downward propelled by a gravitational-force that increases with time. Likewise, the pointsawarded increase as the speedincreases. The player can also see which tetrimino is on-deck, allowing him/her to place the current-tetrimino strategically. The player may rotate the tetrimino 90 degrees clock-wise while it is still floating, so long as the rotation does not cause the tetrimino to be out-of-bounds. The player may also laterally-move the tetrimino left or right. And finally, the player may force the tetrimino to free-fall. When the bottom of a tetrimino touches either the bottom of the gaming-environment or the top of the wall made of previously accumulated tetrimino blocks, then its blocks too become immediately integrated into the wall. This integration triggers a series of events which are described below: If the integration results in a wall with complete-rows, then those rows dissappear and the player is awarded points. A high-scoring "tetris" occurs when "I" is integrated vertically into a wall where 4 rows become complete --and then dissappear. Progressively smaller awards are provided for 3, 2, and 1 row completions. Once the integration occurs (and any row completions are finished) the on-deck tetrimino become the current tetrimino and a new tetrimino is randomly generated to be the on-deck one. The now current tetrimino begins its descent, and the cycle continues until the wall reaches 90% of the height of the gaming environment, at which point the game is over. Ctrl-Shift-Alt-U on package.

20. //generate a new on-deck-tetro //while wall is < 90% of game-environment height //on-deck becomes current and generate a new on-deck tetro //start current-tetro descent at random column //while current-tetro is floating //allow user to control floating tetro //if current-tetrimino touches wall (or bottom) //integrate //check for row completions and make rows dissappear //award any points //break //pull current down with gravity //game over

21. Creating a class

22. Members aka fields (instance variables) • Fields are the data defined in the class and belonging to each instantiation (object). Fields can change value i.e. they're variable. • If a field is not variable, then you should exclude it, or make it a constant (public final static). Any static member belongs to the CLASS -- only one. • A field is private. This is what is meant by encapsulation. You are hiding all but the 'public interface' (not to be confused with Interface). • There is NO limit as to how many instances (objects) of a class you can have; and often you will have more than one.

23. getters and setters • public type getField() • public void setField(Type typName) • They are public! They form the 'public interface' of the class. • Use IntelliJ to generate them for you.

24. Constructors • Constructors are optional. If your class is just a static driver; i.e. it just has a static main method, then no need to instantiate it; and no need for constructor. • If your class is a POJO (Plain Old Java Object) -- a class that models a real world object (noun) in your system, then it should have a constructor. House, Car, Person, etc. • If you don't provide a constructor, a no-args constructor is provided automatically – the Miranda constructor. • You can, and often want, more than one constructor with different signatures. • You call a constructor with the 'new' keyword. Use IntelliJ

25. Methods • public non-static methods may be called from the implicit parameter of an object (once instantiated in memory space). • public static methods may be called directly from the class -- WITHOUT the need to instantiate in memory. Example: public static void main(), or Math.pow(). • Java doesn't instantiate your methods over and over, just the fields.

26. style conventions • don't use variable/reference names like x,y, i, and j. That's very difficult to read. • The exception is a counter, and even then, it should look like this: nC. • cntrl-alt-L will format your code with indents. Use it. • Use m and s prefixes for members. For local variables, just let the IDE suggest the variable.

27. style conventions • Communicate meta-data! • Prefix 'm' or 's'. • postFix 's' conveys data-structure or array

28. Model a system • Object-oriented programming is about modeling a real-world system. • Write the problem out as requirements -- this will essentially be a math word problem (your favorite kind to solve!) • Your computer objects map directly to real-world objects (nouns). • Your methods map directly to real-world actions (verbs). • Write some pseudo-code

29. Deep Copy Clone • When you clone an object, you are copying the values stored in its fields • If those fields are primitives, no problem • If those fields are objects, you're simply copying the memory addresses of to those objects. See realestate example

30. Inheritance • Every object in Java inherits from Object • You can see this by keying: cntrl-H or cntrl-shift-alt-U in IntelliJ • Your job as a programmer is to organize your classes into a hierarchy so that code is not duplicated. • A superclass is LESS complex that a subclass • A subclass is MORE complex that a superlcass

31. Inheritance • When an object inherits, EVERYTHING from it's ancestry is inherited as well (only these members and methods are implicit – and therefore not visible in the subclass' code) • Often, you will want to increase the complexity of the subclass, and create more members and more methods • Sometimes, you will want to force a genetic modification by overriding methods • Will always call the deepest overridden instance method.

32. Abstract • If I have one or more abstract methods (signature only, no implementation) in my class, I must declare the class as abstract (you can also have zero abstract methods) • Extending abstract classes forces the programmer to override abstract methods. • Overriding is a genetic modification of the subclass' behavior. • You can only instantiate concrete classes, you can never instantiate abstract classes (or interfaces).

33. Abstract • If you can't instantiate abstract classes, then what are they good for? • The answer is: polymorphism • Store your subclass objects in a collection of superclass references (abstract or concrete) See employee example

34. Autoboxing • Since Java5, Wrapper classes and primitives are interchangeable! • Legal statements: • Integer intMe = 67; //auto-box • double dMe = new Double(6.214); //auto-un-box See autboxing example

35. Overlaoding methods • Overlaoded methods are those in the same class that share the same name, BUT have a different signature. • Very useful for constructors, but also certain methods • Return type is not sufficient to differentiate a signature. • > public Employee(){ } • > public Employee(String strName){ } • > public Employee(String strName, double dSalary) { } See employee.Student.java example

36. Overlaoding methods • public void display(int nParam){} public void display(String strParam){} //ok public void display(String strOther){} //not public String display(int nParam){} //not public double display(String str, Date dat){} //ok

37. Overriding methods • Overriden methods are those with the same signature of a method in the class' hierarchy • The @Override is optional. It tells the compiler to check the signature and verify the overloading • Very useful for polymorphism! • If you extend an abstract class, you MUST override its abstract methods. Same with Interfaces if you implement them.

38. Overriding methods • When called from a superclass reference, how does the VM determine which overloaded method to envoke. • 1/ start at the object-level, if it's implemented, there, then call it. • 2/ If not, crawl up the hierarchy until its implemented See employee example

39. The this keyword • The this keyword refers to the implicit parameter. • You may refer to the instantiated object from within your class this way, and it'll resolve to the memory address of the object during runtime. See employee.Executive.java example from lec04

40. The super keyword • The super keyword refers to the implict parameter, but it calls superclass constructors and instance methods only. • You will most often see this in constructors where you will want to call the superclass constructor. If you don't call super() explicitly, the no-arg constructor is called anyway. • You may also see super in overriden methods when you want to evoke the superclass version of that method before or after yours. See employee.Manager.java example

41. VarArgs • VarArgs, or Variable Arguments is a feature since Java5. • It allows you to specify a variable number of arguments as the last parameter of a method • VarArgs are treated as Arrays inside the method • >public void display(int nParam, String... strParams){}//ok >public void display(int nParam, String str, double... dParams){} //ok >public void display(int... nParams, String str){} //NOT See varargs example

42. Command-line from IntelliJ Ever wonder what public static void main(String[] args) means? The args argument is an array of String that are passed into main if you call this method from the command-line. You may pass args into main, by going to Run || Edit configurations || Program arguments See commandline example

43. Interfaces Not to be confused with “public interface” which are all the public methods of your class. An interface is like an abstract class, but it has NO members. The best way to think about an interface is that it's a CONTRACT. You extend a superclass, and you implement an interface. You can NEVER instantiate an interface, but you can instantiate concrete classes and store those objects in interface references.

44. Interfaces Unlike C++, Java does not allow multiple inheritance, however, it does allow a class to implement multiple interfaces. When a class implements an interface, it MUST, by contract, override all the methods in the interface. What good are interfaces? The answer: polymorphism. Store a heterogeneous collection of objects in interface references, so long as all the objects implement the interface. You are guarantee that all the objects in that collection will be able to call the methods of the interface. See fight and race examples

45. Interfaces Build override using IntelliJ UML

46. JavaDocs http://www.oracle.com/technetwork/java/javase/documentation/index-137868.html#examples http://www.oracle.com/technetwork/articles/java/index-137868.html https://www.jetbrains.com/idea/help/edit-template-variables-dialog.html Tools > Generate javaDocs

47. UML Ctrl-shift-Alt-U on a package such as override https://youtu.be/Z1EZVb44j_k override examples

48. Break Andrew McAfee on technology and economics https://www.ted.com/talks/andrew_mcafee_are_droids_taking_our_jobs?language=en One take from Gravity https://www.youtube.com/watch?v=vKW-Gd_S_xc