Creating a class

1. Creating a class

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

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

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

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

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

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

8. Model a system • Object-oriented programming is about modeling a system. • Write the problem out as requirements -- this will essentially be a math world 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).

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

10. Class Objects See statics example

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

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

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

14. Abstract • If I have one or more abstract methods (signature only, no implementation) in my class, I must declare the class as abstract • 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.

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

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

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

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

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

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

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

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

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

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

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

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