1. Defining Classes and Methods Chapter 4.1

2. Key Features of Objects An object has identity (it acts as a single whole). An object has state (it has various properties, which might change). An object has behavior (it can do things and can have things done to it). An object belongs to a class. (cf. Object-oriented Analysis and Design, by Grady Booch, Addison-Wesley, 1994.)

3. Objects of a Class

4. Basic Terminology Objects can represent almost anything. A class defines a family of objects. –It specifies the kinds of data an object of the class can have. –It provides methods specifying the actions an object of the class can take. An object is an instance of the class. We will call the data items associated with an object the instance variables of that object (i.e. that instance of the class).

5. Object Oriented Programming: three stages Creating the program: –define classes that describe objects that the program will use when it is running. –including one class that contains the static main() method which is used to start the program running Compiling the program –translation to bytecode Running the program –The java interpreter looks for a static main() method and starts running. –The program does its work by creating objects and invoking their methods. The order of creation and invocation depends upon the problem at hand.

6. Class Files and Separate Compilation Each Java class definition should be in a file by itself. A Java class can be compiled before it is used in a program If all the classes used in a program are in the same directory (folder) as the program file, you do not need to import them.

7. Syntax of Class Definitions class ClassName { Descriptions of the instance variables and methods each object will have and the constructors that initialize a new object. }

8. Class Definition Often the class definition is segmented for clarity as follows class ClassName { // Description of the variables. // Description of the constructors. // Description of the methods }

9. Checkpoint A program is a class that has a method named main Does every class require a main( ) method?

10. Object Oriented Hello class HelloObject { // method definition void speak() { System.out.println("Hello from an object!"); } } class HelloTester { // method definition public static void main ( String[] args ) { HelloObject anObject = new HelloObject(); anObject.speak(); }

11. What Happens class HelloObject { // method definition void speak() { System.out.println("Hello from an object!"); } } class HelloTester { // method definition public static void main ( String[] args ) { HelloObject anObject = new HelloObject(); anObject.speak(); } 1 main starts running 2 New HelloObject is created 3 it is assigned to anObject 4 speak method of anObject is invoked. 5 A message is printed on the screen. 6. The program finishes

12. speak( ) method requires anObject to contain it

13. Methods and Objects In general, methods require an object to be present in order to be invoked. However, this is not always the case. Static methods can be invoked by themselves. main is an example of a static method

14. More Complex Example SpeciesFirstTry.java This a class which defined three methods.SpeciesFirstTry.java SpeciesFirstTryDemo.java This is another class which invokes the first one.SpeciesFirstTryDemo.java Both definitions live in the same directory (folder) – so there is no need for the second to import the first.

15. Two Kinds of Method methods that return a single value (e.g. nextInt ) methods that perform some action other than returning a single value (e.g println ), called void methods

16. Aspects of Methods Methods Definition Methods that return a value Void Methods Invocation Methods that Return a value Void Methods

17. void Method Definitions example public void writeOuput() { System.out.println(“Name: “ + name); System.out.println(“Age: “ + age); } Such methods are called void methods.

18. Definition of Methods That Return a Value example public int fiveFactorial(); { int factorial = 5*4*3*2*1; return factorial; } As before, the method definition consists of the method heading and the method body. –The return type replaces void.

19. Method Definitions, cont. The parentheses following the method name contain any information the method needs. public int fiveFactorial(); In this case there is no information since there is nothing between parentheses Sometimes, however, we do include such information in the form of a parameter list e.g. public int sum(int i, j); The parameter list gives the order and types of arguments This first part of the method definition is called the heading. The remainder of the method is called the body, and is enclosed in braces {}.

20. Defining Methods That Return a Value, cont. The body of the method contains declarations and statements. The body of the method definition must contain return Expression; –This is called a return statement. –The Expression must produce a value of the type specified in the heading.

21. Using return in a void Method A void method is not required to have a return statement. However, it can be user to terminate the method invocation before the end of the code, to deal with some problem, form return;

22. Invocation of Methods that Return a Value example int next = keyboard.nextInt(); –keyboard is the calling object. –keyboard.nextint() is the invocation. –You can use the invocation any place that it is valid to use of value of the type returned by the method.

23. Invocation of Methods that Do Not Return a Value example System.out.println(“Enter data:”); –System.out is the calling object. –System.out.println() is the invocation. The method invocation is a Java statement that produces the action(s) specified in the method definition. It is as if the method invocation were replaced by the statements and declarations in the method definition.

24. Variables A class definition is associated with different kinds of variables. –variables that are declared in the class –variables that declared in the methods defined within the class.

25. The Class Bank Account public class BankAccount { public double amount; public double rate; public void showNewBalance( ) { double newAmount = amount + (rate/100.0)*amount; System.out.println("amount is $" + newAmount); }

26. Variables When an instance of a class is created, a new instance of each variable declared in the class is created. These variables are instance variables. Instance variables declared to be public can be accessed from outside the class.

27. Accessing Instance Variables Outside the class definition, a public instance variable is accessed with –objectname. instancevariable name aBankAccount.rate = 10; Inside the definition of the same class only the name of the instance variable is used. amount + (rate/100.0)*amount

28. Use of this Inside the definition of the same class only the name of the instance variable is used. amount + (rate/100.0)*amount Equivalently this stands for the calling object - the object that invokes the method. this.amount + (this.rate/100.0) * this.amount

29. Local Variables Variables that belong to the methods are private to the method. They are called local variables They cannot be accessed from outside the method in which they are defined.

30. Identify the Local Variable public class BankAccount { public double amount; public double rate; public void showNewBalance( ) { double newAmount = amount + (rate/100.0)*amount; System.out.println("amount is $" + newAmount); } local variable instance variables

31. What is the Output? public class LocalVariablesDemoProgram { public static void main(String[] args) { BankAccount myAccount = new BankAccount( ); myAccount.amount = 100.00; myAccount.rate = 5; double newAmount = 800.00; myAccount.showNewBalance( ); System.out.println("I wish my new amount were $" + newAmount); }

32. Blocks The terms block and compound statement both refer to a set of Java statements enclosed in braces {}. A variable declared within a block is local to the block. –When the block ends, the variable disappears. If you intend to use the variable both inside and outside the block, declare it outside the block.

33. Local Varables { int x = 1, y = 2; { int x = 3; x = x + y; System.out.println(x); } x = x + y; System.out.println(x); }

34. Constructors Every class is associated with one or more constructors. A constructor is a method which constructs an instance of a class. Below a constructor invocation is shown in red BankAccount ac = new BankAccount( )

35. Default Constructor If a constructor is not defined explicitly within the class definition, it receives a default definition. The default definition is a method without arguments whose name is the same as that of the class. The default constructor behaves as though it were defined as shown in red.

36. Default Constructor class HelloObject { HelloObject() // default constructor { } void speak() { System.out.println("Hello from an object!"); } } Because the default constructor exists we can write new HelloObject(). Note that it has an empty argument list.

37. Improving HelloObject – Step 1 The first step is to provide the speak method with a variable, in this case greeting, to hold the greeting string. class HelloObject { String greeting; void speak() { System.out.println(greeting); } How does greeting receive a value?

38. Assigning to greeting What we want is to be able to write something like this: { hello = new HelloObj(“hello”), goodbye = newHelloObj(“goodbye”); hello.speak(); goodbye.speak(); } In other words, we want to convey information to the object through parameters of the constructor. The problem is that the default constructor for HelloObj has no parameters.

39. The instance variable has to be set by the constructor – which means that the constructor has to have one parameter. We therefore cannot use the default constructor, and have to write our own. Further details are given in Kjell Chapter 30Kjell Chapter 30

40. How Values are Transmitted The method invocation, e.g. HelloObject(″Goodbye″) evaluates the supplied argument (actual parameter) The value of the argument is assigned to the method's corresponding formal parameter. The method computes with the parameter set to that value. This is known as the call-by-value mechanism.