Lesson 4 Classes Objects Unit D

Lesson 4 – Classes & Objects Unit D 1 – Introduction Lecture D – Classes & Objects Slide 1 of 87.

Container vs. Definition classes • Generally, classes can be used for two purposes: § Container classes: • a collection of static methods that are not bound to any particular object (e. g. , the main() method). • These static methods usually have something in common § Definition classes: • These classes define new objects, in a way that we will soon see. Lecture D – Classes & Objects Slide 2 of 87.

Container vs. Definition Classes - Example • The Math class is an example of the first kind. It is a container for math utility methods: Math. sqrt(), Math. abs(), Math. max(), . . . • The class Turtle is an example of the second kind. It defines a new type of objects, Turtle objects. • We will now focus on the second kind. Lecture D – Classes & Objects Slide 3 of 87.

Class Abstraction • The most important stage in writing a class is to get an abstraction of the class done first. What does an object of this type represent? § What is its interface? § What is its internal state? § • This means you have to know what should be the internal state (variables) and also the behavior/interface (methods) of the class before you start to write you class code. Lecture D – Classes & Objects Slide 4 of 87.

Objects and Classes • The relationship between Classes and Objects can be seen as the relationship between a blueprint/model and the actual object built from it. § Example: Blueprint of a house (class) and the house (object) • The class defines: The type of data that will be held in an object § The code for the methods of the object § • In order to use a class you must instantiate an object from it. This corresponds to building the house from the blueprint. § There may be many objects from a single class § Lecture D – Classes & Objects Slide 5 of 87.

Turtle Class Abstraction A Turtle represents a creature moving on the screen with a pen attached to its tail • The internal state of a Turtle includes: • § Location on screen; direction of movement; tail up/down • The interface of a Turtle is: Turtle(); void move. Forward(double units); void move. Backward(double units); void turn. Left(double degrees); // … Lecture D – Classes & Objects Slide 6 of 87.

Encapsulation • The internal state of an object is not directly accessible to other parts of the program • Other parts of the program can only access the object using its interface move. Forward() • We say that the state is encapsulated or hidden. . • This gives modularity • tail. Down. . • x, y to the program. • direction . turn. Right() Lecture D – Classes & Objects Slide 7 of 87.

Clock Class Abstraction • A Clock represents a 12 -hour clock • Its internal state includes: hour, minute, second • Its interface allows telling the clock that a second has elapsed, and querying the clock for the time: Clock(int hours, int minutes, int seconds) void second. Elapsed() int get. Seconds() int get. Minutes() int get. Hours(). . . Lecture D – Classes & Objects Slide 8 of 87.

Using a Clock class Clock new. York. Time = new Clock(12, 59); for (int j = 0; j < 3; j++) new. York. Time. second. Elapsed(); System. out. println(new. York. Time. get. Hours() + “: ” + new. York. Time. get. Minutes() + “: ” + new. York. Time. get. Seconds()); Lecture D – Classes & Objects Slide 9 of 87.

Structure of the Clock class public class Clock { private int hours, minutes, seconds; public Clock(int h, int m, int s){ … } public void second. Elapsed() { … } public int get. Hours() { … } public int get. Minutes() { … } public int get. Seconds() { … } } • The private modifier specifies an identifier that is only visible within the class. Usually used for fields. • The public modifier specifies an identifier that is accessible to all other classes. Usually used for methods. Lecture D – Classes & Objects Slide 10 of 87.

Lesson 4 – Classes & Objects Unit D 2 - Class Elements Lecture D – Classes & Objects Slide 11 of 87.

Instance Variables • • Recall that a class must define the state of an object and its behavior. We declare state variables (variables that hold the state of the object) in a similar way to that of regular variables, only they appear outside methods, inside the class. State variables are also called instance variables or fields. Roughly speaking, the private modifier means that the variables are not part of the object’s interface. public class Clock { private int hours, minutes, seconds; // … } Lecture D – Classes & Objects Slide 12 of 87.

Constructors • Objects must be initialized before they can be used. • We must specify what is the initial state of the object before we can use it. • Space for holding the object state data is only allocated when the object is constructed. • We specify the way an object is initialized using a constructor, which is a special method which is invoked every time we create a new object • The name of the constructor is always identical to the class name Lecture D – Classes & Objects Slide 13 of 87.

Clock Constructor public Clock(int h, int m, int s){ hours = h; minutes = m; seconds = s; } Lecture D – Classes & Objects Slide 14 of 87.

Clock constructor invoked Clock c; c = new Clock(10, 45, 0); public class Clock { private int hours, minutes, seconds; public Clock(int h, int m, int s){ hours = h; minutes = m; seconds = s; } // … Lecture D – Classes & Objects C: hours: 10 Minutes: 45 Seconds: 0 Slide 15 of 87.

Methods • To make the date object useful, we must provide methods that define its behavior. • We declare methods in a similar way to the way the method main was declared. • Only there’s a big difference: § the main method was static, which means it wasn’t bound to a specific object § we want to declare instance methods, which operate on a specific instance of an object Lecture D – Classes & Objects Slide 16 of 87.

second. Elapsed() method public void second. Elapsed() { if (seconds < 59) seconds++; else { seconds=0; if (minutes < 59) minutes++ ; else { minutes = 0; hours = hours < 12 ? hours+1 : 1; } } } Lecture D – Classes & Objects Slide 17 of 87.

Return Types • • • Methods may return values The return type of a method indicates the type of value that the method sends back to the calling client The return-type of get. Hours() is int. When a client ask for the hours read of a clock it gets the answer as an int value. A method that does not return a value (such as second. Elapsed()) has a void return type The return statement specifies the value that should be returned, which must conform with the return type of the method. Lecture D – Classes & Objects Slide 18 of 87.

Clock accessor methods public int get. Hours() { return hours; } public int get. Minutes() { return minutes; } public int get. Seconds() { return seconds; } Lecture D – Classes & Objects Slide 19 of 87.

Method Context • The get. Hours() and second. Elapsed() methods are instance methods, which means they act on a particular instance of the class • They cannot be invoked “out of the blue”. They must act on a particular object: Clock c = new Clock(1, 2, 3); get. Hours(); // Error!! of which clock? c. get. Hours(); // will return 1 • An instance method is executed in the context of the object it acts upon. Lecture D – Classes & Objects Slide 20 of 87.

Clock. Test example public class Clock. Test { public static void main(String[] args) { Clock swatch = new Clock(12, 59); Clock seiko = new Clock(12, 59); System. out. println(swatch. get. Hours()); // 12 System. out. println(seiko. get. Hours()); // 12 swatch. second. Elapsed(); System. out. println(swatch. get. Hours()); // 1 System. out. println(seiko. get. Hours()); // 12 } } Lecture D – Classes & Objects Slide 21 of 87.

Method Parameters • A method can be defined to accept zero or more • • parameters Each parameter in the parameter list is defined by its type and name The parameters in the method definition are called formal parameters The values passed to a method when it is invoked are called actual parameters The name of the method together with the list of its formal parameters is called the signature of the method public void set. Time(int h, int m, int s) Lecture D – Classes & Objects Slide 22 of 87.

Method set. Time() public void set. Time(int h, int m, int s){ if ((s >= 0) && (s < (m >= 0) && (m < (h > 0) && (h <= hours = h; minutes = m; seconds = s; } // no effect if input 60) && 12)) { is illegal } Lecture D – Classes & Objects Slide 23 of 87.

Lesson 4 – Classes & Objects Unit D 3 - Method writing details Lecture D – Classes & Objects Slide 24 of 87.

Variable Scope • Variables may be declared in: Class – state variables § Method/constructor – local variables (and parameters) § Inner block of a method – also local variables § • A variable is recognized throughout the block in which it was defined. This is called the scope of the variable. • Local variables are allocated when the method is entered and freed when the method exits. • The same name may be used in different scopes, and refer to totally different things • If the same name is used in an outer and inner scope, then the inner scope definition “hides” the outer one. Lecture D – Classes & Objects Slide 25 of 87.

The this reference • When appearing inside an instance method, the this keyword denotes a reference to the object that the method is acting upon. • The following are equivalent: public int get. Hours() { return hours; } public int get. Hours() { return this. hours; } Lecture D – Classes & Objects Slide 26 of 87.

Using same names for parameters and fields • It is usually bad practice to use the same name for a state variable and a local variable or parameter. • Exception: parameters that correspond exactly to fields public void set. Time(int hours, int minutes, int seconds) { if ((seconds >= 0) && (seconds < 60) && (minutes >= 0) && (minutes < 60) && (hours > 0) && (hours <= 12)) { this. hours = hours; this. minutes = minutes; this. seconds = seconds; } // no effect if input is illegal } Lecture D – Classes & Objects Slide 27 of 87.

Passing Parameters • When a parameter is passed, a copy of the value is made and assigned to the formal parameter: Clock beritling = new Clock(1, 2, 3); int lunch. Hour = 12; breitling. set. Time(lunch. Hour, 32, 14); hours = lunch. Hour minutes = 32 seconds = 14 Lecture D – Classes & Objects Slide 28 of 87.

Parameters are passed by value Clock c = new Clock(1, 2, 3); int a= 7; c. funny. Get. Hour(a); // still 7!! class Clock { // … public void funny. Get. Hour(int h){ h = hours; } } Lecture D – Classes & Objects Slide 29 of 87.

Passing Object parameters • When an Object is a parameter, only the reference is passed by value. The parameter now is an alias of the object. class XX { // … public void set. Midnight(Clock c) { c. set. Time(12, 0, 0); } class YY { // … XX x = new XX(); Clock my. Clock = new Clock(1, 2, 3); x. set. Midnight(my. Clock); // 12: 0: 0 Lecture D – Classes & Objects Slide 30 of 87.

Example: A Bank Account Object Bank. Account public Bank. Account(long account. Number) public void deposit(double amount) public void withdraw(double amount) public double get. Balance() public void transfer(double amount, Bank. Account target. Account) Lecture D – Classes & Objects Slide 31 of 87.

Bank Account - example public class Bank. Account { private long account. Number; private double balance; public Bank. Account(long account. Number){ this. account. Number = account. Number; balance = 0; } public double get. Balance() { return balance; } // continued in the next slide. . . } Lecture D – Classes & Objects Slide 32 of 87.

Bank Account - example public void deposit(double amount) { balance += amount; } public void withdraw(double amount) { balance -= amount; } public void transfer(double amount, Bank. Account target. Account){ withdraw(amount); target. Account. deposit(amount); } Lecture D – Classes & Objects Slide 33 of 87.

Bank Account – usage example Bank. Account alice. Acc = new Bank. Account(1398723); Bank. Account bob. Acc = new Bank. Account(1978394); alice. Acc. deposit(900); alice. Acc. transfer(700, bob. Acc); // Alice’s balance = 200 ; Bob’s balance = 700 Lecture D – Classes & Objects Slide 34 of 87.

Constructor and Method Overloading • • • A class can define several constructors -- several ways to initialize an instance of this class These constructors differ by the number and/or type of parameters they get. When we construct an object, the compiler decides which constructor to invoke according to the number and types of the actual arguments A constructor with no parameters is called the default constructor Different methods can also use the same name as long as they differ in the number or type of parameters. When we invoke a method, the compiler decides which method to invoke according to the number and types of the actual arguments Lecture D – Classes & Objects Slide 35 of 87.

Constructor Overloading example public Clock(int h, int m, int s){ hours = h; minutes = m; seconds = s; } public Clock(int h) { this(h, 0 , 0); } public Clock() { this(12); } Lecture D – Classes & Objects Slide 36 of 87.

Lesson 4 – Classes & Objects Unit D 4 - Visibility Modifiers Lecture D – Classes & Objects Slide 37 of 87.

Visibility Modifiers • • We accomplish encapsulation through the appropriate use of visibility modifiers Visibility modifiers specify which parts of the program may see and use any particular class/method/field Information hiding is good! A modifier is a Java reserved word that specifies particular characteristics of a programming construct We've used the modifier final to define a constant Java has three visibility modifiers: public, private, and protected We will discuss the protected modifier later in the course Lecture D – Classes & Objects Slide 38 of 87.

Visibility Modifiers - Classes • • A class can be defined either with the public modifier or without a visibility modifier. If a class is declared as public it can be used by any other class If a class is declared without a visibility modifier it has a default visibility. This draws a limit to which other classes can use this class (classes in the same package). We will discuss default visibility later in the course. Classes that define a new type of objects, that are supposed to be used anywhere, should be declared public. Lecture D – Classes & Objects Slide 39 of 87.

Visibility Modifiers - Members • • A member is a field, a method or a constructor of the class. Members of a class can be declared as private, protected, public or without a visibility modifier: private int hours; public int hours; • Members that are declared without a visibility modifier are said to have default visibility. We will discuss default and protected visibility later in the course. Lecture D – Classes & Objects Slide 40 of 87.

Public Visibility • Members that are declared as public can be accessed from any class that can access the class of the member • We expose methods that are part of the interface of the class by declaring them as public • Example: the methods get. Hours(), second. Elapsed() and set. Time() are part of the interface of class Clock so we define them as public. • We do not want to reveal the internal representation of the object’s data. So we usually do not declare its state variables as public (encapsulation) Lecture D – Classes & Objects Slide 41 of 87.

Private Visibility • A class member that is declared as private, can be accessed only by code that is within the class of this member. • We hide the internal implementation of the class by declaring its state variables and auxiliary methods as private. • Data hiding is essential for encapsulation. Lecture D – Classes & Objects Slide 42 of 87.

Illegal Access - example // Example of illegal access class Bank. Account. Test { public static void main(String[] args) { Bank. Account victim = new Bank. Account(2398742); victim. balance = victim. balance - 500; // this will not compile! } } public class Bank. Account { private long account. Number; private double balance; // … Lecture D – Classes & Objects Slide 43 of 87.

Encapsulation not Among Instances of Same Class • Encapsulation is to protect the programmers and is thus between the code of different classes • Sometimes object instances of the same class need to access each other’s “guts” (e. g. , for state copying - if we want to create an identical instance of an object we have) • Example: § from within a Bank. Account object, any private member of a different Bank. Account object can be accessed. Lecture D – Classes & Objects Slide 44 of 87.

Encapsulation - example public void transfer(double amount, Bank. Account target. Account) { withdraw(amount); target. Account. deposit(amount); } // alternative version (valid, but not so nice) public void transfer(double amount, Bank. Account target. Account) { balance -= amount; target. Account. balance += amount; } Lecture D – Classes & Objects Slide 45 of 87.

Lesson 4 – Classes & Objects Unit D 5 - API documentation Lecture D – Classes & Objects Slide 46 of 87.

API Documentation • Your classes are often intended to be used by other programmers • Programmers that use your class are not interested in the way it is implemented. They want to use it as a whole and are only interested in what it does and how to use it. • API (Application Programmer Interface) documentation is a description of the interface of the class intended for the application programmer who wants to use it. • To use the class, we need not (and should not) look at the code. All that is needed is the class API. Lecture D – Classes & Objects Slide 47 of 87.

API Documentation • The JDK contains a special tool for the generation of API documentation for your classes, called javadoc. • Any documentation which is part of the interface begins with /** (double asterick) and ends with */ • javadoc takes as input Java programs and automatically generates documentation using: the public/protected method signatures § the documentation comments (enclosed by /** … */). § • The output is an HTML file which can be viewed by an internet browser. Lecture D – Classes & Objects Slide 48 of 87.

Clock API Documentation /** * A clock represents a point of time in a 12 * hour period within a precision of seconds. * Its range: 1: 00 -- 12: 59. */ public class Clock { private int hours; private int minutes; private int seconds; /** * Constructs a Clock: Sets the clock to the * specified time. */ public Clock(int hours, int minutes, int seconds){ //… } Lecture D – Classes & Objects Slide 49 of 87.

Clock API Documentation – cont. /** * Constructs a Clock: */ public Clock(){ this(12, 0, 0); } Sets the clock to 12: 00 /** * Advances this clock by 1 second. */ public void second. Elapsed() { //… } //… Lecture D – Classes & Objects Slide 50 of 87.

Javadoc Process . java file javadoc . html file View using a browser Lecture D – Classes & Objects Slide 51 of 87.

Clock javadoc - page 1 Lecture D – Classes & Objects Slide 52 of 87.

Clock javadoc - page 2 Lecture D – Classes & Objects Slide 53 of 87.

What should you comment? • You should put a documentation comment for the class itself and for any member of the class which is part of its interface. • All public constructors and methods should have documentation comments. • Private methods are not part of the interface of the class, thus javadoc skips them. (But you should still comment them for internal purposes. ) • In the rare cases that there are public fields, they should have documentation comments. Lecture D – Classes & Objects Slide 54 of 87.

API Documentation • Remember that documentation comments are written for programmers who use your class as a whole. They should describe only What the class does, § How to use it. § • Documentation comments should not describe how a class is implemented. • Documentation comments should be Short and descriptive, § Written in a simple language (ENGLISH), § Accurate. § • Assume that the reader doesn’t know anything about your class Lecture D – Classes & Objects Slide 55 of 87.

API Documentation Tags • Documentation comments can also include tagged paragraphs that give a standard way to document several features of the interface such as method parameters, return values, etc. • A tagged paragraph begins with the symbol @ followed with a tag keywords. Tags: @see, @author, @version, @param, @return, @exception. • Documentation comments text can include HTML tags. Lecture D – Classes & Objects Slide 56 of 87.

@param tag /** * Changes the current time to hour: minute: second * @param hours The new hour value. * @param minutes The new minutes value. * @param seconds The new seconds value. */ public void set. Time(int hours, int minutes, int seconds) { this. hours = hours; this. minutes = minutes; this. seconds = seconds; } Lecture D – Classes & Objects Slide 57 of 87.

set. Time generated javadoc Lecture D – Classes & Objects Slide 58 of 87.

@return /** * Returns the current hour * @return The current hour (between 1 and 12). */ public void get. Hour() { return hours; } Lecture D – Classes & Objects Slide 59 of 87.

get. Hour javadoc Lecture D – Classes & Objects Slide 60 of 87.

Naming • The names you use for your class and for its public methods are part of the class API. • Good descriptive naming are crucial for a clear API. • General rules about naming: § § § Follow the Java conventions Use descriptive names Do not use abbreviations! Make names long enough, not unnecessary long Consist of words in English with no abbreviations Use a dictionary • Read the style guidelines! Lecture D – Classes & Objects Slide 61 of 87.

Changing the Implementation of a Class • Encapsulation allows us to change an implementation of a class without affecting other parts of the program. • Without encapsulation changes to implementation might “break” the program - many changes • Why would we want to change the implementation? § Different implementations have different tradeoffs (e. g. , space conservation, efficiency etc. ) • Example: a time instance in the day can be represented by the number of seconds since midnight • Assume we want to change the implementation of the clock - what is involved in the process? Lecture D – Classes & Objects Slide 62 of 87.

Example of new Clock implementation - page 1 /** * A clock represents a point of time in a 12 * hour period within a precision of seconds. * Its range: 01: 00 -- 12: 59. */ public class Clock { private static final int SECONDS_IN_12 H = 12*60*60; private int seconds. From. Zero; /** * Constructs a Clock: Sets the clock to the * specified time. */ public Clock(int hours, int minutes, int seconds){ seconds. From. Zero = ((hours%12) * 3600 + minutes * 60 + seconds); } Lecture D – Classes & Objects Slide 63 of 87.

Example of new Clock implementation - page 2 /** * Constructs a Clock: */ public Clock(){ seconds. From. Zero=0; } Sets the clock to 12: 00 /** * Advances this clock by 1 second. */ public void second. Elapsed() { seconds. From. Zero = (seconds. From. Zero+1) % SECONDS_IN_12 H; } //… Lecture D – Classes & Objects Slide 64 of 87.

Example of new Clock implementation - page 3 /** * Returns the current hour * @return The current hour (between 1 and 12). */ public void get. Hour() { int h = seconds. From. Zero/3600; return h > 0 ? h : 12 ; } // all the others can be written in the same way Lecture D – Classes & Objects Slide 65 of 87.

Lesson 4 – Classes & Objects Unit D 6 - Applet Methods & Graphic Objects Lecture D – Classes & Objects Slide 66 of 87.

Applet Methods • We saw in earlier applets the use the of the paint method to draw the content of the applet on the screen. public void paint(Graphics g) • An applet has several other methods that perform specific duties. • Because the applets are specifically designed to work with web browsers, some particular applet methods are designed around that concept. Lecture D – Classes & Objects Slide 67 of 87.

Some Applet Methods public void init() • Initializes the applet. Called just after the applet is loaded. public void start() • Starts the applet. Called just after the applet is made active. public void stop() • Stops the applet. Called just after the applet is made inactive. public void destroy() • Destroys the applet. Called when the browser is exited. Lecture D – Classes & Objects Slide 68 of 87.

Init, start, stop, and destroy. • The init method is executed once when the applet is first loaded, such as when the browser or the applet viewer initially view the applet. § This is the place to to initialize the applet’s environment and permanent data. • The start/stop methods of an applet are called when the applet becomes active/inactive. § For example, after we use a browser to initially load an applet start is called. When we leave the page, the applet becomes inactive and stop is called. If we return to that page the applet becomes active again and start is called. init start stop Lecture D – Classes & Objects destroy Slide 69 of 87.

Objects with Graphic representation • Many programs are graphic • Many objects in such programs correspond to “graphic objects” on the screen – this is good programming practice. • Such a graphic object will know how to draw itself on the screen Lecture D – Classes & Objects Slide 70 of 87.

Line. Up Applet Lecture D – Classes & Objects Slide 71 of 87.

The Lineup programs • The Line. Up applet, shown in the previous slide shows 4 • • stick figures of different heights and colors. It uses a Stick. Figure class that represents a stick figure of a certain height, color, and location. The applet creates 4 Stick. Figure objects, of varying color and random height. The Stick. Figure objects are instantiated in the init method of the applet, so they are created once when the applet is loaded. The paint method of Line. Up simply requests that the stick figures draw themselves. Lecture D – Classes & Objects Slide 72 of 87.

Stick. Figure - 1 import java. awt. *; public class Stick. Figure { private int base. X; private int base. Y; private Color color; private int height; public Stick. Figure(int center, int bottom, Color shade, int size) { base. X = center; base. Y = bottom; color = shade; height = size; } Lecture D – Classes & Objects Slide 73 of 87.

Stick. Figure - 2 public void draw(Graphics page) { int top = base. Y – height; page. set. Color(color); //head page. draw. Oval(base. X-10, top, 20); //trunk page. draw. Line(base. X, top+20, base. X, base. Y-30); page. draw. Line(base. X, base. Y-30, base. X-15, base. Y); //legs page. draw. Line(base. X, base. Y-30, base. X+15, base. Y); //arms page. draw. Line(base. X, base. Y-70, base. X-25, base. Y-70); page. draw. Line(base. X, base. Y-70, base. X+20, base. Y-85); } Lecture D – Classes & Objects Slide 74 of 87.

Line. Up - code import java. applet. Applet; import java. awt. *; public class Line. Up extends Applet { private final int APPLET_WIDTH = 400; private final int APPLET_HEIGHT = 150; private final int HEIGHT_MIN = 100; private final int VARIANCE = 30; private Stick. Figure figure 1, figure 2, figure 3, figure 4; Lecture D – Classes & Objects Slide 75 of 87.

Line. Up - code public void init () { int h 1, h 2, h 3, h 4; h 1 h 2 h 3 h 4 = = // heights of figures (int)(Math. random() * * VARIANCE) + + HEIGHT_MIN; figure 1 = new Stick. Figure(100, 150, Color. red, h 1); figure 2 = new Stick. Figure(150, Color. cyan, h 2); figure 3 = new Stick. Figure(200, 150, Color. green, h 3); figure 4 = new Stick. Figure(250, 150, Color. yellow, h 4); set. Background(Color. black); set. Size(APPLET_WIDTH, APPLET_HEIGHT); } Lecture D – Classes & Objects Slide 76 of 87.

Line. Up - code public void paint (Graphics page){ figure 1. draw(page); figure 2. draw(page); figure 3. draw(page); figure 4. draw(page); } } Lecture D – Classes & Objects Slide 77 of 87.

Lesson 4 – Classes & Objects Unit D 7 - Static and Auxiliary Methods Lecture D – Classes & Objects Slide 78 of 87.

The Static Modifier • The static modifier can be applied to variables or methods • It associates a variable or method with the class rather than an object • Methods that are declared as static do not act upon any particular object. They just encapsulate a given task, a given algorithm. • We can write a class that is a collection of static methods. Such a class isn’t meant to define new type of objects. It is just used as a library for utilities that are related in some way. Lecture D – Classes & Objects Slide 79 of 87.

Example - a Math Class /** * A library of mathematical methods. */ public class Math { /** * Computes the trigonometric sine of an angle. */ public static double sin(double x) { … } /** * Computes the logarithm of a given number. */ public static double log(double x) { … } //. . . Lecture D – Classes & Objects Slide 80 of 87.

Static Variables • A variable that is declared static is associated with the class itself and not with an instance of it. • Static variables are also called class variables. • We use static variables to store information that is not associated with a given object, but is relevant to the class. • We have already seen such usage - constants of a class (final static) Lecture D – Classes & Objects Slide 81 of 87.

Static Variables - Example public class Bank. Account { private long account. Number; private double balance; private static int number. Of. Accounts = 0; public Bank. Account() { this. account. Number = ++number. Of. Accounts; this. balance = 0; } public static int get. Number. Of. Accounts { return number. Of. Accounts; } } Lecture D – Classes & Objects Slide 82 of 87.

Static Methods and Instance Variables • Static methods: cannot reference instance variables (e. g. - access instance variable when an object doesn’t exist) § can reference static variables or local variables (within the method) § • this has no meaning inside a static method, thus its use inside a static method is not allowed. • Instance methods can access static variables. Lecture D – Classes & Objects Slide 83 of 87.

Division Into Methods • Complicated tasks or tasks that occur often within a class should be wrapped in a method • If you can clearly define the task, you should probably make it a method. • This results in a readable and manageable code • This is very helpful when implementing algorithms, or when we need “helper” methods in classes. Lecture D – Classes & Objects Slide 84 of 87.

Division into methods – interest calculation public class Bank. Account { final static int DAYS_IN_YEAR = 365; public void earn. Daily. Interest(int days){ double rate = 1 + interest. Rate()/DAYS_IN_YEAR; for(int j=0 ; j<days ; j++) balance *= rate; } private double interest. Rate() { return (balance>100000) ? 0. 06 : 0. 05; } Lecture D – Classes & Objects Slide 85 of 87.

Division into Methods – Printing primes public class Print. Primes { public static void main(String[] args) { for(j = 2 ; j < 1000 ; j++){ if (is. Prime(j)) System. out. println(j); } } private static boolean is. Prime(int n){ for(int j=2 ; j < n ; j++) if (n%j == 0) return false; return true; } } Lecture D – Classes & Objects Slide 86 of 87.

Lesson 4 – Classes & Objects Lecture D – Classes & Objects Slide 87 of 87.