Java Programming Review (Part I) Enterprise Systems Programming.

Java Programming Review(Part I)

Enterprise Systems Programming

Outline Java programs and packages Classes, fields, methods, objects Naming conventions Types, variables, parameters Arrays Inheritance, interfaces Exceptions Files and streams Static fields and methods Java core packages, collection classes Generics, auto-boxing Inner classes

Java programs A Java program is a collection of classes Each class is specified in a separate file

Source file carries a .java extension Compiled program carries a .class extension

Compilation through the java development kit (JDK) Via the command line: javac ClassName.java

(produces ClassName.class) Through an IDE such as Eclipse or JCreator

Execution requires a Java virtual machine

Java program execution Standalone java programs execute through a run

time environment(the Java VM) Via the command-line: java ClassName Requires ClassName.class ClassName must have a main method

(entry point) but may make use of other java classes Applets and Servlets

Virtual machine resides in browsers or servers Java execution is automatic and triggered by events

Java packages A package is a set of Java classes Packages are Java’s way of organizing its classes

into modules or namespaces Manages complexity and naming conflicts

Classes in a package share increased visibility rules

Packages follow a hierarchical structure and naming pattern e.g., java.awt.event

Classes import classes from outside packages e.g., import java.util.*;

Classes and filenames,packages and folder names The name of a Java class must match the name of

the source file that defines it

This Java source file mustbe named MyClass.java

If it is part of a named package, it should reside in a folder that follows the same hierarchy as its package name

WelcomeServlet.java should reside in a folder named myservlets

public class MyClass{ …}

package myservlets;public class WelcomeServlet{ …}

Class definition in Java

BankAccount Type (or class)

State/attributes (fields)

Behavior (methods)

Code for object creation(usually) done outsideof this class

public class BankAccount{ private double balance = 0;

public double getBalance() { return balance; }

public void deposit( double amount ) { balance = balance + amount; } …}

BankAccount.java

A Class with a constructors

public class BankAccount{ private double balance;

public BankAccount() { balance = 0; } public BankAccount( double initBal ) { balance = initBal; }

public double getBalance() { return balance; } public void deposit( double amount ) { balance = balance + amount; } …}

BankAccount.java

Constructor: special method that handles initialization

Constructor name must match the name of class

In this example, creation of bank account objects may indicate an initial balance

Object creation and method invocation

public class TestAccounts{

public static void main( String args[] ){ BankAccount b = new BankAccount(); BankAccount x = new BankAccount( 5000.00 ); b.deposit( 1000.00 ); b.withdraw( 100.00 ); System.out.println( b.getBalance() ); x.deposit( 2000.00 ); b.deposit( 2000.00 ); System.out.println( b.getBalance() ); System.out.println( x.getBalance() );}

}

TestAccounts.java Object creation done through the new keyword

Method invocation done through the dot notation

object.method( params )

Java naming conventions Class names

Start with a capital letter, capitalize first letters of succeeding words

Examples: BankAccount, MyClass, WelcomeServlet Variable and method names

Start with a lowercase letter, capitalize first letters of succeeding words

aka “camelCase” Examples: balance, firstName, favoriteNumber

Following these conventions make your programs easier to read!

Types in Java Primitive types: one of the 8 built-in types in Java

int, double, long, short, byte, float, char, boolean Variables of primitive types hold values acceptable

under these types Object types: classes

Some of these types are “built-in” (present in the Java library) such as String or System, the rest are user-defined such as BankAccount or WelcomeServlet

Variables of object types hold references to objects

Variables for built-in types Variables for built-in types

int x; …x = 5;

5

x

x

Variables for object types Object (reference) type variables

BankAccount x; …x = new BankAccount( 1000 );

x

x

balance:1000

BankAccount Object

Variables and assignment Primitive variables

int x, y;x = 1000;y = x;y++;// at this point, x = 1000, y = 1001

Object variables BankAccount x, y;

x = new BankAccount( 1000 );y = x;y.deposit( 1 );// at this point, x.getBalance() is 1001,// y.getBalance() is 1001

xbalance:

1001

y

1000

x

1001

y

Parameter passing BankAccount b = new BankAccount(100);

int x = 100;changeAccount( b ); // update of b possiblechangeNumber( x ); // update of x not possible…void changeAccount( BankAccount c ){ c.deposit( 10 ); // b and c point to the same object }void changeNumber( int y ){ y = y + 10; // y changes, but x does not}

In the above code, since b is a reference to an object, that object could be changed by the method.

The same does not hold for x. The value of x is copied into y. Changes to y does not impact on x.

The null keyword Set an object variables to null when you

want the variable to not refer to an object null is a reserved word in Java

Can be used to initialize object variables BankAccount x = null;

You may test for null first before you call methods on an object variable if ( x != null )

System.out.println( x.getBalance() );

The this keyword When within a class and you wish to refer

to the current object, use the this keyword this is a reserved word in Java

Can use the dot notation within a class when referring to fields/methods public void deposit( double amount )

{ this.balance = this.balance + amount;}

Arrays Array variables are object references

type[] arrayVar; Array creation done separately

arrayVar = new type[size]; Applicable for both primitive types and

object types Note: for an array of objects, array

creation creates object references Individual objects need to be created

separately

Array of numbers

Declare: double[] nums;

nums

Array of numbers


Create: nums = new double[8];

nums 0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0

1

2

3

4

5

6

7

0.0

Array of numbers


Create: nums = new double[8];

Use: nums[3] = 6.6;

nums 0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0

1

2

3

4

5

6

7

6.6

Array of objects

Use objects: e.g., accounts[3].getBalance(); (returns 30)

Create array: accounts = new BankAccount[5];

Declare: BankAccount[] accounts;

accounts

Create objects:for ( i = 0; i < 5; i++ ){ accounts[i] = new BankAccount(i * 10);}

null0

1

2

3

4

null

null

null

null

null

BankAccount-type references

BankAccount balance 40





Inheritance Inheritance: an object-oriented

programming language feature that allows for the definition of a class in terms of another class

In Java, use the extends keyword Promotes reusability of existing code

Example: CheckingAccount Suppose we define CheckingAccount from scratch Attributes

balance number of checks drawn

Methods deposit withdraw get balance draw a check …others

CheckingAccount

double balanceint numChecks

double getBalance()void deposit( double amount )void withdraw( double amount )void drawCheck( double amount )…others

Example: CheckingAccount Resulting class is very similar to

BankAccount The same as BankAccount except for an

additional field and some methods Better to extend BankAccount instead

BankAccount revisitedpublic class BankAccount{ private double balance = 0; public double getBalance() { return balance; } public void deposit( double amount ) { balance = balance + amount; } public void withdraw( double amount ) { balance = balance - amount; }}

public class CheckingAccount{ private double balance = 0; private int numChecks = 0;

public int getBalance() { return balance; } public void deposit( double amount ) { balance = balance + amount; } public void withdraw( double amount ) { balance = balance - amount; } public void drawCheck( double amount ) { balance = balance - amount; // or, withdraw( amount ); numChecks++; } public int numChecksDrawn() { return numChecks; }}

CheckingAccount.java

Just like BankAccount except for the code in bold

public class CheckingAccount extends BankAccount{ private int numChecks = 0;

public void drawCheck( double amount ) { withdraw( amount ); // can’t do balance = balance – amount; // because balance is private to BankAccount numChecks++; } public int numChecksDrawn() { return numChecks; }}

CheckingAccount.java

Using extends

Notice that (public) methods defined in BankAccount (e.g., withdraw) can be used within CheckingAccount

Using CheckingAccount objects

CheckingAccount mary = new CheckingAccount();mary.deposit( 1000 );System.out.println( “Balance: ” + mary.getBalance() );mary.drawCheck( 100 );System.out.println( “Balance: ” + mary.getBalance() );System.out.println( “Checks Drawn: ” +

mary.numChecksDrawn() );

Can call methods defined in BankAccount

… and methods defined in CheckingAccount

Superclass variables, subclass objects Checking accounts are bank accounts so it is

possible to have a BankAccount variable point to a CheckingAccount object

But not the other way around Superclass variables can refer to subclass

objects, not vice-versa BankAccount b1 = new CheckingAccount();

(note: only methods indicated in BankAccount may be invoked through b1)

CheckingAccount b2 = new BankAccount();(not allowed because a bank account is not necessarily a checking account)

Method overriding A subclass may define a method already in

the superclass: this is called method overriding

The subclass method takes precedence over the superclass method Suppose class A extends class B and both

classes define a method m() B x = new A();

x.m(); // calls the method defined in A, not B If you call m() within class A, this pertains to

class A’s m(). To call B’s m(), use super.m()

Inheritance and constructors

public class BankAccount{ private double balance;

public BankAccount() { balance = 0; } public BankAccount( double initBal ) { balance = initBal; } public double getBalance() { return balance; } public void deposit( double amount ) { balance = balance + amount; } public void withdraw( double amount ) { balance = balance - amount; }}

public class CheckingAccount extends BankAccount{ private int numChecks;

public CheckingAccount() { numChecks = 0; } public void drawCheck( double amount ) { withdraw( amount ); numChecks++; } public int numChecksDrawn() { return numChecks; }}

CheckingAccount c = new CheckingAccount();

Which of the constructors are called?

Inheritance and constructors

CheckingAccount = new CheckingAccount();

In the above statement, CheckingAccount’s (default) constructor is called

Since CheckingAccount is a BankAccount, a BankAccount constructor should also be called Which one? Answer: the default constructor Note that BankAccount() is called before

CheckingAccount() What if we want a particular constructor of a

superclass called?

Incorrect attempt


public CheckingAccount() { numChecks = 0; } public CheckingAccount( double startBal ) { numChecks = 0; } public void drawCheck( double amount ) { withdraw( amount ); numChecks++; } public int numChecksDrawn() { return numChecks; }}

We want CheckingAccount c = new CheckingAccount( 1000 );to create an account with an initial balance of 1000

This will still callBankAccount( ),notBankAccount( 1000 )

Using super()


public CheckingAccount() { numChecks = 0; } public CheckingAccount( double startBal ) { super( startBal ); numChecks = 0; } public void drawCheck( double amount ) { withdraw( amount ); numChecks++; } public int numChecksDrawn() { return numChecks; }}

•super( … ) indicates which superclass constructor will be called•If not indicated, it defaults to super( ) with no parameters•Call to super(…) should be the first line in the subclass’ constructorImplicitly calls

“super();” or BankAccount( )

Calls a particular constructorBankAccount( int )

Interfaces in Java Interface: collection of method signatures with no

bodies Syntax

public interface InterfaceName{ public type methodName1(…); public type methodName2(…); …}

A java class may implement an interface

public class ClassName implements InterfaceName{ // define methodName1, methodName2, ... here}

Two types of inheritance Class inheritance (extends)

public class A extends B { … } Class A inherits fields and methods in class B public methods of B can be invoked on A objects, unless

overridden in A Interface inheritance (implements)

Also called implementation inheritance public class X implements Y { … } X must define all methods indicated in Y

Why use interfaces? Interfaces enable and enforce “strict” sharing of

methods among classes Recall that superclass variables can refer to

subclass objects Suppose Y is an interface

Y var; var can refer to an object of a class that implements Y var.methodName( … ) calls the actual method defined

Example: Shape A Shape is anything that can be drawn:

public interface Shape{ public void draw();}

Any class that implements Shape must implement the draw() method

Suppose Block, Triangle, and LetterT implement shape

We can have an array of Shapes with elements referring to different kinds of objects Use a loop to call draw() on all of the shapes

Example: Shape (and Block)public class Block implements Shape{ private int size; public Block( int s ) { size = s; } public void draw() { for( int i = 1; i <= size; i++ ) { for( int j = 1; j <= size; j++ ) System.out.print( “*” ); System.out.println(); }}

Because it implements Shape,this class will not compile unlessdraw() is defined

Example: array of Shapes

null

Shape[] list;…for ( int i = 0; i < 5; i++ ){ list[i].draw( );}

0

1

2

3

4

null

null

null

null

null

list Blockobject

Triangle object

LetterT object

Block object

Triangle object

Multiple inheritance Multiple (class) inheritance is not

supported in Javapublic class A extends B1, B2, B3 { … }

But a class may implement multiple interfacespublic class X implements Y1, Y2, Y3 { … }

will not compile

will compile, but X must define methods in Y1, Y2, and Y3

About interfaces Interfaces cannot be instantiated

Shape s = new Shape(); Interfaces can be extended

public interface Y1 extends Y2 { … } public class X implements Y1 { … }

X must define methods indicated in Y1 and Y2 Interfaces cannot declare instance fields and may

not have any method definitions Use an abstract class instead

Java Programming Review (Part I) Enterprise Systems Programming.

Documents