1
Object
-
Oriented Software Engineering
CS288
2
Multiple Classes
Contents
•
Defining multiple classes
•
Using objects of one class in another
•
Multiple constructor methods
•
Nested objects
•
Inner classes
•
Infinite nesting error, stack overflow
3
Back to first version of SimpleClass
public class SimpleClass {
private String uselessField;
public SimpleClass (String newFieldVal) {
setUselessField (newFieldVal);
}
public String getUselessField () {
return uselessField;
}
public void setUselessField (String newUselessField) {
uselessField = newUselessField;
}
public static void main (String[ ] args) {
// Add Code Here
}
}
4
The FooClass class
public class FooClass {
private String fieldOfFoo;
public FooClass (String newField) {
setFieldOfFoo(newField);
}
public String getFieldOfFoo ( ) {
return fieldOfFoo;
}
public void setFieldOfFoo (String fieldOfFoo) {
this.fieldOfFoo = fieldOfFoo;
}
}
Note:
NO MAIN METHOD
Otherwise, exactly
same syntax as
SimpleClass
5
The FooClass class
•
The SimpleClass code exists as a
file SimpleClass.java.
The FooClass code exists as a file
FooClass.java.
•
NetBeans conveniently keeps track
that they belong in the same
project for us.
•
For simple projects we only need to
make sure the files live in the same
folder for them to be in the same
project automatically.
•
Each class in the same project is
able to access fields and methods
of the other class where it has
permission.
6
Creating Objects of one Class in Another Class
public static void main (String[ ] args) {
SimpleClass ob1 = new SimpleClass ("Fluffy");
FooClass ob2 = new FooClass("Vote Snooks");
String stVal = ob2.getFieldOfFoo ();
ob1.setUselessField (stVal);
}
Edit main method of
SimpleClass
to create object of
FooClass
7
Executing main method
public static void main (String[ ] args) {
SimpleClass ob1 = new SimpleClass ("Fluffy");
FooClass ob2 = new FooClass("Vote Snooks");
String stVal = ob2.getFieldOfFoo ();
ob1.setUselessField (stVal);
}
FooClass
SimpleClass
When execution gets to here
objects have these values
8
Executing main method
public static void main (String[ ] args) {
SimpleClass ob1 = new SimpleClass ("Fluffy");
FooClass ob2 = new FooClass("Vote Snooks");
String stVal = ob2.getFieldOfFoo ();
ob1.setUselessField (stVal);
}
When execution finishes here
objects have these values
9
Add FooClass field to SimpleClass
Add to SimpleClass a new field of type FooClass.
private FooClass myFoo = new FooClass("Read Books");
This field can be used in main method.
10
New main method for SimpleClass
public static void main (String[ ] args) {
SimpleClass ob1 = new SimpleClass ("Fluffy");
String stVal = ob1.myFoo.getFieldOfFoo( );
ob1.setUselessField (stVal);
}
Note syntax for accessing
methods of field that is itself
an object.
11
Executing main method
public static void main (String[ ] args) {
SimpleClass ob1 = new SimpleClass ("Fluffy");
String stVal = ob1.myFoo.getFieldOfFoo( );
ob1.setUselessField (stVal);
}
When execution gets to here
objects have these values
myFoo is nested inside ob1
12
Executing main method
public static void main (String[ ] args) {
SimpleClass ob1 = new SimpleClass ("Fluffy");
String stVal = ob1.myFoo.getFieldOfFoo( );
ob1.setUselessField (stVal);
}
When execution finishes here
objects have these values
13
Syntax for nested objects
Think of
ob1.myFoo.getFieldOfFoo( );
as
(ob1.myfoo).getFieldOfFoo( );
Hence we could achieve the same effect with:
FooClass tmpObj = ob1.myfoo;
tmpObj. getFieldOfFoo( );
14
Modify main method and test
Change main method to code below. Can see with debugger
in NetBeans that
ob1
is changed exactly as before.
public static void main (String[ ] args) {
SimpleClass ob1 = new SimpleClass ("Fluffy");
// String stVal = ob1.myFoo.getFieldOfFoo( );
// ob1.setUselessField (stVal);
FooClass fooVal = ob1.myFoo;
String stVal = fooVal.getFieldOfFoo ( );
ob1.setUselessField (stVal);
}
15
Infinite Nesting Error
What will happen if we add a new
SimpleClass
field to the
FooClass
as shown
below?
public class FooClass {
private String fieldOfFoo;
private SimpleClass mySimpCls = new SimpleClass("Give it welly");
public FooClass (String newField) {
setFieldOfFoo(newField);
}
public String getFieldOfFoo () {
return fieldOfFoo;
}
public void setFieldOfFoo (String fieldOfFoo) {
this.fieldOfFoo = fieldOfFoo;
}
}
16
Runtime Stack Overflow
running program gives:
Exception in thread "main" java.lang.StackOverflowError
at multipleclassexample.FooClass.<init>(FooClass.java:7)
at multipleclassexample.SimpleClass.<init>(SimpleClass.java:6)
at multipleclassexample.FooClass.<init>(FooClass.java:7)
at multipleclassexample.SimpleClass.<init>(SimpleClass.java:6)
at multipleclassexample.FooClass.<init>(FooClass.java:7)
at multipleclassexample.SimpleClass.<init>(SimpleClass.java:6)
at multipleclassexample.FooClass.<init>(FooClass.java:7)
at multipleclassexample.SimpleClass.<init>(SimpleClass.java:6)
at multipleclassexample.FooClass.<init>(FooClass.java:7)
at multipleclassexample.SimpleClass.<init>(SimpleClass.java:6)
at multipleclassexample.FooClass.<init>(FooClass.java:7)
at multipleclassexample.SimpleClass.<init>(SimpleClass.java:6)
at multipleclassexample.FooClass.<init>(FooClass.java:7)
.............................................
This happens because compiler is trying to create infinitely many objects when we invoke
the
SimpleClass
constructor.
17
Multiple Constructor Methods
The constructor method defines how an object is to be initialised.
That is it defines field values for the object at the point it is created
The FooClass has three fields:
private String fieldOfFoo;
private Integer int_field;
private Boolean bool_field;
It may be that we want to have different ways to create an object
of type FooClass that specify some or no initial values.
Java permits a class to have multiple constructor methods that
do this job.
18
Multiple Constructor Methods
Here are three constructors for FooClass, they are all valid when added
to the FooClass.java file at the same time.
public FooClass (String newField) {
setFieldOfFoo(newField);
int_field = 12;
bool_field = false;
}
public FooClass (String newField, Integer int_field) {
setFieldOfFoo(newField);
this.int_field = int_field;
bool_field = false;
}
public FooClass (String newField, Integer int_field, boolean bool_field) {
setFieldOfFoo(newField);
this.int_field = int_field;
this.bool_field = bool_field;
}
19
Multiple Constructor Methods
class FooClass {
/* field declarations here */
public FooClass (String newField) {
setFieldOfFoo(newField);
int_field = 12;
bool_field = false;
}
public FooClass (String newField, Integer int_field) {
setFieldOfFoo(newField);
this.int_field = int_field;
bool_field = false;
}
public FooClass (String newField, Integer int_field, boolean bool_field) {
setFieldOfFoo(newField);
this.int_field = int_field;
this.bool_field = bool_field;
}
/* and so on */
}
20
Multiple Constructor Methods
For example, within the main method we could write:
FooClass fc1 = new FooClass("Give me strength");
FooClass fc2 = new FooClass("Give me strength", 10);
FooClass fc3 = new FooClass("Give me strength", 7, true);
21
public class SimpleClass {
private String uselessField;
public SimpleClass () {
}
public SimpleClass (String newFieldVal) {
setUselessField (newFieldVal);
}
public String getUselessField () {
return uselessField;
}
public void setUselessField (String newUselessField) {
uselessField = newUselessField;
}
public class SimpleInnerClass {
public String innerField;
public SimpleInnerClass (String newFieldVal) {
innerField = newFieldVal;
}
}
public static void main (String[ ] args) {
// TODO code application logic here
}
}
Inner Classes
Inner Class
Definition lies
within the body
of SimpleClass
22
Declaration For Inner Class
This variation on the
SimpleClass
main method is legal:
public static void main (String[ ] args) {
SimpleClass ob1 = new SimpleClass ();
SimpleInnerClass ob2;
}
It is quite legitimate to declare a variable to be an object of type
SimpleInnerClass
but we must provide a method that allows
us to construct a new object of this class.
The intention is for inner classes to be used only within the
class they are defined in. If we want to have full access to a
class and its methods, then it should be defined as a separate
class.
23
Inner Class can not be directly accessed
We can
not
use an inner class within the main method in the
same way we could use the
FooClass
, which was external to
SImpleClass
.
If we try (as shown below) it will result in compiler error.
The error shown is somewhat misleading.
The
SimpleInnerClass
constructor belongs to an object of class
SimpleClass
. But we have not provided any way to invoke
the constructor from a
SimpleClass
object.
24
Adding Method to create Inner Class
This method, when added to SimpleClass, can be used to create objects
of type
SimpleInnerClass
given a String argument.
public SimpleInnerClass createInnerClassObject (String newStr) {
SimpleInnerClass nwObj = new SimpleInnerClass(newStr);
return nwObj;
}
The main method can now use this to create objects of this type.
public static void main (String[ ] args) {
SimpleClass ob1 = new SimpleClass ();
SimpleInnerClass ob2 = ob1.createInnerClassObject("OK, done");
/* and so on */
}
25
Inner Classes are Not Visible from other Classes
public class SimpleClass {
// Code for fields and methods
public class SimpleInnerClass {
public String innerField;
public SimpleInnerClass (String newFieldVal) {
innerField = newFieldVal;
}
}
}
class DiffClass {
public DiffClass () {
SimpleInnerClass tempObj;
}
}
Trying to declare variable of type
SimpleInnerClass in any other class
leads to compiler errors
26
Summing Up
This lecture discussed
•
Using objects of one class within the main
method of another.
•
Creating an inner class.
•
Discovering stack overflows.
Enter the password to open this PDF file:
File name:
-
File size:
-
Title:
-
Author:
-
Subject:
-
Keywords:
-
Creation Date:
-
Modification Date:
-
Creator:
-
PDF Producer:
-
PDF Version:
-
Page Count:
-
Preparing document for printing…
0%
Comments 0
Log in to post a comment