Effective Java II - Object Oriented Programming 2 | CMSC 132, Study notes of Computer Science

Download Effective Java II - Object Oriented Programming 2 | CMSC 132 and more Study notes Computer Science in PDF only on Docsity!

CMSC 132:

Object-Oriented Programming II

Effective Java II

Department of Computer Science

University of Maryland, College Park

Effective Java

Collection of tips forprogramming in Java

By Joshua Bloch (Sun)

Quick look at 3 topics(out of 57) 1.^

Duplicate Object Creation 2.

Defensive Copying 3.

Immutable Classes

Slides borrowed fromBloch & adapted

Object Duplication Example

public class Person {

private final Date birthDate; public Person(Date birthDate){

this.birthDate = birthDate; } // UNNECESSARY OBJECT CREATION public boolean bornBefore2000(){

Calendar gmtCal = Calendar.getInstance(

TimeZone.getTimeZone("GMT")); gmtCal.set(2000,Calendar.JANUARY,1,0,0,0); Date MILLENIUM = gmtCal.getTime(); return birthDate.before(MILLENIUM); } }

Object Duplication Example (cont.)

public class Person {

… // STATIC INITIALIZATION CREATES OBJECT ONCE private static final Date MILLENIUM; static {

Calendar gmtCal = Calendar.getInstance(

TimeZone.getTimeZone("GMT")); gmtCal.set(2000,Calendar.JANUARY,1,0,0,0); Date MILLENIUM = gmtCal.getTime(); } public boolean bornBefore2000(){ // FASTER!

return birthDate.before(MILLENIUM); } }

2) Defensive Copying

Java programming language is safe

Immune to buffer overruns, wild pointers, etc… Unlike C, C++

Makes it possible to write robust classes

Correctness doesn’t depend on other modules Even in safe language, requires effort

Defensive Programming

Assume clients will try to destroy invariants

May actually be true More likely – honest mistakes

Ensure class invariants survive any inputs

The Problem – Date is Mutable

// ATTACK INTERNALS OF PERSONDate today = new Date();Person p = new Person(today);today.setYear(78);

// MODIFIES P’S BIRTHDAY!

Constructors can allow invariant to be modified

The Solution – Defensive Copying

public class Person { private final Date birthDate;

// REPAIRED CONSTRUCTOR // DEFENSIVELY COPIES PARAMETERS public Person(Date birthDate){

this.birthDate =

new Date(birthDate.getTime());

} // RETURNS birthDate public Date bday() { return birthDate; } }

Another Important Detail

Use constructor, not clone, to make copies

Necessary because Date class is nonfinal

Attacker could implement malicious subclass

Records reference to each instance in list Provides attacker with access to instance list

…and pass subclass to Person( ) constructor

Another Important Detail (cont.)

Malicious subclass example

public class MaliciousDate extends Date {

public long getTime(){

sendToAttacker(this); return super.getTime(); } public int compareTo(Object o){

sendToAttacker(o); return super.compareTo(o);

}

MaliciousDate

myBad = new MaliciousDate( );

Person p = new Person( mybad );

More Defensive Copying

// REPAIRED ACCESSOR DEFENSIVELY COPY FIELDSpublic class Person {

// RETURNS CLONE (COPY) OF birthDatepublic Date bday() {

return (Date) birthDate.clone( ); } }

Solution – defensive copying in accessors Now Person class is robust!

Defensive Copying Summary

Don’t incorporate mutable parameters intoobject – make defensive copies

Constructors Static factories Pseudo-constructors Mutators

Return defensive copies of mutable fields

Accessors

Real lesson – use immutable components

Eliminates the need for defensive copying

How to Write an Immutable Class

Don’t provide any mutators Ensure that no methods may be overridden Make all fields final Make all fields private Ensure exclusive access to any mutablecomponents

Immutable Fval Class Example

public final class Fval

private final float f; public Fval(float f) {

this.f = f; } // ACCESSORS WITHOUT CORRESPONDING MUTATORS public float value( ) { return f; } // ALL OPERATIONS RETURN NEW Fval public Fval

add(Fval x) {

return new Fval(f + x.f); } // SUBTRACT, MULTIPLY, ETC. SIMILAR TO ADD