Lecture 04 agenda• Go over QT exam.• Discuss OO• How to discover objects, properties, and methods• Tetris game• Other examples

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

Heap and StackThe 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

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.

git remote -v

git fetch origin lab04agit tech origin lab04c

git checkout -b lab04a origin/lab04agit checkout -b lab04c origin/lab04c

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.

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

Creating a class

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.

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.

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.

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.

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.

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

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

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.

Class Objects

See statics example

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

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

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.

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

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

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

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

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

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.

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

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

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

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

Command-line from IntelliJEver 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

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

InterfacesUnlike 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

Interfaces

override examples

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