CLASSES AND OBJECTS Object-Oriented Basics

Vocabulary Review – C++ Class Object Instance this new Constructor Default constructor Access (private/public/protected) static parent/child; superclass/subclass abstract class/pure virtual function

Object-Oriented ConceptReview Encapsulation – hiding unimportant details Black box – something that magically “does its thing” Abstraction – taking away inessential features Example: car –if engine control module fails, replace it –mechanic can provide inputs, test outputs –doesn’t need to know how it works OO challenge: finding the right abstractions (what “black boxes” do we need to solve the problem at hand?)

Simple Class public class Book { // static = one copy per class // final = constant, can't change public static final int MAX_HIGHLIGHTS = 100; // these are INSTANCE variables // may also be called ATTRIBUTES or MEMBER variables // In CSCI306, MUST be private unless you have a compelling argument otherwise private int numPages; private int[] highlights; private int numHighlights; private int currentPage; public Book(int numPages) { super(); // covered in more detail under Inheritance this.numPages = numPages; currentPage = 1; // Notice use of constant, avoid 'Magic constants' // highlights = new int[100]; - NOT GOOD!!!!! highlights = new int[MAX_HIGHLIGHTS]; }

Continued public void addHighlight() { highlights[numHighlights] = currentPage; numHighlights++; } public void addHighlight(int whichPage) { highlights[numHighlights] = whichPage; numHighlights++; } public void printHighlights() { System.out.println("Highlighted pages\n"); for (int page=0; page<numHighlights; page++) System.out.println(highlights[page]); }

Continued //Setters and getters by Eclipse public static void main(String[] args) { Book aBook = new Book(300); aBook.setCurrentPage(15); aBook.addHighlight(); aBook.addHighlight(32); aBook.printHighlights(); }

Methods in Java Instance –called with an object –most methods are of this type –able to access/update object (instance) data Class/static – called with the class name –also known as static –no object, so no object data… must pass needed data in as parameters –don’t make a static method unless you have a reason –main is static – why?

More Instance Method Examples public class MyPoint { private int x, y; public MyPoint(int x, int y){ this.x = x; this.y = y; } public int getX() { return x; } } // in main MyPoint p1 = new MyPoint(3, 4); MyPoint p2 = new MyPoint(5, 6); System.out.println(p1.getX()); System.out.println(p2.getX()); notice that you call an instance method using an object constructor – just like C++

Static Method Examples Existing class: System.out.println(Math.round(x + y)); Example of creating your own: public class Financial { public static double percentOf(double p, double a) { return (p/100) * a; } double tax = Financial.percentOf(taxRate, total); Call with class name, not instance. NOTE: inside class, don’t need class name All data is passed in, no “owned” variables numerous Math functions static keyword

Variables Instance – each object has its own copy Class/static – one copy per class. Often used with final. Local – only exists inside the function

BankAccount Example lastAccountNum public class BankAccount { private static int lastAccountNum = 0; private String name; private double balance; private int accountNum; // methods here } BankAccount mine = new BankAccount(“Jim”, 5000); BankAccount yours = new BankAccount(“Sally”, 10000); just one copy of lastAccountNum Jim Sally mineyours

Variables Instance variables –each object has its own copy (as in C++) –objects are automatically garbage collected (unlike C++!) –fields are initialized with a default value (e.g., 0, null) if not explicitly set in constructor. Still good to do your own initialization. –NullPointerException if you forget to call new Local variables –must be explicitly initialized –error if you use before initializing (unlike C++) –only exist inside method (as in C++)

Instance vs Static vs Local – Which to Use? Use instance variables for data that “belong” to one instance of the class and will be operated on by multiple methods Use local variables for temporary calculations within a method Use static variables ONLY for constants and values that are clearly shared between objects. If you don’t have a reason for static, don’t use it! Use static methods for utility methods Common mistake – use static just to get rid of compiler errors

Intance vs Local vs Static Example public class Financial{ public static double percentOf(double p, double a) { return (p/100) * a; } public class BankAccount { private double balance; private double intRate; // addInterest updates balance & returns amt of interest public double addInterest() { double interest = balance * intRate; balance += interest; return interest; } Common errors: Making all variables instance, even if only used in one function. Making all variables static – like using globals! instance variables, can access inside all instance methods local variable: interest

DON’T DO THIS!! public class SomeClass { public static int count; public static void update() { count++; } public static void main(String[] args) { count = 0; //.. Some stuff update(); //.. Some stuff update(); System.out.println(count); }

DO SOMETHING LIKE THIS! public class SomeClass { private int count; // let Eclipse do getter/setter public void update() { count++; } public static void main(String[] args) { SomeClass sc = new SomeClass(); // not needed, done in constructor: count = 0; //.. Some stuff sc.update(); //.. Some stuff sc.update(); //System.out.println(count); System.out.println(sc.getCount();); }