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 must be 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 outside of 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( ); b.deposit( ); b.withdraw( ); System.out.println( b.getBalance() ); x.deposit( ); b.deposit( ); 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 x balance: 1001 y 1000 x 1001 y

Parameter passing  BankAccount b = new BankAccount(100); int x = 100; changeAccount( b ); // update of b possible changeNumber( 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 Declare: double[] nums; Create: nums = new double[8]; nums

Array of numbers Declare: double[] nums; Create: nums = new double[8]; Use: nums[3] = 6.6; nums

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); } null BankAccount-type references BankAccount balance 40 BankAccount balance 30 BankAccount balance 20 BankAccount balance 10 BankAccount balance 0

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 balance int 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 revisited public 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 class CheckingAccount extends BankAccount { private int numChecks; 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 call BankAccount( ), not BankAccount( 1000 )

Using super() public class CheckingAccount extends BankAccount { private int numChecks; 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’ constructor Implicitly calls “super();” or BankAccount( ) Calls a particular constructor BankAccount( 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 unless draw() is defined

Example: array of Shapes null Shape[] list; … for ( int i = 0; i < 5; i++ ) { list[i].draw( ); } null list Block object Triangle object LetterT object Block object Triangle object

Multiple inheritance  Multiple (class) inheritance is not supported in Java public class A extends B1, B2, B3 { … }  But a class may implement multiple interfaces public 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