IT 405: KPLBO M ATERI 6 A I NTERAKSI A NTAR O BJEK III Ayi Purbasari, ST., MT. If-Unpas, 2014.
-
Upload
anthony-hardy -
Category
Documents
-
view
215 -
download
1
Transcript of IT 405: KPLBO M ATERI 6 A I NTERAKSI A NTAR O BJEK III Ayi Purbasari, ST., MT. If-Unpas, 2014.
METHOD INVOCATION
Information Hiding /
Accessibility
Accessor Methods
Constructor
Constructor
Overloading
INFORMATION HIDING / ACCESSIBILITY Public Accessibility
public class Student {public String name;// etc.
public class MyProgram {public static void main(String[] args) {
Student x = new Student();// Because name is a public attribute of the Student class, we may access// it via dot notation from client code.x.name = "Fred Schnurd"; // assign a value to x's name attribute// or:System.out.println(x.name); // retrieve the value of x's name attribute// etc.
}
}
INFORMATION HIDING / ACCESSIBILITY
Private Accessibilitypublic class Student {
public String name;private String ssn;// etc.
public class MyProgram {public static void main(String[] args) {
Student x = new Student();// Not permitted from client code! ssn is private to the// Student class, and so this will not compile.x.ssn = "123-45-6789";// etc.
The resultant error message would bessn has private access in Student
INFORMATION HIDING / ACCESSIBILITY The same is true for methods that are declared to be
privatepublic class Student {
// Attribute details omitted from this example.// Methods.public boolean isHonorsStudent() { ... }private void printInfo() { ... }// etc.
}public class MyProgram {
public static void main(String[] args) {Student x = new Student();// Because printInfo() is a private method, we may not access it// via dot notation from client code; this won't compile:x.printInfo();// etc.
The resultant error message would beprintInfo() has private access in Student
ACCESSING PRIVATE FEATURES FROM CLIENT CODE
A “set” method is used to pass data into an object.
A “get” method is used to retrieve data from an object.
ACCESSOR METHODS
For a “get” method, the formula is as follows:public attribute-type getAttributeName()
for example,public String getMajorField()
For a “set” method, the formula is as follows:public void setAttributeName(attributeType parameterName)
for example,public void setMajorField(String major)
CONTOH PENGGUNAAN
public class Student {private String name;private String ssn;private String major;private Professor advisor;// etc.// Set/get methods provided; details omitted.public void assignMajor(String m, Professor p) {
// Not as desirable.this.major = m;this.advisor = p;
}// etc.
CONSTRUCTORS
Student x = new Student(); It turns out that when we instantiate an
object via the new keyword, we’re actually invoking a special type of procedure called a constructor. Invoking a constructor serves as a request to the JVM to construct (instantiate) a brand-new object at run time by allocating enough program memory to house the object’s attributes.
DEFAULT CONSTRUCTOR
Constructor: Default Constructor Writing Our Own Explicit Constructors
If we don’t explicitly declare any constructors for a class, Java automatically provides a default constructor for that class.
The default constructor is parameterless—that is, it takes no arguments— and does the “bare minimum” required to initialize a new object: namely, setting all attributes to their zero-equivalent default values.
WRITING OUR OWN EXPLICIT CONSTRUCTORS
A constructor’s name must be exactly the same as the name of the class for which we’re writing the constructor—we have no choice in the matter.
A parameter list, enclosed in parentheses, is provided for a constructor header as with method headers.
We cannot specify a return type for a constructor; by definition, a constructor returns a reference to a newly created object of the type represented by the class to which the constructor belongs.
PASSING ARGUMENTS TO CONSTRUCTORS
public class Student {// Attributes.private String name;private String ssn;private String major;// etc.// We've declared a constructor that accepts three arguments, to accommodate// passing in three attribute values.public Student(String s, String n, String m) {
this.setName(n);this.setSsn(s);this.setMajor(m);
}
// etc.
REPLACING THE DEFAULT PARAMETERLESS CONSTRUCTOR
public class Student {// Attributes.private String name;private String major;// etc.// We've explicitly programmed a parameterless constructor, // thus replacing the default version.public Student() {
// Perhaps we wish to initialize attribute values to something other than// their zero equivalents.this.setName("?");this.setMajor("UNDECLARED");
}// etc. // Other methods omitted from this example.
}
OVERLOADING CONSTRUCTORS
public class Student {private String name;private String ssn;private int age;// etc.// Constructor #1: takes no arguments; supercedes the default constructor.public Student() {}// Assign default values to selected attributes, if desired.// this.setSsn("?");// Those that aren't explicitly initialized in the constructor // will automatically assume the zero-equivalent value for their respective type.
OVERLOADING CONSTRUCTORS
// Constructor #2: takes a single String argument.public Student(String s) {
this.setSsn(s);
}
// Constructor #3: takes two Strings and an int as // arguments.public Student(String s, String n, int i) {
this.setSsn(s);this.setName(n);this.setAge(i);
}
// Other methods omitted from this example.
}
THE USE OF ALL THREE FORMS OF STUDENT CONSTRUCTOR
// We don't know ANYTHING about our first student, // so we use the parameterless constructor to instantiate s1.Student s1 = new Student();// We know the ssn (only) for our second student, and // so we use the second form of constructor to // instantiate s2.Student s2 = new Student("123-45-6789");// We know the ssn, name, and age of our third // student, and so we use the third form of constructor // // to instantiate s3.Student s3 = new Student("987-65-4321", "John Smith", 21);
THE USE OF ALL THREE FORMS OF STUDENT CONSTRUCTOR
As with overloaded methods, the compiler is able to unambiguously match up which version of constructor is being invoked in each case based on the argument signatures: (): No arguments tells the compiler that we are
invoking constructor #1. ("123-45-6789"): One String argument tells the
compiler that we are invoking constructor #2. ("987-65-4321", "John Smith", 21): Two Strings
and an int as arguments tell the compiler that we are invoking constructor #3.
21
Author: H
endra Kom
ara
REFERENSI
Beginning Java Object: From Concept to Code. Author: JACQUIE BARKER
SoftwareEngineering: A Practitioner Approach 7th Edition. Author: Roger S Pressman