Defining Classes and Methods

1. Defining Classes and Methods Chapter 4

2. Object-Oriented Programming • Our world consists of objects (people, trees, cars, cities, airline reservations, etc.). • Objects can perform actions which effect themselves and other objects in the world. • Object-oriented programming (OOP) treats a program as a collection of objects that interact by means of actions.

3. OOP Design Principles • OOP adheres to three primary design principles: • encapsulation • polymorphism • inheritance.

4. Introduction to Encapsulation • The data and methods associated with any particular class are encapsulated (“put together in a capsule”), but only part of the contents is made accessible. • Encapsulation provides a means of using the class, but it omits the details of how the class works. • Encapsulation often is called information hiding.

5. Accessibility Example • An automobile consists of several parts and pieces and is capable of doing many useful things. • Awareness of the accelerator pedal, the brake pedal, and the steering wheel is important to the driver. • Awareness of the fuel injectors, the automatic braking control system, and the power steering pump is not important to the driver.

6. Introduction to Inheritance • Classes can be organized using inheritance.

7. Introduction to Inheritance, cont. • A class at lower levels inherits all the characteristics of classes above it in the hierarchy. • At each level, classifications become more specialized by adding other characteristics. • Higher classes are more inclusive; lower classes are less inclusive.

8. Introduction to Polymorphism • from the Greek meaning “many forms” • The same program instruction adapts to mean different things in different contexts. • A method name, used as an instruction, produces results that depend on the class of the object that used the method. • everyday analogy: “take time to recreate” causes different people to do different activities • more about polymorphism in Chapter 7

9. Outline • Class and Method Definitions • Information Hiding and Encapsulation • Objects and Reference

10. Class and Method Definitions: Outline • Class Files and Separate Compilation • Instance Variables • Using Methods • void Method Definitions • Methods that Return a Value • Accessing Instance Variables • Local Variables • Blocks • Parameters of a Primitive Type • Class and Method Definition Syntax

11. Basic Terminology • Objects can represent almost anything. • A class defines a kind of object. • 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 satisfying the class definition instantiates the class and is an instance of the class.

12. Basic Terminology, cont. • The data items and the methods are referred to as members 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).

13. A Class as an Outline

14. Class and Method Definition Syntax public class Class_Name { Instance_Variable_Declaration_1; Instance_Variable_Declaration_2; … Method_Definition_1 Method_Definition_2 ... }

15. Class and Method Definition Syntax, cont. public Type_Name_Or_void Method_Name(Parameter_List); where Parameter_List consists of • a list of one or more formal parameter names, each preceded by a type and separated by commas or • no formal parameters at all

16. Example • The modifier public associated with the instance variables should be replaced with the modifier private, as we will do later in the chapter.

17. Class Files and Separate Compilation • Each Java class definition should be in a file by itself. • The name of the file should be the same as the name of the class. • The file name should end in .java • A Java class can be compiled before it is used in a program • The compiled byte code is stored in a file with the same name, but ending in .class

18. Class Files and Separate Compilation, cont. • If all the classes used in a program are in the same directory as the program file, you do not need to import them.

19. Using Methods • two kinds of methods: • 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

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

21. Methods That Do Not Return a Value • example System.out.println(“Enter data:”); • System.out is the calling object. • 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.

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

23. Method Definitions • All method definitions belong to some class. • All method definitions are given inside the definition of the class to which they belong. • If the definition of the method begins with public void, it does not return a value. • public indicates that use is unrestricted. • void indicates that the method does not return a value.

24. Method Definitions, cont. • The parentheses following the method name contain any information the method needs. • The first part of the method definition is called the heading. • The remainder of the method is called the body, and is enclosed in braces {}. • Statements or declarations are placed in the body.

25. The Method main • A program is a class that has a method named main. • The programs we have seen so far have no instance variables and no methods other than method main. • Programs can have instance variables and other methods.

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

27. Defining Methods That Return a Value, cont. • 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. • The body can contain multiple return statements, but a single return statement makes for better code.

28. Using return in a void Method • form return; • use • to end the invocation of the method, usually prematurely, to deal with some problem • caution • Almost always, there are better ways to deal with a potential problem.

29. public Method Definitions • syntax for a void method public void Method_Name(Parameters); { <statement(s)> } • syntax for methods that return a value public Return_Type Method_Name(Parameters); { <statement(s), including a return statement> }

30. Accessing Instance Variables • Outside the class definition, a public instance variable is accessed with • the name of an object of the class • a dot (.) • the name of the instance variable. • Example:myBestFriend.name = “Lara”; • Inside the definition of the same class only the name of the instance variable is used. • Example:name =keyboard.nextLine();

31. Accessing Instance Variables, cont. • equivalent assignment statements: name =keyboard.nextLine(); and this.name = keyboard.nextLine(); • The keyword this stands for the calling object - the object that invokes the method.

32. Local Variables • A variable declared within a method is called a local variable. • Its meaning is “local to” (confined to) the method definition. • Variables with the same name declared within different methods are different variables. • A local variable exists only as long as the method is active.

33. Local Variables, cont. • class BankAccount • class LocalVariablesDemoProgram

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

35. Variables in for Statements • The loop control variable can be declared outside the for statement int n; for (n = 1; n <10, n++) in which case the variable n still exists when the for statement ends or

36. Variables in for Statements, cont. • The loop control variable can be declared inside the for statement for (int n = 1; n <10, n++) in which case the variable n ceases to exist when the for statement ends

37. Parameters of a Primitive Type • Often it is convenient to pass one or more values into a method and to have the method perform its actions using those values. • The values are passed in as arguments (or actual parameters) associated with the method invocation.

38. Parameters of a Primitive Type, cont. • The method receives the values and stores them in its formal parameters (or simply parameters). • A method invocation assigns the values of the arguments (actual parameters) to the corresponding formal parameters (parameters). • This is known as the call-by-value mechanism. • The formal parameters exist as long as the method is active.

39. Parameters of a Primitive Type, cont. • Generally, the type of each argument must be the same as the type of the corresponding formal parameter. • Java will perform automatic type conversion for an argument that appears to the left of a formal parameter it needs to match byte --> short --> int --> long --> float --> double

40. Parameters of a Primitive Type, cont. • An argument in a method invocation can be • a literal such as 2 or ‘A’ • a variable • any expression that yields a value of the appropriate type. • A method invocation can include any number of arguments; the method definition contains a corresponding number of formal parameters, each preceded by its type.

41. Parameters of a Primitive Type, cont. anObject.doStuff(42, 100, 9.99, ‘Z’); public void doStuff(int n1, int n2, double d1, char c1); • arguments and formal parameters are matched by position • Everything said about arguments and formal parameters applies to methods that return a value as well as to void methods.

42. Method with a Parameter

43. Information Hiding and Encapsulation: Outline • Information Hiding • Precondition and Postcondition Comments • The public and private Modifiers • Encapsulation • Automatic Documentation with javadoc • UML Class Diagrams

44. Information Hiding • “Information overload” is avoided by suppressing or hiding certain kinds of information, making the programmer’s job simpler and the code easier to understand. • A programmer can use a method defined by someone else without knowing the details of how it works (e.g. the println method) • He needs to know what the method does, but not how it does it.

45. Information Hiding, cont. • What the method contains is not secret, and maybe not even interesting. • Viewing the code does not help you use the method and may distract you from the task at hand. • Designing a method so that it can be used how it performs its task is called information hiding or abstraction.

46. The public and private Modifiers • The instance variables of a class should not be declared public. • Typically, instance variables are declared private. • An instance variable declared public can be accessed and changed directly, with potentially serious integrity consequences. • Declaring an instance variable private protects its integrity.

47. The public and private Modifiers, cont. • Analogy: An ATM permits deposits and withdrawals, both of which affect the account balance, but it does not permit an account balance to be accessed and changed directly. If an account balance could be accessed and changed directly, a bank would be at the mercy of ignorant and unscrupulous users.

48. The private Modifier • The private modifier makes an instance variable inaccessible outside the class definition. • But within the class definition, the instance variable remains accessible and changeable. • This means that the instance variable can be accessed and changed only via the methods accompanying the class.

49. Accessor and Mutator Methods • Appropriate access to an instance variable declared private is provided by an accessor method which is declared public. • Typically, accessor methods begin with the word get, as in getName. • Mutator methods should be written to guard against inappropriate changes.

50. Encapsulation • Encapsulation is the process of hiding details of a class definition that are not needed to use objects of the class. • Encapsulation is a form of information hiding.