1. Lecture 04 agenda Go over QT exam. Discuss OO How to discover objects, properties, and methods 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).

4. 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

5. 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.

6. git remote -v git fetch origin lab04a git tech origin lab04c git checkout -b lab04a origin/lab04a git checkout -b lab04c origin/lab04c

7. 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 points awarded increase as the speed increases. 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.

8. //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

9. Creating a class

10. 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.

11. 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.

12. 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. You can, and often want, more than one constructor with different signatures. You call a constrcutor with the 'new' keyword.

13. 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(). Java doesn't instantiate your methods over and over, just the fields. The methods are compiled in the.class file, and only once.

14. 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.

15. style conventions Example: x verus dPrice? Example: name or strFirstName Example: today or greToday Example countries or strCountries (append an s for collections, the type it contains should be first) Communicate meta-data! – prefix conveys type – prefix conveys variable or object reference (one and three letters in prefix respectively) – postFix 's' conveys data-structure or array

16. Model a system Object-oriented programming is about modeling a 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).

17. 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 one 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.

18. Class Objects See statics example

19. 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

20. 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

21. 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.

22. 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).

23. 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

24. 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

25. 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

26. 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

27. 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.

28. 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

29. 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

30. 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

31. 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

32. 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

33. 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.

34. 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

35. Interfaces override examples

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