2/25/19

@NGUYỄN Thị Thu Trang, [email protected] 2

Goals
•  Understand notions, roles and techniques for
OBJECT-ORIENTED LANGUAGE AND THEORY overloading methods and overloading
4. SOME TECHNIQUES IN CLASS BUILDING constructors
•  Object member, class member
Nguyen Thi Thu Trang •  How to pass arguments of functions
[email protected]

3 4

Outline Method recalls

•  Each method has it own signature
1.  Method overloading •  A method signature is composed of:
•  Method’s name
2.  Classifier and constant members •  Number of arguments and their types

3.  Passing arguments to methods

1
 2/25/19

5 6

1.1. Method overloading Method overloading – Example 1

•  Method Overloading: Methods in a class might have the •  Method println() in System.out.println() has
same name but different signatures: 10 declarations with different arguments: boolean,
•  Numbers of arguments are different char[], char, double, float, int, long, Object,
String, and one without argument.
•  If the numbers of arguments are the same, types of
•  Do not need to use different names (for example
arguments must be different
"printString“ or "printDouble“) for each data type
•  Advantages: to be displayed.
•  The same name describes the same task
•  Is easier for developers because they don’t have to
remember too many method names. They remember
only one with the appropriate arguments.

7 8

Method overloading – Example 2 Method overloading – More info.

class MyDate { •  Methods are considered as overloading only if they
int year, month, day;
belong to the same class
public boolean setMonth(int m) { …} •  Only apply this technique on methods describing the
public boolean setMonth(String s) { …} same kind of task; do not abuse
} •  When compiling, compilers rely on number or types of
public class Test{ arguments to decide which appropriate method to call.
public static void main(String args[]){ à If there is no method or more than one method to call,
MyDate d = new MyDate(); an error will be reported.
d.setMonth(9);
d.setMonth(“September”);
}
}

2
 2/25/19

9 10

Discussion
Discussion void prt(String s) { System.out.println(s); }
void f1(char x) { prt("f1(char)"); }
•  Given a following method:
void f1(byte x) { prt("f1(byte)"); }
public double test(String a, int b)
void f1(short x) { prt("f1(short)"); }
•  Let select overloading functions of the given method from
void f1(int x) { prt("f1(int)"); }
the list below::
void f1(long x) { prt("f1(long)"); }
1.  void test(String b, int a)
void f1(float x) { prt("f1(float)"); }
2.  public double test(String a)
void f1(double x) { prt("f1(double)"); }
3.  private int test(int b, String a)
•  What will happens if we do as follows:
4.  private int test(String a, int b)
•  f1(5);
5.  double test(double a, int b)
•  char x=‘a’; f1(x);
6.  double test(int b)
•  byte y=0; f1(y);
7.  public double test(String a, long b)
•  float z = 0; f1(z);

11 12

Discussion 1.2. Constructor overloading

void prt(String s) { System.out.println(s); }
•  In different contexts => create objects in different ways
void f2(short x) { prt("f3(short)"); }
à Any number of constructors with different parameters
void f2(int x) { prt("f3(int)"); }
(following constructor overloading principles)
void f2(long x) { prt("f5(long)"); }
•  Constructors are commonly overloaded to allow for
void f2(float x) { prt("f5(float)"); }
different ways of initializing instances
•  What will happen if we do as follows:
•  f2(5);
•  char x=‘a’; f2(x);
•  byte y=0; f2(y);
•  float z = 0; f2(z);
•  What will happen if we call f2(5.5)?

3
 2/25/19

13 14

Example this keyword

public class BankAccount{ •  “this” refers to the current object, it is used inside the class
private String owner; of the object that it refers to.
private double balance; •  It uses attributes or methods of object through “.”
public BankAccount(){owner = “noname”;}
operator, for example:
public BankAccount(String o, double b){
owner = o; balance = b; public class BankAccount{
} private String owner;
} public void setOwner(String owner){
public class Test{ this.owner = owner;
public static void main(String args[]){ }
BankAccount acc1 = new BankAccount(); public BankAccount() { this.setOwner(“noname”); }
BankAccount acc2 = …
new BankAccount(“Thuy”, 100); }
} •  Call another constructor of the class:
} •  this(danh_sach_tham_so); //neu co tham so

15 16

•  Example
public class Ship { //(cont.)
private double x=0.0, y=0.0 private double degreeToRadian(double degrees) {
private double speed=1.0, direction=0.0; return(degrees * Math.PI / 180.0);
public String name; }
public void move() {
public Ship(String name) { move(1);
this.name = name; }
} public void move(int steps) {
public Ship(String name, double x, double y) { double angle = degreesToRadians(direction);
this(name); this.x = x; this.y = y; x = x + (double)steps*speed*Math.cos(angle);
}
y = y + (double)steps*speed*Math.sin(angle);
public Ship(String name, double x, double y,
double speed, double direction) { }
this(name, x, y); public void printLocation() {
this.speed = speed; System.out.println(name + " is at ("
this.direction = direction; + x + "," + y + ").");
} }
//to be continued… } //end of Ship class

4
 2/25/19

17 18

Outline 2.1. Constant members

•  An attribute/method that can not change its values/content
during the usage.
1.  Method overloading •  Declaration syntax:
access_modifier final data_type
2.  Classifier and constant members CONSTANT_VARIABLE = value;
3.  Passing arguments to methods •  For example:
final double PI = 3.141592653589793;
public final int VAL_THREE = 39;
private final int[] A = { 1, 2, 3, 4, 5, 6 };

19 20

2.1. Constant members (2) 2.2. Classifier members

•  Typically, constants associated with a class are declared as •  Members may belong to either of the following:
static final fields for easy access
•  The whole class (class variables and methods,
•  A common convention is to use only uppercase letters in their names
indicated by the keyword static in Java)
•  Individual objects (instance variables and methods)
•  Static attributes and methods belong to the class
•  Changing a value in one object of that class changes
the value for all of the objects
•  Static methods and fields can be accessed
without instantiating the class
•  Static methods and fields are declared using the static
keyword

5
 2/25/19

22

Instance member vs. Classifier member

Static parts: are shared between all objects

valCount
2
val1 val2

value value

23 24

Static members in Java Example: Class JOptionPane in javax.swing

•  Regular members are members of objects
•  Attributes
•  Class members are declared as static
•  Syntax for declaring static member:
access_modifier static data_type varName;
•  Example:

•  Methods:

6
 2/25/19

25 26

Example – using static attributes and methods in Example – using static attributes and methods
class JOptionPane in class JOptionPane (2)
JOptionPane.showMessageDialog(null,”Ban da thao tac Object[] options = { "OK", "CANCEL" };
loi", "Thong bao loi", JOptionPane.ERROR_MESSAGE);
JOptionPane.showOptionDialog(null,"Nhan OK de tiep tuc",
"Canh bao", JOptionPane.DEFAULT_OPTION,
JOptionPane.WARNING_MESSAGE,null,options,options[0]);

JOptionPane.showConfirmDialog(null,"Ban co chac chan

muon thoat?", "Hay lua chon",
JOptionPane.YES_NO_OPTION);

27 28

Example 1
Static member (2) class TestStatic{
•  Modifying value of a static member in an object will public static int iStatic;
modify the value of this member in all other objects of the public int iNonStatic;
}
class.
public class TestS {
•  Static methods can access only static attributes and public static void main(String[] args) {
can call static methods in the same class. TestStatic obj1 = new TestStatic();
obj1.iStatic = 10; obj1.iNonStatic = 11;
System.out.println(obj1.iStatic+”,”+obj1.iNonStatic);
TestStatic obj2 = new TestStatic();
System.out.println(obj2.iStatic+”,”+obj2.iNonStatic);
obj2.iStatic = 12;
System.out.println(obj1.iStatic+”,”+obj1.iNonStatic);
}
}

7
 2/25/19

29

Java static methods – Example

Example 2 class MyUtils {
. . .
public class Demo { //===================== mean
public static double mean(int[] p) {
int i = 0; int sum = 0;
void increase(){ i++; } for (int i=0; i<p.length; i++) {
sum += p[i];
public static void main(String[] args) { }
return ((double)sum) / p.length;
increase(); }
System.out.println("Gia tri cua i la" + i); . . .
}
} …
}
// Calling a static method from outside of a class
double avgAtt = MyUtils.mean(attendance);

32

When static? Outline

1.  Method overloading

2.  Classifier and constant members
3.  Passing arguments to methods

8
 2/25/19

34

3. Arguments passing to methods 3.1. Variable arguments

•  We can use any data types for arguments for •  An arbitrary number of arguments, called varargs
methods or constructors •  Syntax in Java:
•  Primi5ve data types •  methodName(data_type... parameterName)
•  Example
•  References: array and object
•  Declara5on:
•  Example: public PrintStream printf(String format,
public Polygon polygonFrom(Point[] Object... args)
corners){ •  Usage:
System.out.printf ("%s: %d, %s\n",
// method body goes here
name, idnum, address);
} System.out.printf ("%s: %d, %s, %s, %s\n",
name, idnum, address, phone, email);

• Example
public Polygon polygonFrom(Point... corners) {
int numberOfSides = corners.length;
3.2. Passing by values
double squareOfSide1, lengthOfSide1; •  C++
squareOfSide1 = (corners[1].x - corners[0].x)
•  Passing values, pointers
*(corners[1].x - corners[0].x)
+(corners[1].y - corners[0].y) •  Java
*(corners[1].y - corners[0].y) ; •  Passing values
lengthOfSide1 = Math.sqrt(squareOfSide1);
//create & return a polygon connecting the Points
}

•  corners is considered as an array
•  You can pass and array or a sequence of arguments

9
 2/25/19

37

Java: Pass-by-value for all types of data Discussion:

•  Java passes all arguments to a method in form of pass-
• What will happen if:
by-value: Passing value/copy of the real argument
•  For arguments of value-based data types (primitive data types): •  We modify the internal state of object
passing value/copy of primitive data type argument parameters inside a method?
•  For argument of reference-based data types (array and object):
•  We modify the reference to an object?
passing value/copy of original reference.
à Modifying formal arguments does not effect the real
arguments

39 40

a. With value-based date type b. With reference-based data type

•  Primitive values can not be changed when being passed
as a parameter •  Pass the references by value, not the original
reference or the object

•  Is this swap method correct?

public void swap(int var1, int var2) {
int temp = var1;
var1 = var2;
var2 = temp; •  After being passed to a method, a object has at least
} two references

10
 2/25/19

42

Passing parameters For example

public class ParameterModifier
{ public class Point {
public void changeValues (int f1, Num f2, Num f3) private double x;
{ private double y;
System.out.println ("Before changing the values:");
public Point() { }
System.out.println ("f1\tf2\tf3");
System.out.println (f1 + "\t" + f2 + "\t" + f3 + "\n"); public Point(double x, double y) {
this.x = x; this.y = y;
f1 = 999; }
f2.setValue(888);
f3 = new Num (777);
public void setX(double x) { this.x = x; }
public void setY(double y) { this.y = y; }
System.out.println ("After changing the values:"); public void printPoint() {
System.out.println ("f1\tf2\tf3"); System.out.println("X: " + x + " Y: " + y);
System.out.println (f1 + "\t" + f2 + "\t" + f3 + "\n");
} }
} }

43 44

public class Test {

public static void tricky(Point arg1, Point arg2) {
arg1.setX(100); arg1.setY(100); •  Only the method
Point temp = arg1; references are swap,
arg1 = arg2; arg2 = temp; not the original
} references
public static void main(String [] args) {
Point pnt1 = new Point(0,0);
Point pnt2 = new Point(0,0);
pnt1.printPoint(); pnt2.printPoint();
System.out.println(); tricky(pnt1, pnt2);
pnt1.printPoint(); pnt2.printPoint();
}
}

11