Classes, Methods, & Objects

1. Classes, Methods, & Objects

2. Objectives • Review public and private fields and methods • Learn the syntax for defining constructors and creating objects • Learn the syntax for defining and calling methods • Learn how parameters are passed to constructors and methods and how to return values from methods • Learn about static and instance fields and methods • Learn about method overloading. • Learn about the copy constructor. • Learn about encapsulation .

3. Terminology • Class – is a model, pattern, or blueprint from which an object is created. A class describes the objects, their structure and behavior • Instance data or variable (fields) – memory space is created for each instance of the class that is created. Variables declared in a class. • When you create an object, you are creating an instance of a class. (Copy of the class) • Method – subprograms that perform a specific task. 2 parts of a method: • Method Declaration – access level(public or private), return type, name, and parameters. • Method Body – local variable declaration, statements that implements the method.

4. Class • Declared public • Keyword class • Class name (1st letter of name should be capitalized) • Begin Brace { • Example: public class Student { • When saving a class, it should be saved as the same name as class with the extension .java

5. Classes and Source Files • The name of the source file must be exactly the same name as the class (including upper and lowercase letters) with the extension .java • The Java files for all the classes you create for a project should be located in the same folder.

6. Objects • In a well designed OOP program, each object is responsible for its own clearly defined set of tasks. Objects must be easily controlled and not too complicated.

7. Class’s Client • Any class that uses class X is called a client of X Class X private fields private methods Class Y A client of X public constructor(s) Constructs objects of X and/or calls X’s methods public methods

8. Fields • Fields – data elements of the class. • Fields may hold numbers, characters, strings, or objects • Fields act as personal memory of an object and the particular values stored in them determine the object’s current state. • Each object (instance of a class) has the same fields, but there may be different values stored in those fields.

9. Fields • Fields are declared as private or public. In most cases, they are declared private • When each variable is created for each object of the class, it is called instance variable. • When a field is declared as static, it is called a class variable and only created once and all objects share that memory location. • Examples: • private intmySum = 10; • private static intmySum = 10; //creates one memory location that all the objects share • Fields are Global meaning that they can be accessed anywhere in the class including methods.

10. Access Modifiers public and private • Variables or methods declared with access modifier private are accessible only to methods of the class in which they are declared. • Public variables or methods can be accessible from outside the class. • Data Hiding (encapsulated) – The private access modifier allows a programmer to hide memory location from the program and can’t be directly changed.

11. Public vs. Private • Public constructors and methods of a class constitute its interface with classes that use it — its clients. • All fields are usually declared private — they are hidden from clients. • Static constants occasionally can be public. • “Helper” methods that are needed only inside the class are declared private.

12. Public vs. Private (cont’d) • A private field is accessible anywhere within the class’s source code. • Any object can access and modify a private field of another object of the same class. public class Fraction { private int num, denom; ... public multiply (Fraction other) { int newNum = num * other.num; ...

13. Encapsulation • Hiding the implementation details of a class (making all fields and helper methods private) is called encapsulation. • Encapsulation helps in program maintenance: a change in one class does not affect other classes. • A client of a class iteracts with the class only through well-documented public constructors and methods; this facilitates team development.

14. Encapsulation (cont’d) public class MyClass { // Private fields: private <sometype> myField; ... // Constructors: public MyClass (...) { ... } ... // Public methods: public <sometype> myMethod (...) { ... } ... // Private methods: private <sometype> myMethod (...) { ... } ... } Public interface: public constructors and methods

15. Constructors • Constructor primary purpose is to initialize the object’s field. • A class’s constructor define different ways of creating an object. • Different constructor use different numbers or types of parameters • Constructors are not called explicitly, but invoked using the new operator.

16. Constructors • Has the same name as the class. • Default constructor – automatically created by the compiler if no constructors are present. • Default constructor assigns the fields to all default values if they are not initialized. • Default values – integers and real data fields are set to 0. • Objects are set to null • Boolean – are set to false • Constructors do not have a return type

17. Constructor • If a class has more than one constructor, they must have different numbers and/or types of parameters. • Constructors allows you to create a set the fields to their starting values. • One of the constructors will run when an object of the class is created.

18. Constructors (cont’d) • Programmers often provide a “no-args” constructor that takes no parameters (a.k.a. arguments). • If a programmer does not define any constructors, Java provides one default no-args constructor, which allocates memory and sets fields to the default values.

19. Constructors (cont’d) public class Fraction { private int num, denom; public Fraction ( ) { num = 0; denom = 1; } public Fraction (int n) { num = n; denom = 1; } Continued  public Fraction (int n, int d) { num = n; denom = d; reduce (); } public Fraction (Fraction other) { num = other.num; denom = other.denom; } ... } “No-args” constructor Copy constructor

20. Constructors (cont’d) • A nasty bug: public class MyWindow extends JFrame { ... // Constructor: public void MyWindow ( ) { ... } ... Compiles fine, but the compiler thinks this is a method and uses MyWindow’s default no-args constructor instead.

21. Constructors (cont’d) • Constructors of a class can call each other using the keyword this — a good way to avoid duplicating code: public class Fraction { ... public Fraction (int n) { this (n, 1); } ... ... public Fraction (int p, int q) { num = p; denom = q; reduce (); } ...

22. Copy Constructor • Student s1 = new Student(); • Student s2 = new Student(s1); //copy constructor.

23. Notes • Dynamic Memory Allocation – pool of memory that is drawn from and added to as the program is running. • Garbage Collection – When the computer is done with an object, it is put into the garbage collection. • Variables holds a reference (address) to an object of the corresponding type. • It is crucial to initialize a reference before using it.

24. Methods • Methods – defines the behavior of an object, what the object can do. • It represents what an object of a particular type can do in response to a particular call or message.

25. Method Design • An algorithm is a step-by-step process for solving a problem • Examples: a recipe, travel directions • Every method implements an algorithm that determines how the method accomplishes its goals • An algorithm may be expressed in pseudocode, a mixture of code statements and English that communicate the steps to take

26. Method Decomposition • A method should be relatively small, so that it can be understood as a single entity • A potentially large method should be decomposed into several smaller methods as needed for clarity • A public service method of an object may call one or more private support methods to help it accomplish its goal • Support methods might call other support methods if appropriate

27. Accessors and Modifiers • A programmer often provides methods, called accessors, that return values of private fields; methods that set values of private fields are called modifiers (Mutator). • Accessors’ names often start with get, and modifiers’ names often start with set. • These are not precise categories: the same method can modify several fields or modify a field and also return its old or new value.

28. Methods public [or private] returnTypemethodName(type1 name1, ..., typeNnameN) { ... } Body • To define a method: • decide between public and private (usually public) • give it a name • specify the types of parameters and give them names • specify the method’s return type or chose void • write the method’s code Header

29. Methods (cont’d) • A method is always defined inside a class. • A method returns a value of the specified type unless it is declared void; the return type can be any primitive data type or a class type. • A method’s parameters can be of any primitive data types or class types. Empty parentheses indicate that a method takes no parameters public [or private] returnTypemethodName ( ) { ... }

30. Methods: Java Style • A method name starts with a lowercase letter. • Method names usually sound like verbs. • The name of a method that returns the value of a field often starts with get: getWidth, getX • The name of a method that sets the value of a field often starts with set: setLocation, setText

31. Static Fields and methods • Two types of variables • Instance variables – non-static • Class variable – static • Static fields are called static because their memory is not dynamically allocated. Memory for static fields is reserved even before any object of the class have been created. • Static methods are not allowed to access or set any non-static methods of the same class. • Instance methods (non-static) can access and change both static and non-static fields.

32. Static Fields • static fields are shared by all instance of the class. • Example: private static final String letters =“ABCD”; • Static fields are stored separately from instance of the class in a special memory space allocated for the class as a whole.

33. Static fields continued • Static simply saves space in memory. • The code for methods is not duplicated either: all instances of the same class share code for its method. • All final variables should be declared static because there is no reason to duplicate them. • Example: Private static final int sum = 8;

34. Static Fields • A static field (a.k.a. class field or class variable) is shared by all objects of the class. • A non-static field (a.k.a. instance field or instance variable) belongs to an individual object.

35. Static Fields (cont’d) • A static field can hold a constant shared by all objects of the class: • A static field can be used to collect statistics or totals for all objects of the class (for example, total sales for all vending machines) Reserved words: static final public class RollingDie { private static final double slowDown = 0.97; private static final double speedFactor = 0.04; ...

36. Static Fields (cont’d) • Static fields are stored with the class code, separately from instance variables that describe an individual object. • Public static fields, usually global constants, are referred to in other classes using “dot notation”: ClassName.constName double area = Math.PI * r * r; setBackground(Color.BLUE); c.add(btn, BorderLayout.NORTH); System.out.println(area);

37. Static Fields (cont’d) • Usually static fields are NOT initialized in constructors (they are initialized either in declarations or in public static methods). • If a class has only static fields, there is no point in creating objects of that class (all of them would be identical). • Math and System are examples of the above. They have no public constructors and cannot be instantiated.

38. Static Methods • Static methods can access and manipulate a class’s static fields. • Static methods cannot access non-static fields or call non-static methods of the class. • Static methods are called using “dot notation”: ClassName.statMethod(...) double x = Math.random(); double y = Math.sqrt (x); System.exit();

39. Static Methods (cont’d) public class MyClass { public static final int statConst; private static int statVar; private int instVar; ... public static int statMethod(...) { statVar = statConst; statMethod2(...); instVar = ...; instMethod(...); } Static method OK Errors!

40. Static Methods (cont’d) • main is static and therefore cannot access non-static fields or call non-static methods of its class: public class Hello { private int test () { ... } public static void main (String[ ] args) { System.out.println (test ()); } } Error: non-static method test is called from static context (main)

41. Static Methods class Helper { public static int cube (int num) { return num * num * num; } } Because it is declared as static, the method can be invoked as value = Helper.cube(5);

42. Static Class Members • The order of the modifiers can be interchanged, but by convention visibility modifiers come first • Recall that the main method is static – it is invoked by the Java interpreter without creating an object • Static methods cannot reference instance variables because instance variables don't exist until an object exists • However, a static method can reference static variables or local variables

43. OOP Model • OOP program maintains a world of interacting objects • Describe the different types of objects • What they can do • How they are created • How they interact with other objects.

44. Operator new • Constructors are invoked using the operator new. • Parameters passed to new must match the number, types, and order of parameters expected by one of the constructors. public class Fraction { public Fraction (int n) { num = n; denom = 1; } ... • Fraction f1 = new Fraction ( ); • Fraction f2 = new Fraction (5); • Fraction f3 = new Fraction (4, 6); • Fraction f4 = new Fraction (f3); 5 / 1

45. Operator new (cont’d) • You must create an object before you can use it; the new operator is a way to do it. • private Fraction ratio; • ... • ratio = new Fraction (2, 3); • ... • ratio = new Fraction (3, 4); ratio is set to null Now ratio refers to a valid object Now ratio refers to another object (the old object is “garbage-collected”)

46. f1 f1 A Fraction object: num = 3 denom = 7 A Fraction object: num = 3 denom = 7 A Fraction object: num = 3 denom = 7 f2 References to Objects Fraction f1 = new Fraction(3,7); Fraction f2 = f1; Fraction f1 = new Fraction(3,7); Fraction f2 = new Fraction(3,7); f2 Refer to the same object

47. Passing Parameters to Constructors and Methods • Any expression that has an appropriate data type can serve as a parameter: double u = 3, v = -4; ... Polynomial p = new Polynomial (1.0, -(u + v), u * v); double y = p.getValue (2 * v - u); public class Polynomial { public Polynomial (double a, double b, double c) { ... } public double getValue (double x) { ... } ...

48. Passing Parameters (cont’d) • A “smaller” type can be promoted to a “larger” type (for example, int to long, float to double). • int is promoted to double when necessary: ... Polynomial p = new Polynomial (1, -5, 6); double y = p.getValue (3); The same as: (1.0, -5.0, 6.0) The same as: (3.0)

49. Passing Parameters (cont’d) • Primitive data types are always passed “by value”: the value is copied into the parameter. public class Polynomial { ... public double getValue (double u) { double v; ... } } copy double x = 3.0; double y = p.getValue ( x ); u acts like a local variable in getValue x: 3.0 u:3.0 copy

50. Passing Parameters (cont’d) public class Test { public double square (double x) { x *= x; return x; } public static void main(String[ ] args) { Test calc = new Test (); double x = 3.0; double y = calc.square (x); System.out.println (x + " " + y); } } x here is a copy of the parameter passed to square. The copy is changed, but... ... the original x is unchanged. Output: 3 9