using final we use the notion of constant data to represent data that cannot be changed. public...

Using finalUsing final

We use the notion of We use the notion of constant dataconstant data to represent data that to represent data that cannot be changed.cannot be changed.

public class Testpublic class Test

{{

static final int someInt = 10;static final int someInt = 10;

//…//…

someInt = 9; someInt = 9; // // ERRORERROR

//…//…

}}


What happens when we want a constant What happens when we want a constant objectobject??

public class Circle {public class Circle {

private double radius;private double radius;

public Circle(double r) {public Circle(double r) {

radius = r;radius = r;

}}

public void setRadius(double r) {public void setRadius(double r) {

radius = r;radius = r;

}}

public double getRadius() { public double getRadius() {

return radius; return radius;

}}

}}

Using FinalUsing Final

public class FinalTestpublic class FinalTest

{{

private static final Circle wheel = new Circle(5.0);private static final Circle wheel = new Circle(5.0);

public static void main(String[] args) {public static void main(String[] args) {

System.out.println(“radius is “ + wheel.getRadius());System.out.println(“radius is “ + wheel.getRadius());

wheel.setRadius(7.4);wheel.setRadius(7.4);

System.out.println(“now the radius is “ + System.out.println(“now the radius is “ +

wheel.getRadius());wheel.getRadius());

}}

}}


The output of the code is:The output of the code is:

radius is 5.0radius is 5.0

now the radius is 7.4now the radius is 7.4

How can the wheel object change values when we How can the wheel object change values when we specifically declared it final???specifically declared it final???

We did not change the We did not change the valuevalue of the variable wheel. of the variable wheel.

We changed the We changed the content of the objectcontent of the object that wheel references. that wheel references.


What if we try the following code:What if we try the following code:

public class FinalTestpublic class FinalTest

{{

private static final Circle wheel = new Circle(5.0);private static final Circle wheel = new Circle(5.0);

public static void main(String[] args) {public static void main(String[] args) {

System.out.println(“radius is “ + wheel.getRadius());System.out.println(“radius is “ + wheel.getRadius());

wheel = new Circle(7.4) ;wheel = new Circle(7.4) ;

System.out.println(“now the radius is “ + System.out.println(“now the radius is “ +

wheel.getRadius());wheel.getRadius());

}}

}}


Compiling this code results in what we expect:Compiling this code results in what we expect:

FinalTest.java:9: Can’t assign a value to a final variable: wheelFinalTest.java:9: Can’t assign a value to a final variable: wheel

wheel = new Circle(7.4);wheel = new Circle(7.4);

^̂

1 error1 error

There is an error because we are attempting to modify There is an error because we are attempting to modify the reference which was defined as final.the reference which was defined as final.• The reference is final and thus immutable.The reference is final and thus immutable.• The object itself is not affect and thus is mutable.The object itself is not affect and thus is mutable.

Arrays vs. VectorsArrays vs. Vectors

• Java provides two constructs, an array and a Vector, Java provides two constructs, an array and a Vector,

which appear to be similar.which appear to be similar.• In fact, the array and Vector are altogether different.In fact, the array and Vector are altogether different.• It is important to understand the differences between It is important to understand the differences between

the two, in order to write efficient code.the two, in order to write efficient code.

Arrays summaryArrays summary

• Arrays have fixed size - after creating an array, you Arrays have fixed size - after creating an array, you cannot add more elements than its maximum size. If cannot add more elements than its maximum size. If you do, you will get an you do, you will get an ArrayIndexOutOfBoundsExceptionArrayIndexOutOfBoundsException

• In Java, arrays are objects, so any methods contained In Java, arrays are objects, so any methods contained in java.lang.Object can be invoked on them.in java.lang.Object can be invoked on them.

• In order to find the length of the array, use the public In order to find the length of the array, use the public variable variable lengthlength..

int[] ia = new int[N];int[] ia = new int[N];

System.out.println(“ia length is “ + ia.length);System.out.println(“ia length is “ + ia.length);

Arrays summaryArrays summary

• Arrays can hold both primitive types and object Arrays can hold both primitive types and object

references.references.

Default values are used for each entry, based on its type.Default values are used for each entry, based on its type.

TypeType Default valueDefault value

booleanboolean falsefalse

charchar ‘‘\u0000’\u0000’

shortshort 00

intint 00

longlong 00

floatfloat 0.00.0

doubledouble 0.00.0

object referenceobject reference nullnull

Vectors summaryVectors summary

• An Vector grow its size dynamically when more An Vector grow its size dynamically when more

elements are added than its current size can elements are added than its current size can

accommodate.accommodate.• As elements get deleted, each element with an index As elements get deleted, each element with an index

greater than the index being removed is shifted greater than the index being removed is shifted

downward.downward.• Unlike arrays, you call a Unlike arrays, you call a methodmethod on a Vector to on a Vector to

determine its size.determine its size.

Vector v = new Vector();Vector v = new Vector();

System.out.println(“v length is “ + v.size());System.out.println(“v length is “ + v.size());


• The Vector’s size measures the number of elements it The Vector’s size measures the number of elements it

holds.holds.

Thus, the Vector’s size may vary, unlike the array’s Thus, the Vector’s size may vary, unlike the array’s

size which is fixed.size which is fixed.• A vector is implemented in terms of an array of A vector is implemented in terms of an array of

java.lang.Object.java.lang.Object.

That is, when it grows, or shrinks, the entire array That is, when it grows, or shrinks, the entire array

must be reallocated and copied.must be reallocated and copied.

This may cause performance problems if Vectors are This may cause performance problems if Vectors are

not used properly.not used properly.


• Finally, a Vector may contain only Finally, a Vector may contain only object referencesobject references an an

not primitive types.not primitive types.

Vector v = new Vector();Vector v = new Vector();

v.add(new Turtle()); v.add(new Turtle()); // OK// OK

v.add(5); v.add(5); // // ERRORERROR

Integer i = new Integer(5);Integer i = new Integer(5);

v.add(i);v.add(i); // OK// OK

Arrays vs. VectorsArrays vs. Vectors

If you are working with a primitive type, consider using If you are working with a primitive type, consider using an array instead of Vector.an array instead of Vector.

Support Support for for

primitive primitive typestypes

Support Support for objectsfor objects

Auto sizeAuto size fastfast

ArrayArray YesYes YesYes NoNo YesYes

VectorVector NoNo YesYes YesYes NoNo

Memory ManagementMemory Management

• Java provides an automatic memory management with its garbage collection.

• For this reason, free and delete are unnecessary.• This may lead some programmers to ignore memory issues.• The garbage collector frees memory held by an object only if

the object is no longer being referenced.

Turtle one = new Turtle();

Turtle two = one;one two

one = null;

two = null;

Oops, killing turtles is

against the law

15


• There are many implementation for the garbage collection algorithm as there are numerous JVMs.

• Multiple invocations might be needed to reclaim an unreferenced object.

Runtime rt = Runtime.getRuntime();

long mem = rt.freeMemory();

System.out.println(“Free memory is: “ + mem);

//…

System.gc();

//…

mem = rt.freeMemory();

System.out.println(“Free memory is now: “ + mem);

16


• Problems can arise when objects contain instance variables that is initialized in the constructor and consumes large amounts of memory:

public class Customers {

private int[] cusIdArray;

public Customers(String filename) {

int num = // read amount from file

cusIdArray = new int[num];

for (int i=0; i<num; i++)

cusIdArray[i] = // value from the file

}

}


• Suppose we want to display all the ids to the screen:

public class Display {

public static void main(String[] args) {

Customers cust = new Customers();

// display the ids to the screen

// Customers object is no longer needed.

//…

// the rest of the application

}

}

Assume there are 20,000 different customers !!!


• One solution is to set the local variable cust to null, after it is used.

public class Display {

public static void main(String[] args) { Customers cust = new Customers(); // display the ids to the screen // Customers object is no longer needed. //… cust = null; // the rest of the application }}


• What if you need to keep the cust object, but have limited use for the cusIdArray, after it is displayed ?

The solution above works, but has a potential negative implications. We may need to handle the case that the array is needed but no longer valid.

public class Customers {

// … same code as above

public void resetCust() {

cusIdArray = null;

}

}

public static void main(String[] args) { Customers cust = new Customers(); // display the ids to the screen // Customers object is no longer needed. //… cust.resetCust(); // the rest of the application}

Objects and EqualityObjects and Equality

• Java provides two different types: reference types and primitives. In addition wrapper classes are provided for each primitive type.

Primitive TypePrimitive Type Wrapper classWrapper class

booleanboolean BooleanBoolean

charchar CharacterCharacter

bytebyte ByteByte

shortshort ShortShort

intint IntegerInteger

longlong LongLong

floatfloat FloatFloat

doubledouble DoubleDouble


• References and primitives behave altogether differently and have different semantics.

int i = 5;

Integer j = new Integer(10);

• Both primitives and references are stored and manipulated on the Java operand stack.

• Objects are stored in memory heap.

jj

5 // i’s value5 // i’s value

stack heap

Integer10


• Using a primitive type eliminates the need to call new and create an object - this saves time and space.

• Mixing primitives and objects can also create unexpected results with regard to assignment.

int a = 1;

int b = 2;

Point x = new Point(0,0);

Point y = new Point(1,1);

System.out.println(“a is “ + a);

System.out.println(“b is “ + b);

System.out.println(“x is “ + x);

System.out.println(“y is “ + y);


// performing assignment and setLocation

a = b;

a++;

x = y;

x.setLocation(5,5);

System.out.println(“a is “ + a);

System.out.println(“b is “ + b);

System.out.println(“x is “ + x);

System.out.println(“y is “ + y);


The output for the code is:

a is 1

b is 2

x is java.awt.Point[x=0,y=0]

y is java.awt.Point[x=1,y=1]

a is 3

b is 2

x is java.awt.Point[x=5,y=5]

y is java.awt.Point[x=5,y=5] y has also changed!


Point(0,0)

Point(1,1)

x

y

Point x = new Point(0,0);

Point y = new Point(1,1);

Point(0,0)

Point(1,1)

x

y

x = y;

Point(0,0)

Point(5,5)

x

y

x.setLocation(5,5);

Differentiate between == and Differentiate between == and equalsequals

What is the difference between the == operator and the equals method? Isn’t == good enough?

Public class Test{ public static void main(String[] args) { int a = 10; int b = 10; System.out.println(“a==b is “ + (a==b)); Integer ia = new Integer(10); Integer ib = new Integer(10); System.out.println(“ia==ib is “ + (ia==ib)); }}


The output for this code is:

a==b is true

ia==ib is false

What went wrong?

• a and b are of type int, and as such, they are of primitive

type.• ia and ib are object references and reference Integer

objects.


• a and b have the same value of 10.• The object references, ia and ib are really references to

two different Java Integer Objects that have the value 10. • The values of ia and ib are not 10 but rather unique

values that represent the two objects.

The == operator tests for equality. Is the thing on the

left-hand side of the == the same as the thing on the

right-hand side?

How do you test to see whether the values referenced by ia and ib are equal? This is where you use the equals method.

using final we use the notion of constant data to represent data that cannot be changed. public...

Documents

wheel wheel

getradius wheel

wheel object

variable wheel

r radius

public double getradius

final variable

final public class finaltest