Lecture 4 part 2.pdf

Writing your own class
Phase 2
▪ Objects interacting with other objects
▪ Passing objects to methods
▪ Objects as attributes

Using Objects
Passing objects as parameters to a method.
▪ We know that we can pass primitive variables (int,
float, boolean…) to methods.
▪ What about treating objects as we treat ordinary,
primitive variables? Can we pass objects as arguments
to methods?
float addTwoNumbers(float x, float y) {
return x+y;
}

Using Objects
Returning an object from a method:
▪ We also know that we can return primitive values (int,
float, boolean…) from methods.
▪ What about treating objects as we treat ordinary,
primitive variables? Can we return objects from methods?
float addTwoNumbers(float x, float y) {
return x+y;
}

Using Objects
We can use objects as attributes.
▪ e.g. Equipment that can be loaned out to a student.
Exercise: Create a new Equipment class
Attributes
‒ name
‒ value
‒ Student to whom the equipment
is loaned
Methods
‒ get methods for name and value
‒ Loan equipment to student
• See which student this
equipment is loaned to
• Constructor: set name and value
• Note that because name and value do not change, we can
assigned them at creation and then not give them set
methods.

Using Objects
Attributes
• name
• value
• Student to whom the equipment is loaned
private String name;
private float value;
private Student LoanedTo;

Using Objects
public Equipment(String newName, float val) {
name = newName;
value = val;
}
Methods
• Get methods for name and value
• Loan equipment to student
• See which student this equipment is loaned to

Using Objects
public String getName() {return name;}
public float getValue() {return value;}
Methods

Using Objects
Methods
public void loan(Student s) {LoanedTo = s;}

Using Objects
Methods
public Student getLoanedTo() {return LoanedTo;}

Using Objects
name = newName;
value = val;
}
Methods

Using Objects
public class Equipment {
private String name;
private Student LoanedTo;
private float value;
name = newName;
value = val;
}
}

▪ We can add an BorrowedEquipment attribute to the
Student class, to record if they borrow any equipment:
public class Student {
...
private Equipment BorrowedEquipment;
...
void BorrowEquip(Equipment newEquip) {BorrowedEquipment =
newEquip;}
Equipment getBorrowedEquipment() {return BorrowedEquipment;}
void returnEquip() {BorrowedEquipment = null;}

Summary so far
▪ We can create another class, called Equipment
▪ Equipment has an attribute Student
▪ Equipment has a method that takes Student as an
argument
▪ Let’s now use these classes

Using Objects
▪ In this code, we create a Student object and two
Equipment objects, we loan those equipment objects to
the same student.
public class L4 {
public static void main(String[] args) {
Student s = new Student("Jonathan", "Parker");
Equipment e1 = new Equipment("Multimeter", 149.99f);
Equipment e2 = new Equipment("Oscilloscope", 3499.99f);
e1.loan(s);
e2.loan(s);
}
}

Using Objects
▪ Recall: for an object, the identifier is actually a pointer
(address) to the object
▪ When we pass an object to a method, we are not
passing the actual object – we are passing a reference
to the object to that method.

Creating and returning objects
Creating and returning an object from a method:
▪ We know methods of objects can return objects
▪ Also, methods of objects can also create objects and
return them.
▪ This might be helpful if we want to create an object
based on the current object.
▪ Example: we want to give someone else all the marks
for all the tests, but anonymously i.e. without a name.
▪ We don’t want to change our original object, so we
return a new object with the name removed.

▪ Create a new
Student object with
a blank name
▪ Copy the test marks
across
▪ Return the new
object (remember,
returning a
pointer…)
Student Anonymise() {
Student s_anon = new Student("","");
for (int i = 0; i < testMarks.length; i++)
s_anon.testMarks[i] = testMarks[i];
return s_anon;
}
Notice:
▪ What is being returned?
▪ What type is being returned?

▪ Now to actually use this:
▪ s.Anonymise() creates a Student object, does some stuff to it and
then returns a pointer to that object.
s.setTestMark(75f, 0);
s.setTestMark(93.5f, 3);
s.setTestMark(82.5f, 4);
Student s2 = s.Anonymise();

Local variables
Local variables:
▪ Variables that live inside a method
▪ Not visible to other methods, even in the same class or object.
▪ Avoid using the same name as other attributes in the class or
object.

this keyword
this keyword
▪ There is possible ambiguity between passed variables and
instance variables.
private String firstName;
private String lastName;
//...
void changeName(String firstName, String lastName) {
//Inside this method, what does firstName refer to?
//The class attribute or the first argument?
}
?
?

this keyword
this keyword
▪ What if I declare a local variable to have the same name as an
attribute? Which one is used?
//...
void anotherMethod() {
String firstName = "H";
return firstName;
}
?
?

this keyword
this keyword
▪ The local variable (the passed variable is treated as a local
variable) will be used, not the attribute.
▪ To overcome this, we can use the this keyword to make it
clear we are referring to the attribute.
▪ this is a pointer to the current object.

this keyword
this keyword
void changeName(String firstName, String lastName) {
{*firstName and lastName refer to the local variable.
this.firstName and this.lastName refer to the instance
variable. *}
this.firstName = firstName;
this.lastName = lastName;
}

Overloading
▪ Overloaded functions are distinguished by their method
signature (types of input parameters)
▪ When we use them, the correct overloaded function will be
chosen on the basis of the type of input parameters.
▪ It is very common to overload constructor methods
▪ Recall constructors are simply methods that are run when the
object is created
Overloading
The use of the same method name for different functions.

Overloading
▪ Before:
▪ Example: Now, lets have the option of creating a Student
object and not requiring the user to enter a name.
Student(String defaultFirstName, String defaultLastName){
firstName = defaultFirstName;
lastName = defaultLastName;
testMarks = new float[5];
}

Overloading
▪ Example: Lets have the option of creating a Student object and
not requiring the user to enter a name.
▪ Now add:
Student s = new Student();
Student(){
firstName = "John";
lastName = "Smith";
}
Different input arguments!

Overloading
▪ Example: Lets have the option of creating a Student object and
allowing them to enter the number of tests.
▪ Add even more:
Student s = new Student("Jonathan", "Parker", 10);
Student(String defaultFirstName, String defaultLastName, int NoTests){
testMarks = new float[NoTests];
}

Overloading
▪ For overloaded functions, it will look for the method that
matches the input arguments (method signature) and run
that method. Example:
public class L4 {
...
Student(String defaultFirstName, String defaultLastName){
}
will call:
Two strings
Two strings

Overloading
▪ For overloaded functions, it will look for the method that
matches the input arguments (method signature) and run
that method. Example:
public class L4 {
Student s = new Student();
...
Student(){
firstName = "John";
lastName = "Smith";
}
will call:
No arguments
No arguments

Lecture 4 part 2.pdf

Recommended

Recommended

More Related Content

Similar to Lecture 4 part 2.pdf

Similar to Lecture 4 part 2.pdf (20)

More from SakhilejasonMsibi

More from SakhilejasonMsibi (10)

Recently uploaded

Recently uploaded (20)

Lecture 4 part 2.pdf