August 2, 2014
Hot Topics:
RSS RSS feed Download our iPhone app

Java Advanced Placement Study Guide: Classes, Constructors, Setter Methods, and Getter Methods

  • March 21, 2002
  • By Richard G. Baldwin
  • Send Email »
  • More Articles »

Questions

File JavaAP016.htm


Welcome

This is one in a miniseries of tutorial lessons designed to help you learn the essential features of Java object-oriented programming as identified by The College Board.

Purpose

The purpose of this miniseries is to help you study for the Advanced Placement Examinations designed by the College Board.

Once you understand everything in this miniseries, plus the material in the lessons that I published earlier on Java Data Structures, you should understand the Java programming features that the College Board considers essential for the first two semesters of object-oriented programming education at the university level.

Approach

These lessons provide questions, answers, and explanations designed to help you to understand the subset of Java features covered by the Java Advanced Placement Examinations (as of October, 2001).

Please see the first lesson in the miniseries entitled Java Advanced Placement Study Guide: Introduction to the Lessons, Primitive Types, for additional background information.  The previous lesson was entitled Java Advanced Placement Study Guide:  Method Overloading.

Supplementary material

In addition to the material in these lessons, I recommend that you also study the other lessons in my extensive collection of online Java tutorials, which are designed from a more conventional textbook approach.  You will find those lessons published at Gamelan.com.  However, as of the date of this writing, Gamelan doesn't maintain a consolidated index of my Java tutorial lessons, and sometimes they are difficult to locate there.  You will find a consolidated index at Baldwin's Java Programming Tutorials.

What is Included?

Click here for a preview of the Java programming features covered by this lesson.



1.  What output is produced by the following program?
  • A.  Compiler Error
  • B.  Runtime Error
  • C.  An Object
  • D.  None of the above
public class Ap090{
  public static void main(
                        String args[]){
    new Worker().makeObj();
  }//end main()
}//end class definition

class Worker{
  public void makeObj(){
    NewClass obj = NewClass();
    System.out.println(obj);

  }//end makeObj()


}// end class 

class NewClass{
  public String toString(){
    return "An Object";
  }//end toString()
}//end NewClass

Answer and Explanation

2.  What output is produced by the following program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  An Object
  • D.  None of the above
public class Ap091{
  public static void main(
                        String args[]){
    new Worker().makeObj();
  }//end main()
}//end class definition

class Worker{
  public void makeObj(){
    NewClass obj = new NewClass();
    System.out.println(obj);

  }//end makeObj()

}// end class 

Class NewClass{
  public String toString(){
    return "An Object";
  }//end toString()
}//end NewClass

Answer and Explanation

3.  What output is produced by the following program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  An Object
  • D.  None of the above
public class Ap092{
  public static void main(
                        String args[]){
    new Worker().makeObj();
  }//end main()
}//end class definition

class Worker{
  public void makeObj(){
    NewClass obj = new NewClass();
    System.out.println(obj);

  }//end makeObj()

}// end class 

class NewClass{
  public String toString(){
    return "An Object";
  }//end toString()
}//end NewClass

Answer and Explanation

4.  What output is produced by the following program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  Object containing 2
  • D.  None of the above
public class Ap093{
  public static void main(
                        String args[]){
    new Worker().makeObj();
  }//end main()
}//end class definition

class Worker{
  public void makeObj(){
    NewClass obj = new NewClass();
    System.out.println(obj);
  }//end makeObj()
}// end class 

class NewClass{
  private int x = 2;
  
  public NewClass(int x){
    this.x = x;
  }//end constructor
  
  public String toString(){
    return "Object containing " + x;
  }//end toString()
}//end NewClass

Answer and Explanation

5.  What output is produced by the following program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  Object containing 2
  • D.  None of the above
public class Ap094{
  public static void main(
                        String args[]){
    new Worker().makeObj();
  }//end main()
}//end class definition

class Worker{
  public void makeObj(){
    Subclass obj = new Subclass();
    System.out.println(obj);
  }//end makeObj()
}// end class 

class Superclass{
  private int x;
  
  public Superclass(int x){
    this.x = x;
  }//end constructor
  
  public String toString(){
    return "Object containing " + x;
  }//end toString()
    
  public void setX(int x){
    this.x = x;
  }//end setX()
}//end Superclass

class Subclass extends Superclass{
  public Subclass(){
    setX(2);
  }//end noarg constructor
}//end Subclass

Answer and Explanation

6.  What output is produced by the following program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  Object containing 5
  • D.  Object containing 2
  • E.  None of the above
public class Ap095{
  public static void main(
                        String args[]){
    new Worker().makeObj();
  }//end main()
}//end class definition

class Worker{
  public void makeObj(){
    NewClass obj = new NewClass(5);
    System.out.println(obj);
  }//end makeObj()
}// end class 

class NewClass{
  private int x = 2;
  
  public NewClass(){
  }//end constructor
  
  public NewClass(int x){
    this.x = x;
  }//end constructor
  
  public String toString(){
    return "Object containing " + x;
  }//end toString()
}//end NewClass

Answer and Explanation

7.  What output is produced by the following program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  Object containing 0, 0.0, false
  • D.  Object containing 0.0, 0, true
  • E.  None of the above
public class Ap096{
  public static void main(
                        String args[]){
    new Worker().makeObj();
  }//end main()
}//end class definition

class Worker{
  public void makeObj(){
    NewClass obj = new NewClass();
    System.out.println(obj);
  }//end makeObj()
}// end class 

class NewClass{
  private int x;
  private double y;
  private boolean z;
  
  public String toString(){
    return "Object containing " + 
                          x + ", " + 
                          y + ", " + z;
  }//end toString()
}//end NewClass

Answer and Explanation

8.  What output is produced by the following program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  2
  • D.  5
  • E.  None of the above
public class Ap097{
  public static void main(
                        String args[]){
    new Worker().makeObj();
  }//end main()
}//end class definition

class Worker{
  public void makeObj(){
    NewClass obj = new NewClass(5);
    System.out.println(obj.getX());
  }//end makeObj()
}// end class 

class NewClass{
  private int x = 2;
    
  public NewClass(){
  }//end constructor
  
  public NewClass(int x){
    this.x = x;
  }//end constructor

  public int getX(){
    return x;
  }//end getX()
}//end NewClass

Answer and Explanation

9.  What output is produced by the following program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  10
  • D.  None of the above
public class Ap098{
  public static void main(
                        String args[]){
    new Worker().makeObj();
  }//end main()
}//end class definition

class Worker{
  public void makeObj(){

    NewClass obj = new NewClass();
    obj.setX(10);
    System.out.println(obj.getX());
    
  }//end makeObj()
}// end class 

class NewClass{
  private int y;
 
  public void setX(int y){
    this.y = y;
  }//end setX()

  public int getX(){
    return y;
  }//end getX()
}//end NewClass

Answer and Explanation

10.  What output is produced by the following program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  2
  • D.  5
  • E.  10
  • F.  None of the above
public class Ap099{
  public static void main(
                        String args[]){
    new Worker().makeObj();
  }//end main()
}//end class definition

class Worker{
  public void makeObj(){
    NewClass obj = new NewClass(5);
    obj.x = 10;
    System.out.println(obj.x);
  }//end makeObj()
}// end class 

class NewClass{
  private int x = 2;
    
  public NewClass(){
  }//end constructor
  
  public NewClass(int x){
    this.x = x;
  }//end constructor
  
  public void setX(int x){
    this.x = x;
  }//end setX()

  public int getX(){
    return x;
  }//end getX()
}//end NewClass

Answer and Explanation

What is Included?

According to the subset document,
"Classes: Students are expected to construct objects with the new operator, to supply construction parameters, and to invoke accessor and modifier methods. For the A exam, students are expected to modify existing classes (by adding or modifying methods and instance variables). For the AB exam, students are expected to design their own classes."

Answers and Explanations

Answer 10

A.  Compiler Error

Back to Question 10

Explanation 10

Variables declared private really are private

The code in the following fragment attempts to ignore the setter and getter methods and directly access the private instance variable named x in the object referred to by the reference variable named obj.
 

    obj.x = 10;
    System.out.println(obj.x);

This produces a compiler error.  The compiler error produced by JDK 1.3 is reproduced below.

Ap099.java:19: x has private access in NewClass
    obj.x = 10;
       ^
Ap099.java:20: x has private access in NewClass
    System.out.println(obj.x);
                          ^

Answer 9

C.  10

Back to Question 9

Explanation 9

A setter and a getter

This is a very simple program that uses a setter (modifier or mutator) method named setX() to set the value 10 in a property named x that just happens to be stored in an instance variable named y in an object instantiated from the class named NewClass..

The program also uses a getter (accessor) method named getX() to get and display the value of the property named x.

Answer 8

D.  5

Back to Question 8

Explanation 8

Hide your data and expose your methods

For reasons that I won't go into here, good object-oriented design principles state that in almost all cases where an instance variable is not declared to be final, it should be declared private. (A final variable behaves like a constant.)

What is private access?

When an instance variable is declared private, it is accessible only by methods of the class in which it is defined.  Therefore, the only way that the "outside world" can gain access to a private instance variable is by going through an (usually public) instance method of the object.

Accessor, modifier, mutator, setter, and getter methods

Historically, methods that have been defined for the purpose of exposing private instance variables to the outside world have been referred to as accessor and modifier methods. (Modifier methods are also sometimes called mutator methods.)

(Note that since the advent of Sun's JavaBeans Component design patterns, these methods have also come to be known as getter methods and setter methods in deference to the design-pattern naming conventions for the methods.)
A private instance variable with an initializer

The class named NewClass declares a private instance variable named x and initializes its value to 2, as shown in the following code fragment:
 

  private int x = 2;

Two constructors

The class contains both a noarg constructor and a parameterized constructor as shown in the following fragment:
 

  public NewClass(){
  }//end constructor
  
  public NewClass(int x){
    this.x = x;
  }//end constructor

Invoking the noarg constructor

If an object of the class is instantiated by invoking the noarg constructor, the initial value of 2 remains intact, and that object contains an instance variable with an initial value of 2.

Invoking the parameterized constructor

If an object of the class is instantiated by invoking the parameterized constructor, the initial value of 2 is overwritten by the value of the incoming parameter to the parameterized constructor.  In this case, that value is 5, because the object is instantiated by the following code fragment, which passes the literal value 5 to the parameterized constructor.  Thus, the initial value of the instance variable in that object is 5.
 

    NewClass obj = new NewClass(5);

A getter method

Because the instance variable named x is private, it cannot be accessed directly for display by the code in the makeObj() method of the Worker class.  However, the NewClass class provides the following getter or accessor method that can be used to get the value stored in the instance variable.

(The name of this method complies with JavaBeans design patterns.  If you examine the name carefully, you will see why Java programmers often refer to methods like this as getter methods.)
  public int getX(){
    return x;
  }//end getX()

Invoking the getter method

Finally, the second statement in the following code fragment invokes the getter method on the NewClass object to get and display the value of the instance variable named x.
 

    NewClass obj = new NewClass(5);
    System.out.println(obj.getX());

Answer 7

C.  Object containing 0, 0.0, false

Back to Question 7

Explanation 7

Default initialization values

The purpose of this question is to confirm that you understand the default initialization of instance variables in an object when you don't write code to cause the initialization of the instance variable to differ from the default.

(Although I don't believe that the AP CS exam covers default initialization, I believe that you should understand it anyway if you plan to write Java programs.)


By default, all instance variables in a new object are initialized with default values if you don't provide a constructor (or other mechanism) that causes them to be initialized differently from the default.

  • All instance variables of the numeric types are initialized to the value of zero for the type.  This program illustrates default initialization to zero for int and double types.
  • Instance variables of type boolean are initialized to false.
  • Instance variables of type char are initialized to a 16-bit Unicode character for which all sixteen bits have been set to zero (type char is not included on the AP CS exam).  I didn't include initialization of the char type in the output of this program because the default char value is not printable.
  • Instance variables of reference types are initialized to null.

Answer 6

C.  Object containing 5

Back to Question 6

Explanation 6

A parameterized constructor

This program illustrates the straightforward use of a parameterized constructor.

The class named NewClass defines a parameterized constructor that requires an incoming parameter of type int.

(For good design practice, the class also defines a noarg constructor, even though it isn't actually used in this program.  This makes it available if needed later when someone extends the class.)
Both constructors are shown in the following code fragment.
 
  public NewClass(){
  }//end constructor

  public NewClass(int x){
    this.x = x;
  }//end constructor

The parameterized constructor stores its incoming parameter named x in an instance variable of the class, also named x.

(The use of the keyword this is required in this case to eliminate the ambiguity of having a local parameter with the same name as an instance variable.  Although this syntax is apparently not covered on the AP CS exam, this is very common Java syntax that you should recognize and understand.)
Invoke the parameterized constructor

The following code fragment invokes the parameterized constructor, passing the literal int value of 5 as a parameter.
 

    NewClass obj = new NewClass(5);

Hopefully you will have no difficulty understanding the remaining code in the program that causes the value stored in the instance variable named x to be displayed on the computer screen.

Answer 5

A.  Compiler Error

Back to Question 5

Explanation 5

If you define any constructors, ...

The discussion for a previous question explained that if you define any constructor in a new class, you must define all constructors that will ever be needed for that class.  When you define one or more constructors, the default noarg constructor is no longer provided by the system on your behalf.

The previous question illustrated a simple manifestation of a problem arising from the failure to define a noarg constructor that would be needed later.  The reason that it was needed later was that the programmer attempted to explicitly use the non-existent noarg constructor to create an instance of the class.

A more subtle problem

The problem in this program is more subtle.  Unless you (or the programmer of the superclasses) specifically write code to cause the system to behave otherwise, each time you instantiate an object of a class, the system automatically invokes the noarg constructor on superclasses of that class up to the class named Object.  If one or more of those superclasses don't have a noarg constructor, unless the author of the subclass constructor has taken this into account, the program will fail to compile.

Invoking a non-existing noarg constructor

This program attempts to instantiate an object of a class named Subclass, which extends a class named Superclass.  By default, when attempting to instantiate the object, the system will attempt to invoke a noarg constructor on the superclass.

Superclass has no noarg constructor

The Superclass class defines a parameterized constructor that requires a single incoming parameter of type int.  However, it does not also define a noarg constructor.  Because the parameterized constructor is defined, the default noarg constructor does not exist.  As a result, JDK 1.3 produces the following compiler error:

Ap094.java:40: cannot resolve symbol
symbol  : constructor Superclass  ()
location: class Superclass
  public Subclass(){

Answer 4

A.  Compiler Error

Back to Question 4

Explanation 4

Constructors

Java uses the following kinds of constructors:

  • Those that take arguments, often referred to as parameterized constructors, which typically perform initialization on the new object using parameter values.
  • Those that don't take arguments, often referred to as default or  noarg constructors, which perform default initialization on the new object.
  • Those that don't take arguments but perform initialization on the new object in ways that differ from the default initialization.
Constructor definition is optional

You are not required to define a constructor when you define a new class.  If you don't define a constructor for your new class, a default constructor will be provided on your behalf.  This constructor requires no argument, and it is typically used in conjunction with the new operator to create an instance of the class using statements such as the following:
 

    NewClass obj = new NewClass();

The default constructor

The default constructor typically does the following:

  • Invokes the noarg constructor of the superclass
  • Assists in the process of allocating and organizing memory for the new object
  • Initializes all instance variables of the new object with the following default values:
    • numeric = 0,
      boolean = false,
      char = all zero bits
      reference = null
Are you satisfied with default values?

As long as you are satisfied with the default initialization of all instance variables belonging to the object, there is no need for you to define a constructor of your own.

However, in the event that you have initialization needs that are not satisfied by the default constructor, you can define your own constructor.  Your new constructor may or may not require arguments.  (In case you have forgotten, the name of the constructor is always the same of the name of the class in which it is defined.)

A non-default noarg constructor

If your new constructor doesn't require arguments, you will typically write code that performs initialization in ways that differ from the default initialization.  For example, you might decide that a particular double instance variable needs to be initialized with a random number each time a new object is instantiated.  You could do that with a constructor of your own design that doesn't take arguments by defining the constructor to get initialization values from the random() method of the Math class.

A parameterized constructor

If your new constructor does take arguments, (a parameterized constructor) you can define as many overloaded versions as you need.  Each overloaded version must have a formal argument list that differs from the formal argument list of all of the other overloaded constructors for that class.

(The rules governing the argument list for overloaded constructors are similar to the rules governing the argument list for overloaded methods, which were discussed in a previous lesson.)
Use parameter values for initialization

Typically you will define your parameterized constructors to initialize some or all of the instance variables of the new object using values passed to the constructor as parameters.

What else can a constructor do?

You can also cause your new constructor to do other things if you so choose.  For example, if you know how to do so, you could cause your constructor (with or without parameters) to play an audio clip each time a new object is instantiated.  You could use a parameter to determine which audio clip to play in each particular instance.

The punch line

So far, everything that I have said is background information for this program.  Here is the punch line insofar as this program is concerned.

If you define any constructor in your new class, you must define all constructors that your new class will ever need.
If you define any constructor, the default constructor is no longer provided on your behalf.  If your new class needs a noarg constructor (and it probably does, but that may not become apparent until later when you or someone else extends your class) you must define the noarg version in addition to the other overloaded versions that you define.

A violation of the rule

This program violated the cardinal rule shown above.  It defined the parameterized constructor for the class named NewClass shown below
 

  public NewClass(int x){
    this.x = x;
  }//end constructor

However, the program did not also define a noarg constructor for the NewClass class.

Invoking the noarg constructor

The code in the makeObj() method of the Worker class attempted to instantiate a new object using the following code:
 

    NewClass obj = new NewClass();

Since the class definition didn't contain a definition for a noarg constructor, the following compiler error was produced by JDK 1.3.

Ap093.java:18: cannot resolve symbol
symbol  : constructor NewClass  ()
location: class NewClass
    NewClass obj = new NewClass();
 

Answer 3

C.  An Object

Back to Question 3

Explanation 3

We finally got it right!

Did you identify the errors in the previous two programs before looking at the answers?

This program declares the class named NewClass correctly and uses the new operator correctly in conjunction with the default noarg constructor for the NewClass class to create a new instance of the class (an object).

Making the class public

One of the things that I could do differently to make this program more consistent with the intent of the AP CS exam would be to make the declaration for the NewClass class public (as shown in the following code fragment).
 

public class NewClass{
  public String toString(){
    return "An Object";
  }//end toString()
}//end NewClass

I am a little lazy

The reason that I didn't declare this class public (and haven't done so throughout this series of lessons) is because the source code for all public classes and interfaces must be in separate files.  While that is probably a good requirement for large programming projects, it is overkill for simple little programs like I am presenting in this series of tutorial lessons.

Dealing with multiple files

Therefore, in order to avoid the hassle of having to deal with multiple source code files for every program, I have been using package access for class definitions other than the controlling class (the controlling class is declared public).  Although I won't get into the details at this point, when a class is not declared public, it is common to say that it has package access instead of public access.

Answer 2

A.  Compiler Error

Back to Question 2

Explanation 2

Java is a case-sensitive language

Java keywords must be written exactly as specified.  The keyword class cannot be written as Class, which is the problem with this program.

The inappropriate use of the upper-case C in the keyword Class caused the following compiler error.

Ap091.java:25: 'class' or 'interface' expected
Class NewClass{

The solution to the problem

This problem can be resolved by replacing the first character in the keyword class in the following code fragment with a lower-case character.
 

Class NewClass{
  public String toString(){
    return "An Object";
  }//end toString()
}//end NewClass

Answer 1

A.  Compiler Error

Back to Question 1

Explanation 1

Instantiating an object

There are several ways to instantiate an object in Java:

  • Use the newInstance() method of the class named Class.
  • Reconstruct a serialized object using an I/O readObject() method.
  • Create an initialized array object such as {1,2,3}.
  • Create a String object from a literal string such as "A String".
  • Use the new operator.
Of all of these, the last two are by far the most common.

What you cannot do!

You cannot instantiate a new object using code like the following code fragment that was extracted from this program.
 

    NewClass obj = NewClass();

This program produces the following compiler error:

Ap090.java:18: cannot resolve symbol
symbol  : method NewClass  ()
location: class Worker
    NewClass obj = NewClass();

The solution to the problem

This problem can be solved by inserting the new operator to the left of the constructor as shown in the following code fragment.
 

    NewClass obj = new NewClass();

About the Author

Richard Baldwin is a college professor (at Austin Community College in Austin, TX) and private consultant whose primary focus is a combination of Java and XML. In addition to the many platform-independent benefits of Java applications, he believes that a combination of Java and XML will become the primary driving force in the delivery of structured information on the Web.

Richard has participated in numerous consulting projects involving Java, XML, or a combination of the two.  He frequently provides onsite Java and/or XML training at the high-tech companies located in and around Austin, Texas.  He is the author of Baldwin's Java Programming Tutorials, which has gained a worldwide following among experienced and aspiring Java programmers. He has also published articles on Java Programming in Java Pro magazine.

Richard holds an MSEE degree from Southern Methodist University and has many years of experience in the application of computer technology to real-world problems.

baldwin.richard@iname.com






Comment and Contribute

 


(Maximum characters: 1200). You have characters left.

 

 


Sitemap | Contact Us

Rocket Fuel