IT 405: KPLBO MATERI 6A INTERAKSI ANTAR OBJEK IIIAyi 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

INFORMATION HIDING / ACCESSIBILITY

METHOD HEADERS, REVISITED

A method’s access modifier

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

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

THANK YOU