Container Vs. Definition Classes. Container Class

Transcription

1 Overview Abstraction Defining new classes Instance variables Constructors Defining methods and passing parameters Method/constructor overloading Encapsulation Visibility modifiers Static members 14 November 2007 Ariel Shamir 1 Container Vs. Definition Classes Container classes: A collection of static methods that are not bound to any particular object. These static methods usually have something in common. Definition classes: These classes define new objects, in a way that we will soon see. 14 November 2007 Ariel Shamir 2 Container Class The Math class is an example of the first kind. It is a container for math utility methods: Math.sqrt() Math.abs() Math.max() November 2007 Ariel Shamir 3 1

2 Definition Class The class Turtle is an example of the second kind. It defines a new type of objects, Turtle objects. We will focus more on the second kind. 14 November 2007 Ariel Shamir 4 Abstraction Think of the object in its ideal form: what does it represent? What behaviors it should have? It is often useful to think of a real-world comparison, to help choose the name for the class and its methods. Often we include methods that we don t immediately need only because they make sense for the abstraction of the object. 14 November 2007 Ariel Shamir 5 The Clock Abstraction Clock(int hours, int minutes, int seconds) void secondelapsed() int getseconds() int getminutes() int gethours() November 2007 Ariel Shamir 6 2

3 Using a Clock Clock newyorkclock = new Clock(12,59,59); // advance New York clock by three seconds for (int j = 0; j < 3; j++) { System.out.println(newYorkClock.getHours() + : + newyorkclock.getminutes() + : + newyorkclock.getseconds()); newyorkclock.secondelapsed(); 14 November 2007 Ariel Shamir 7 Using a Clock (Cont.) Clock israelclock = new Clock(6,0,0); // advance Israel clock by one hour for (int j = 0; j < 60 * 60; j++) { System.out.println(israelClock.getHours() + : + israelclock.getminutes() + : + israelclock.getseconds()); israelclock.secondelapsed(); 14 November 2007 Ariel Shamir 8 Instance Variables Recall that a class must define the state of an object and its behavior. The state of an object is the state of the data it holds. The data of a class are its instance variable. Instance variables (or fields) are defined in a similar way to that of regular variables, only they appear outside methods, inside the class. 14 November 2007 Ariel Shamir 9 3

4 Method Local Data Vs. Object Data. Data inside the method is called local data. Local data is created when method invoked and destroyed when method returned. Instance variables are part of the object and hence are not destroyed (only when the object itself is destroyed). 14 November 2007 Ariel Shamir 10 The Clock Class Instance Variables /** * A clock representation class. Clock instances * represent a point of time during the day in a * precision of seconds. */ public class Clock { // The current hours, minutes, and second private int hours, minutes, seconds; // November 2007 Ariel Shamir 11 The Private Modifier Roughly speaking, the private modifier means that the variables are not part of the object s interface: private int hours, minutes, seconds; Other possible modifiers are: public, protected 14 November 2007 Ariel Shamir 12 4

5 Constructors Objects must be initialized before they can be used (similar to primitive data types). We must specify what is the initial state of the object before we can use it. 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. 14 November 2007 Ariel Shamir 13 Clock Constructor public class Clock { // The current hours, minutes, and second private int hours, minutes, seconds; /** * Constructs a new clock, sets the * clock to the time 00:00:00. **/ public Clock() { hours = 0; minutes = 0; seconds = 0; 14 November 2007 Ariel Shamir 14 Creating a Clock The statement new Clock() does the following: 14 November 2007 Ariel Shamir 15 5

6 Creating a Clock The statement new Clock() does the following: 1. Allocates the memory for a new clock object clock hours minutes seconds 14 November 2007 Ariel Shamir 16 Creating a Clock The statement new Clock() does the following: 1. Allocates the memory for a new clock object 2. Initializes its state by calling the constructor clock hours 0 minutes 0 seconds 0 14 November 2007 Ariel Shamir 17 Methods To make the clock object useful, we must provide methods that define its behavior and operations. We declare methods in a similar way to the way the method main was declared: public static void main(string[] args) { // November 2007 Ariel Shamir 18 6

7 Methods Purpose We have seen: Simplify sub-tasks Reuse the same piece of code Now: Operations on the objects Access to objects data (queries) 14 November 2007 Ariel Shamir 19 Non Static Methods static methods (such as main() method) are not bound to a specific object We want to declare instance methods, which operate on a specific instance of an object 14 November 2007 Ariel Shamir 20 Clock Method Example public class Clock { private int hours, minutes, seconds; public Clock() { //... /** * Advances the clock by one hour. */ public void hourelapsed() { hours = (hours + 1) % 24; 14 November 2007 Ariel Shamir 21 7

8 Methods Modifiers The modifier public denotes that the method hourelapsed() is part of the interface of the class (it is one of the services that the class exposes to outside world clients) The keyword void denotes that the method hourelapsed() has no return value 14 November 2007 Ariel Shamir 22 Another Clock Method public class Clock { //... instance variables and constructor public void hourelapsed() { hours = (hours + 1) % 24; /** * Returns the hour read. */ public int gethours() { return hours; 14 November 2007 Ariel Shamir 23 Instance Methods gethours() and hourelapsed() are instance methods, which means they act on a particular instance of the class. They cannot be invoked without a particular object and they execute in the context of this object: Clock c = new Clock(); gethours(); // of which clock? c.gethours(); // will return 0 14 November 2007 Ariel Shamir 24 8

9 Using Instance Methods public class ClockTest { public static void main(string[] args) { Clock swatch = new Clock(); Clock seiko = new Clock(); System.out.println(swatch.getHours()); // 0 System.out.println(seiko.getHours()); // 0 swatch.hourelapsed(); System.out.println(swatch.getHours()); // 1 System.out.println(seiko.getHours()); // 0 14 November 2007 Ariel Shamir 25 Clocks Memory Layout swatch seiko Clock object hours 1 minutes 0 seconds 0 Clock object hours 0 minutes 0 seconds 0 14 November 2007 Ariel Shamir 26 The this Reference When 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 gethours() { return hours; public int gethours() { return this.hours; 14 November 2007 Ariel Shamir 27 9

10 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 14 November 2007 Ariel Shamir 28 SetTime Method Documentation public class Clock { private int hours, minutes, seconds; /** * Sets the clock to the specified time. * If one of the parameters is not in the allowed * range, the call does not have any effect on the * clock. hours The hours to be set (0-23) minutes The minutes to be set (0-59) seconds The seconds to be set (0-59) */ 14 November 2007 Ariel Shamir 29 SetTime Method Implementation public void settime(int hours, int minutes, int seconds) { if ((seconds >= 0) && (seconds < 60) && (minutes >= 0) && (minutes < 60) && (hours >= 0) && (hours < 24)) { this.hours = hours; this.minutes = minutes; this.seconds = seconds; // no effect if input is illegal 14 November 2007 Ariel Shamir 30 10

11 Using This Reference public class Clock { private int hours, minutes, seconds; /** */ public void settime(int hours, int minutes, int seconds) { if ((seconds >= 0) && (seconds < 60) && (minutes >= 0) && (minutes < 60) && (hours >= 0) && (hours < 24)) { this.hours = hours; this.minutes = minutes; this.seconds = seconds; // no effect if input is illegal 14 November 2007 Ariel Shamir 31 Passing Parameters When a parameter is passed, a copy of the value is made and assigned to the formal parameter: Clock beritling = new Clock(); int lunchhour = 12; breitling.settime(lunchhour,32,14); 14 November 2007 Ariel Shamir 32 Value Passing Clock beritling = new Clock(); int lunchhour = 12; breitling.settime(lunchhour,32,14); public void settime(int hours, int minutes, int seconds) { breitling hours = 12 minutes = 32 seconds = November 2007 Ariel Shamir 33 11

12 Object Reference as Parameters Both primitive types and object references can be passed as parameters When a primitive type is passed the actual value is passed ( call by value ) When an object reference is passed, the formal parameter becomes an alias of the actual parameter ( call by reference ) 14 November 2007 Ariel Shamir 34 A Bank Account Object Interface BankAccount public BankAccount(long accountnumber) public void deposit(float amount) public void withdraw(float amount) public void transfer (float amount, BankAccount targetaccount) 14 November 2007 Ariel Shamir 35 /** * A bank account. */ public class BankAccount { private long accountnumber; // The balance in dollars private float balance; /** * Constructs a new empty account. */ public BankAccount(long accountnumber) { this.accountnumber = accountnumber; this.balance = 0; // continued in next slide November 2007 Ariel Shamir 36 12

13 /** * Deposites a given amount into the account. */ public void deposit(float amount) { //... perhaps perform some security checks balance = balance + amount; /** * Withdraws a given amount from the account. */ public void withdraw(float amount) { //... perhaps perform some security checks balance = balance - amount; // continued in next slide November 2007 Ariel Shamir 37 /** * Transfers a given amount into * another bank account */ public void transfer(float amount, BankAccount targetaccount) { //... perhaps perform some security checks this.withdraw(amount); targetaccount.deposit(amount); amount += ; // just for fun :-) 14 November 2007 Ariel Shamir 38 Usage // Usage... BankAccount gadiaccount = new BankAccount( ); BankAccount saritaccount = new BankAccount( ); gadiaccount.deposit(500); // gadi s balance = 500 int amount = 700; gadiaccount.transfer(amount,saritaccount); // gadi s balance = -200, sarit s balance = 700 System.out.println( Gadi has just transferred + amount + dollars to Sarit ); Output: Gadi has just transferred 700 dollars to Sarit 14 November 2007 Ariel Shamir 39 13

14 Method Signature The name of the method together with the list of its formal parameters is called the signature of the method public void settime(int hours, int minutes, int seconds) void_settime_int_int_int 14 November 2007 Ariel Shamir 40 Overloading Methods You may define two (or more) methods with the same name and same return type but they must differ in the number or type of parameters (hence they have different signature). Note: they must return the same type! This is called overloading! 14 November 2007 Ariel Shamir 41 Calling an Overloaded Method When we call a method, the compiler (or JVM) decides which method to invoke according to the type and number of the actual parameters. 14 November 2007 Ariel Shamir 42 14

15 Method Overloading Example class mymath { //... int add(int x, int y); int add(double a, double b); MyMath m; int sum; sum = m.add(3,4); // will use add(int,int) sum = m.add(3.5,5.2); // will use add(double,double) sum = m.add(3,5.2); // will use add(double,double) 14 November 2007 Ariel Shamir 43 More on Constructors Constructors have no declared return type and cannot return anything. Constructors are always used with the new operator. Constructors must have exactly the same name as class. A class can have many ways to initialize instances. This is done by defining several constructors. 14 November 2007 Ariel Shamir 44 Constructor Overloading Different constructors differ by the number and/or type of parameters they receive. When we construct an object, the compiler decides which constructor to invoke according to the type of the actual parameters. If no other constructor is defined, the compiler creates the default constructor for the class automatically. 14 November 2007 Ariel Shamir 45 15

16 Default Constructor The default constructor receives no parameters and it initializes all the instance variables to zero or null (depending on the type). When we define a constructor with no parameter it is sometimes called a default constructor: public class Clock { private int hours, minutes, seconds; public Clock() { // November 2007 Ariel Shamir 46 Overloading Clock Constructor /** * Constructs a new clock with the specified hours, * minutes and seconds read. * If one of the paramenters is not in the allowed * range, the time will be reset to 00:00:00. hours The hours to be set (0-23) minutes The minutes to be set (0-59) seconds The seconds to be set (0-59) */ public Clock(int hours, int minutes, int seconds) { // implementation on the next slide 14 November 2007 Ariel Shamir 47 Clock Constructor Implementation public Clock(int hours, int minutes, int seconds) { if ((seconds >= 0) && (seconds < 60) && (minutes >= 0) && (minutes < 60) && (hours >= 0) && (hours < 24)) { this.hours = hours; this.minutes = minutes; this.seconds = seconds; else { this.hours = 0; this.minutes = 0; this.seconds = 0; 14 November 2007 Ariel Shamir 48 16

17 Using Overloaded Constructors // default constructor... Clock c1 = new Clock(); // Clock(int, int, int) constructor... Clock c2 = new Clock(23,12,50); The constructor must always check the parameters: in no way may an object be initialized to an inconsistent state! What is an inconsistent state in a clock? 14 November 2007 Ariel Shamir 49 Method Overloading Discussion Advantages: Opens up namespace Means shorter names An overloaded constructor provides multiple ways to set up a new object Disadvantages: Can accidentally invoke wrong version as a result of human error (leaving off parameter, forgetting a cast) 14 November 2007 Ariel Shamir 50 Interface Vs. Implementation Objects have two kinds of behavior: Outer send & receive messages, relations with other objects. Inner processing and computing the messages. Usually these are called the interface (outer) vs. Implementation (inner). 14 November 2007 Ariel Shamir 51 17

18 Implement & Interface Example: Point class Point { private float m_x,m_y; public float getx() { return m_x; public float gety() { return m_y; public void setx(float x) { m_x=x; public void setx(float x) { m_x=x; Interface implementation 14 November 2007 Ariel Shamir 52 Encapsulation Object should generally hide their implementation and internal representation (data). This makes the use of objects more easy and allows later changes in the implementation. 14 November 2007 Ariel Shamir 53 Black Box An encapsulated object can be thought of as a black box; its inner workings are hidden from other objects, clients or user. a Point object getx() gety() setx() sety() object interface client 14 November 2007 Ariel Shamir 54 18

19 Encapsulation Advantages In black box programming user gets object interface but should not have to be aware of internal implementation of it. The interface cannot be bypassed. Encapsulation makes an object easy to manage because all communication with the object are done through well defined services. 14 November 2007 Ariel Shamir 55 Modularity The use of objects ease the design and maintenance of complex systems. We divide the system into several autonomous components (objects). Each has a well defined role and interface. These objects interact between them to achieve the functionality of the whole system. The components themselves can be further divided into smaller components. 14 November 2007 Ariel Shamir 56 Components & Reuse Building our system from smaller components, has several advantages: It is easier to understand the systems in terms of a collection of few interoperating object. We can correct/improve the implementation of one component, without affecting the others. A component may be used later in other places. We may find components written by others that are suitable for our needs. 14 November 2007 Ariel Shamir 57 19

20 Reusable Objects Design Autonomous - a component should be an autonomous entity, so it could work anywhere. Abstraction - it should have a clear abstraction, so others can easily understand it s behavior (know what to expect from it). Clear interface - it should have a clear interface so it will be easy to work with, and to maintain. Documentation & Naming - without documentation and good naming for interface methods, no one will understand how to use it. 14 November 2007 Ariel Shamir 58 Visibility Modifiers We accomplish encapsulation through the appropriate use of visibility modifiers A modifier is a Java reserved word that specifies particular characteristics of a programming construct (The final modifier is used for constants) Java has three visibility modifiers: public, private, and protected 14 November 2007 Ariel Shamir 59 Classes Visibility Modifiers 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. 14 November 2007 Ariel Shamir 60 20

21 Default Visibility The default visibility draws a limit to which other classes can use this class. 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. 14 November 2007 Ariel Shamir 61 Using a Public Class Any other class can use a MyClass which is defined as a public class. public MyClass { // 14 November 2007 Ariel Shamir 62 Class Members We use the generic term member to describe a variable, a method or a constructor of the class. Class instances (object) share the class method members (the code for execution) but have unique copy of the class data members (variables). 14 November 2007 Ariel Shamir 63 21

22 Access to Members You access a class member using an object reference +. + member name: leon.taildown() this.hours Or using class name if it is static: Math.sqrt() 14 November 2007 Ariel Shamir 64 Data Members Vs. Method Members P1 m_x 4 m_y 7.5 getx() gety() setx() sety() class point { float m_x,m_y; getx() { gety() { setx() { sety() { P2 m_x 0.5 m_y 33 getx() gety() setx() sety() 14 November 2007 Ariel Shamir 65 Members Visibility Modifiers Members of a class can be declared as private, protected, public or without a visibility modifier: private int hours; protected int hours; int hours; public int hours; later Members that are declared without a visibility modifier are said to have default visibility. 14 November 2007 Ariel Shamir 66 22

23 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 gethours(), hourelapsed() and settime() are part of the interface of class Clock so we define them as public. 14 November 2007 Ariel Shamir 67 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 data variables and auxiliary methods as private. Data hiding is essential for encapsulation. 14 November 2007 Ariel Shamir 68 Illegal Access // Example of illegal access public class BankAccount { private float balance; //... class BankAccountTest { public static void main(string[] args) { BankAccount victim = new BankAccount( ); victim.balance = victim.balance - 500; // this will not compile! 14 November 2007 Ariel Shamir 69 23

24 Encapsulation Level Encapsulation comes in the class level and not in the object level. Private access disallowed! Private access allowed! 14 November 2007 Ariel Shamir 70 Encapsulation Among Instances of Same Class 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). In Java object of a certain class (instances) can access private members of other object of the same class! 14 November 2007 Ariel Shamir 71 BankAccount Example From within a BankAccount object, any private member of a different BankAccount object can be accessed: /** * Transfers a given amount into another bank account */ public void transfer(float amount, BankAccont other) { //... perhaps perform some security checks this.withdraw(amount); other.deposit(amount); // an alternative way of doing the same thing: // other.balance = other.balance + amount 14 November 2007 Ariel Shamir 72 24

25 Class Vs. Objects Most of the data and methods reside and work on specific objects of a class. The class is only a blueprint used as object definition. This view is not totally correct. There are situations in which data and/or methods reside in the class itself. 14 November 2007 Ariel Shamir 73 Static Data Members Only one instance of a static variable exists for the whole class The value of the variable is one for all instances The variable exist even before any objects of the class are instantiated By default static variables are initialized to 0 or null 14 November 2007 Ariel Shamir 74 Static Variable Chart P1 m_x 4 m_y 7.5 m_count getx() gety() setx() sety() class point { float m_x,m_y; static int m_count 2 getx() { gety() { setx() { sety() { P2 m_x 0.5 m_y 33 m_count getx() gety() setx() sety() 14 November 2007 Ariel Shamir 75 25

26 Static Methods Static methods can operate only on static variables or call other static methods. They are not connected to a specific instance and therefore cannot use this reference. Instance methods can access static variables! 14 November 2007 Ariel Shamir 76 Static Method Call The access to a static method is not done through an object but through the class name itself: float i = Math.random(); String s = String.valueOf(i); If a static method calls another static method of the same class than the classname can be omitted. 14 November 2007 Ariel Shamir 77 Defining Static Members All static data/methods are marked with a static modifier. static <type> variable_name; static <type> function_name(...); Examples: static int count; static void foo(); 14 November 2007 Ariel Shamir 78 26

27 The Main Method The main method is static; it is invoked by the system without creating an instance object! public static void main(string[] args); 14 November 2007 Ariel Shamir 79 Static Variables Example Frequent usage of a static variable is as a counter holding the number of objects of the class. class Visitor { static int m_count; public Visitor() { m_count++; 14 November 2007 Ariel Shamir 80 Static Variables Value Change Follow the changes in m_count variable as we instantiate objects of Visitor class: class Theater { public static void main(...) { // Visitor avi = new Visitor(); // Visitor beni = new Visitor(); // m_count = 0 m_count = 1 m_count = 2 14 November 2007 Ariel Shamir 81 27

28 /** * A bank account. */ public class BankAccount { private long number; private static int nextid = 1; // The balance in dollars private float balance; /** * Constructs a new empty account. */ public BankAccount() { this.accountnumber = nextid++; this.balance = 0; // more methods November 2007 Ariel Shamir 82 Usage // Usage... BankAccount gadiaccount = new BankAccount(); BankAccount saritaccount = new BankAccount(); BankAccount arikaccount = new BankAccount(); 14 November 2007 Ariel Shamir 83 Static Variable Chart GadiAccount balance 0 number 1 nextid class BankAccount { float balance; int number; static int nextid 1 BankAccount() { November 2007 Ariel Shamir 84 28

29 Static Variable Chart GadiAccount balance 0 number 1 nextid class BankAccount { float balance; int number; static int nextid 2 BankAccount() {... SariAccount balance 0 number 2 nextid 14 November 2007 Ariel Shamir 85 Static Variable Chart GadiAccount balance 0 number 1 nextid class BankAccount { float balance; int number; static int nextid 3 BankAccount() {... ArikAccount balance 0 number 3 nextid SariAccount balance 0 number 2 nextid 14 November 2007 Ariel Shamir 86 A Collection of Static Methods Even if no static variables exist static methods can still be used to implement general functionality. 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. 14 November 2007 Ariel Shamir 87 29

30 Example java.lang.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) { //... // November 2007 Ariel Shamir 88 Use of Math Methods It is just used as a library for utilities that are related in some way: double x = Math.sin(alpha); int c = Math.max(a,b); double y = Math.random(); 14 November 2007 Ariel Shamir 89 30