Component-Based Software Engineering - Object-Oriented Software Engineering

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.