Core Java

Arrays
• An array is a collection of variables of the same type.
• A variable declared in brackets, [], is an array reference.
• Three steps
• Declaration - tell the compiler what the name is and the type
of its elements.
• Construction -
• Initialization
int numbers[]; // declaration
numbers = new int[100]; // construction
for (int i=0; i<100; i++) {
numbers[i] = i;
}
• String username[]; float[] balance;

2
 Arrays
• Components of an array are accessed by a simple
integer index.
• Element indexing begins with the number 0.
username[0] = "Fred";
username[1] = "Barney";
• The size of an array is easily accessed with the
length attribute.
for (int i=0; i<username.length; i++) {
System.out.println("The user's name is: " + username[i]);
}
• Indexing past the end of an array throws an
exception.
• Multidimensional arrays can be created.

3
 Extending Classes
• It is easy for one Java class to extend the
behavior of another Java class.
• This capability is usually referred to as
polymorphism, which means that an object
of a given class can have multiple forms.

4
 Objectives
• Extend existing classes.
• Define the terms subclass, superclass,
overloading, and overriding.
• Define how constructors of subclasses
operate.
• Define the implications of marking a class or
method as final.
• Discuss the considerations of cloning
classes.

5
 An Extended Class
• An extended class can be used wherever the
original class was legal.
• Polymorphism - an object of a given class can
have multiple forms.
• The extended class is a subclass.
• The class it extends is the superclass.
• If a class does not explicitly extend a class then
it implicitly extends Object.
• Object declares methods that are implemented
by all objects.

6
 What protected really means?
• A protected class member can be accessed by
classes that extend that class.
• A protected class member also be accessed
from code within the same package.
• A protected class member also be accessed
from references of the class's type or one of it's
subtypes.

7
 Constructors in extended classes
• When you extend a class, the new class must choose one of
it's superclass's constructors to invoke.
• If you do not invoke a superclass constructor as your
constructors first executable statement, the superclass no-arg
constructor is automatically invoked before any statements in
your new constructor are executed.
• If the superclass does not have a no-arg constructor, you must
explicitly invoke one of the superclass's other constructors, or
invoke another of your own constructors using the this
construct.
• If you use super(), it must be the first executable statement of
the constructor.
• The language provides a default no-arg constructor for you.

8
 Constructors order dependencies

• When an object is created, all it's fields are

set to default initial values.
• Then the constructor is invoked.

9
 Constructor Phases
• Invoke a superclass's constructor.
• Initialize the fields using their initializers and
any initialization blocks.
• Execute the body of the constructor.

10
 Overriding methods, hiding fields, and
nested classes
• Overloading - providing more than one method with the same
name but with different signatures.
• Overriding - replacing a superclass's implementation with your
own.
• Overriding
– Signatures must be identical.
– Return type must be the same.
– Only accessible non-static methods can be overridden.
– A subclass can determine whether a parameter in an overridden method
is final.
• The super keyword
– Available in all non-static methods of a class.
– super.method() - uses the superclass's implementation of method.

11
 Marking methods and classes final
• No extended class can override the method to change
its behavior. (This is the final version of that method.)
• A class marked final cannot be extended by any other
class (and, all the methods of a final class are
implicitly final).
• Security - anyone who uses the class can be sure the
behavior will not change (validatePassword example).
• Serious restriction on the use of the class.
• Final simplifies optimizations.

12
 The object class
• All classes inherit from Object.
• Object's methods fall in two classes: utilities,
and thread support.
• Object's utility methods
– equals(Object o)
– hashCode()
– clone()
– getClass()
– finalize()

13
 Anonymous classes
• Use these when the weight of a full class seems too
much for your needs.
• Extend a class or implement an interface.
• Defined at the same time they are created with new.
• Defined in the new expression.
• Cannot have their own constructors.
• Can easily become hard to read.
• Avoid anonymous classes longer than six lines.
• Use them only in the simplest of expressions.

14
 Abstract Classes and methods
• Helpful when some of the behavior is defined for most
objects of a given type, but some behavior makes sense
for only particular classes and not the superclass.
• Declare classes that define only part of an
implementation.
• Each method not implemented in an abstract class is
marked abstract.
• A class with any abstract methods must be declared
abstract.
• Abstract methods must be implemented by subclasses
that are not abstract themselves.

15
 Cloning objects
• A clone method returns a new object whose initial state is a copy of
the current state of the object on which clone was invoked.
• Subsequent changes to the clone will not affect the state of the
original.
• Object.clone()
• Three major considerations in writing a clone method
– Empty Cloneable interface.
– Object.clone() method.
– CloneNotSupportedException.
• Four different attitudes a class can have towards clone
– Support clone.
– Conditionally support clone.
– Allow subclasses to support clone but don't publicly support it.
– Forbid clone.

16
 Designing a class to be extended
• Choose the access for each part of a class design
carefully: public, protected, private.
• If your design will have subclasses, design your
protected parts carefully.
• Bad effects of public fields
– Fields can be modified at any time by a programmer.
– No way to add functionality.
• Non-final classes have two interfaces
– Public interface for programmers using the class.
– Protected interface for programmers extending the class.

17
 Interfaces
Interfaces are a way to declare a type
consisting only of abstract methods and
related constants, classes, and interfaces.
An interface in Java is an expression of pure
design, whereas a class is a mix of design
and implementation.

18
 Objectives
• Describe an interface.
• Define the differences between single and
multiple inheritance.
• Show how to implement an interface.
• Describe the differences between interfaces
and abstract classes.

19
 More about Interface
• Java has single inheritance of implementation -
you can extend only one class.
• Java has multiple interface inheritance.
• All methods in an interface are implicitly
abstract.
• Each class that implements the interface must
implement all its methods.
• Methods in an interface are always public.
• Fields in an interface are always static and
final.
20
 Single inheritance versus multiple
inheritance
• A new class can extend exactly one superclass.
• The new class inherits the superclass's (a) contract
and (b) implementation.
• Some languages allow multiple inheritance - two or
more superclasses.
• Problem of multiple inheritance arises from multiple
inheritance of implementation. (Usually related to a
class that maintains state information.)

21
 Extending Interfaces
• Interfaces can be extended using the
extends keyword.
• Interfaces can extend more than one
interface:
interface Shimmer extends FloorWax, DessertTopping {…

• All methods and constants defined by

FloorWax and DessertTopping are part of
Shimmer.

22
 Interfaces Vs Abstract Classes
• Two Important Differences Between Interfaces and Abstract Classes
• Interfaces provide a form of multiple inheritance. A class can extend
only one other class.
• Interfaces are limited to public methods and constants with no
implementation. Abstract classes can have a partial implementation,
protected parts, static methods, etc.
• Interface or Abstract Class
• These two differences usually direct the choice.
• If multiple inheritance is important or even useful interfaces are
used.
• Abstract class lets you define some or all of the implementation.
• Any major class you expect to be extended should be an
implementation of an interface.

23
 Exceptions
• Applications can run into many kinds of errors during
execution.
• Java exceptions provide a clean way to check for
errors without cluttering code, and provide a
mechanism to signal errors directly.
• Exceptions are also part of a method's contract.
• An exception is thrown when an unexpected error
condition is encountered.
• The exception is then caught be an encompassing
clause further up the method invocation stack.

24
 Objectives
• Create their own Exception class.
• Throw an exception.
• Define the three choices you have when a method
throws an exception.
• Use try/catch/finally to run a method that may throw
an exception.
• Describe the purpose of the finally clause, and when
it is run.
• Make better decisions about when to throw
exceptions in your code.

25
 Creating Exception Types
• Exceptions are objects.
• Must extend the class Throwable or one of it's
subclasses.
• By convention new exception types extend Exception
(a subclass of Throwable).
public class BadPizzaException extends Exception { public
String attrName;
BadPizzaException(String name) {
super( "BadPizzaException: " + name ); attrName = name;
}
}

26
 throw
• Exceptions are thrown using the throw
statement.
• Exceptions are objects, so they must be
created (with new) before being thrown.

27
 The throws clause
• The exceptions a method can throw are declared with a
throws clause.
• The exceptions a method can throw are as important as
the value type the method returns.
• Choices when invoking a method that has a throws
clause
– Catch the exception and handle it.
– Catch the exception and map it to one of your exceptions by
throwing an exception of a type declared in your own throws
clause.
– Declare the exception in your throws clause and let the exception
pass through your method.
28
 try, catch, and finally
• Exceptions are caught by enclosing code in try blocks.
• The body of try is executed until an exception is thrown or it
finishes successfully.
• If an exception is thrown, each catch clause is examined in turn,
from first to last, to see whether the exception object is assignable
tto the type declared with the catch.
• When an assignable catch is found, its code block is executed. No
other catch clause will be executed.
• Any number of catch clauses can be associated with a try, as long
as each clause catches a different type of exception.
• If a finally clause is present in the try block, the code is executed
after all other processing in the try is complete. This happens no
matterhow the try clause completed - normally, through an
exception, or through a return or break.

29
 finally
• A mechanism for executing a section of code
whether or not an exception is thrown.
• Usually used to clean up internal state or to release
non-object resources, such as open files stored in
local variables.
• Can also be used to cleanup for break, continue, and
return.
• No way to leave a try block without executing its
finally clause.
• A finally clause is always entered with a reason; that
reason is remembered when the finally clause exits.

30
 Concept of Packages
• Reusability of code is one of the most important
requirements in the software industry.
• Reusability saves time, effort and also ensures
consistency.
• In Java, the codes which can be reused by other
programs is put into a “Package”.
• A Package is a collection of classes, interfaces and/or
other packages.
• Packages are essentially a means of organizing
classes together as groups.

31
 Features of Packages
• Packages are useful for the following purposes:
Packages allow you to organize your classes into
smaller units ( such as folders ) and make it easy to
locate and use the appropriate class file.
• It helps to avoid naming conflicts. When you are
working with a number of classes, it becomes difficult
to decide on names of the classes & methods.
• At times you would want to use the same name, which
belongs to an another class. Package, basically hides
the classes and avoids conflicts in names.
• Packages allow you to protect your classes, data and
methods in a larger way than on a class-to-class basis.
• Package names can be used to identify your classes.
32
 More on Packages
• A package name should be unique. A good way to
ensure unique package names is to use an Internet
domain name (reversed):
package COM.missiondata.utils;
• A public class or interface is accessible to code
outside that package.
• Types that are not public have package scope; they are
available to all other code in the same package, but are
hidden outside the package and even from code in
nested packages.
• Package scope is the default if public/protected/private
are not declared.

33
 Importing a Package
• In Java, the Packages (where the required method is already
created) can be imported into any program where the
method is to be used.
• We can import a Package in the following manner :
import package_name . class_name ;
• Suppose you wish to use a class say My_Class whose
location is as follows:
• This class can be imported as follows :

import My_Package . MySub_Package . My_Class ;

34
 Creating a Package
• In Java Packages are created in the following
manner :
package package_name ;

35
Standard Java Packages

36
java.lang package

37
 Some of the important methods of
Math class
• int abs(int i) - returns the absolute value of I
• long abs(long l) - returns the absolute value of l
• float abs(float f) - returns the absolute value of f
• double abs(double d) - returns the absolute value of
d
• double ceil(double d) -- returns as a double the
smallest integer that is not less than d
• double floor(double d) --- returns as a double the
largest integer

38
java.io package

39
 java.io package
• The classes derived in Inputstream and Outputstream can
only read from or write to the respective files.
• We cannot use the same class for both reading and
writing operations.
• An exception to this rule is the class RandomAccessFile”.
• This is the class used to handle files that allow random
access and is capable of mixed reading and writing
operations on a file.
• There are two additional interface to this package :
– Data input
– Data output
• These classes are used to transfer data other than bytes
or characters

40
 java.util package
• One of the most important package in this package is
the class “Date”, which can be used to represent or
manipulate date and time information.
• In addition, the class also enable us to account for
time zones .
• Java helps us to change the size of an array which is
usually fixed, by making use of the class “Vector”.
This class also enable us to add, remove and search
for items in the array.

41
 Tips on using packages
• The statement :
import java.awt.* ;
• Will include all the classes available in the “awt”
subdirectory present in the java directory.
• While creating a package, care should be taken that
the statement for creating a package must be written
before any other import statements

42
 Important Packages in Java
• java.lang
– You don’t need to explicitly import this package. It is always imported for you.
• java.io
– This package consists of classes that help you for all the Input and Output
operations.
• java.applet
– This package consists of classes that you need, to execute an applet in the
browser or an appletviewer.
• java.awt
– This package is useful to create GUI applications.
• java.util
– This package provides a variety of classes and interfaces for creating lists,
calendar, date, etc.
• java.net
– This package provides classes and interfaces for TCP/IP network programming.

43
 IO Streams
• Objectives
– IO Streams in Java
– Understanding some fundamental streams
– Creating streams for required functionality
– Some advanced streams

44
 Streams
• Streams are channels of communication
• Provide a good abstraction between the source and
destination
• Could also act as a shield to lower transport
implementation
• Most of Java’s IO is based on streams
– Byte-oriented streams
– Character-oriented streams
• Concatenating Streams

45
 More about Streams
• A stream can be thought of as a Conduit (pipe) for data
between a source and the destination.
• Two types of Streams are:
– Streams which carries bytes are called low level streams.
– Examples are FileInputStream and FileOutputStream.
• Streams which carries primitive data types are called high
level streams.
– Examples are DataInputStream and DataOutputStream.

• InputStreams are used for reading the data from the source.
• OutputStreams are used for writing the data to the
destination.

46
How it works?

47
 Writing primitives to a File
• Writing Primitives to a File
DataOutputStream dos = new DataOutputStream( new
FileOutputStream("item.dat"));
dos.writeFloat(itemPrice);
dos.writeInt(itemQty);
dos.writeChars(itemNo);

48
 Filter Streams
• Filter contents as they pass through the
stream
• Filters can be concatenated as seen before
• Some filter streams
– Buffered Streams
– LineNumberInputStream
– PushBackInputStream
– PrintStream

49
 Conversion Streams
• InputStreamReader: bridge from byte streams
to character streams

BufferedReader in = new BufferedReader( new

InputStreamReader(System.in));

• OutputStreamWriter: bridge from chararcter

streams to byte streams

50
 Summary of IO Streams and Readers
• The java.io package provides a rich framework and class library for reading and
writing any type of data (text, numbers, images) in streams from any type of
location (disk, network, memory).
• The package provides 2 class hierarchies: one for byte streams, the other for
character streams.
– Base classes for reading data: InputStream for byte streams, Reader for character
streams.
– Base classes for writing data: OutputStream for byte streams, Writer for character
streams.
• Example of copying one file to another.
Reader in = new FileReader("one.txt");
Writer out = new FileWriter("two.txt");
int token = -1;
while( (token != in.read()) != -1 ) {
out.write(token);
}
out.close();

51
 Properties Click
// Read properties file.
Properties properties = new Properties();
try {
properties.load(new FileInputStream("filename.properties"));
} catch (IOException e) {
}

// Write properties file.

try {
properties.store(new FileOutputStream("filename.properties"), null);
} catch (IOException e) {
}

52
 Properties File
• Sample properties file
name=Shiv
job=trainner
• Getting and Setting Properties
String string = properties.getProperty("name");
properties.setProperty("name", "New Shiv");

53
 Using Wrappers
• The wrapper classes correlate to the primitive types.
• Wrappers have two main functions:
– To wrap primitives so that they can be handled like objects
– To provide utility methods for primitives (usually conversions)
• Other than Character and Integer, wrapper class names are the
primitive’s name, capitalized.
• Wrapper constructors can take a String or a primitive, except for
Character, which can only take a char.
• A Boolean object can’t be used like a boolean primitive.
• The three most important method families are
– xxxValue() Takes no arguments, returns a primitive
– parseXxx() Takes a String, returns a primitive, is static, throws NFE
– valueOf() Takes a String, returns a wrapped object, is static, throws NFE

54
 Assertions
• Assertions give you a way to test your assumptions during development and debugging.
• Assertions are typically enabled during testing but disabled during deployment.
• You can use assert as a keyword (as of version 1.4) or an identifier, but not both
together.
• To compile older code that uses assert as an identifier (for example, a method name),
use the -source 1.3 command-line flag to javac.
• Assertions are disabled at runtime by default. To enable them, use a command-line
flag -ea or -enableassertions.
• You can selectively disable assertions using the -da or -disableassertions flag.
• You can enable or disable assertions in the system classes with the -esa or -dsa
flags.
• You can enable and disable assertions on a class-by-class basis, using the following
syntax:
• java -ea -da:MyClass TestClass
• You can enable and disable assertions on a package basis, and any package you
specify also includes any subpackages (packages further down the directory
hierarchy).

55
 Some rules for using Assertion
• Do not use assertions to validate arguments to public
methods.
• Do not use assert expressions that cause side effects.
Assertions aren’t guaranteed to always run, so you don’t want
behavior that changes depending on whether assertions are
enabled.
• Do use assertions - even in public methods - to validate that a
particular code block will never be reached.
• You can use assert false; for code that should never be
reached, so that an assertion error is thrown immediately if
the assert statement is executed.
• Do not use assert expressions that can cause side effects.

56
 Overriding equals() and hashcode()
• The critical methods in class Object are equals(), finalize(), hashCode(),
and toString().
• equals(), hashCode(), and toString() are public (finalize() is protected).
• Fun facts about toString():
– Override toString() so that System.out.println() or other methods can see
something useful.
– Override toString() to return the essence of your object’s state.
• Use == to determine if two reference variables refer to the same object.
• Use equals() to determine if two objects are meaningfully equivalent.
• If you don’t override equals(), your objects won’t be useful hashtable/
hashmap keys.
• If you don’t override equals(), two different objects can’t be considered
the same.
• Strings and wrappers override equals() and make good
hashtable/hashmap keys.
• When overriding equals(), use the instanceof operator to be sure you’re
evaluating an appropriate class.
• When overriding equals(), compare the objects’ significant attributes.

57
 Overriding equals() and hashcode()
• If you override equals(), override hashCode().
• Classes HashMap, Hashtable, LinkedHashMap, and
LinkedHashSet use hashing.
• A legal hashCode() override compiles and runs.
• An appropriate hashCode() override sticks to the
contract.
• An efficient hashCode() override distributes keys
randomly across a wide range of buckets.
• To reiterate: if two objects are equal, their hashcodes
must be equal.
• It’s legal for a hashCode() method to return the same
value for all instances (although in practice it’s very
inefficient).

58
 Collections
• Common collection activities include adding
objects, removing objects, verifying object
inclusion, retrieving objects, and iterating.
• Three meanings for "collection":
– collection - Represents the data structure in which
objects are stored
– Collection - java.util.Collection—Interface from which
Set and List extend
– Collections - A class that holds static collection utility
methods

59
 Lists, Sets and Maps
• Three basic flavors of collections include
Lists, Sets, Maps:
– Lists of things: Ordered, duplicates allowed,
with an index
– Sets of things: May or may not be ordered
and/or sorted, duplicates not allowed
– Maps of things with keys: May or may not be
ordered and/or sorted, duplicate keys not
allowed

60
 Subflavors of Collections
• Four basic subflavors of collections include
Sorted, Unsorted, Ordered, Unordered.
– Ordered means iterating through a collection
in a specific, nonrandom order.
– Sorted means iterating through a collection in
a natural sorted order.
• Natural means alphabetic, numeric, or
programmer-defined, whichever applies.

61
 More on Collections
• Key attributes of common collection classes:
– ArrayList: Fast iteration and fast random access
– Vector: Like a somewhat slower ArrayList, mainly due to its synchronized
methods
– LinkedList: Good for adding elements to the ends, i.e., stacks and queues
– HashSet: Assures no duplicates, provides no ordering
– LinkedHashSet: No duplicates; iterates by insertion order or last accessed
– TreeSet: No duplicates; iterates in natural sorted order
– HashMap: Fastest updates (key/value pairs); allows one null key, many null
values
– Hashtable: Like a slower HashMap (as with Vector, due to its synchronized
methods). No null values or null keys allowed
– LinkedHashMap: Faster iterations; iterates by insertion order or last accessed,
allows one null key, many null values (new with 1.4)
– TreeMap: A sorted map, in natural order

62
 Object Serialization
Need for Serialization
• Persistence:
– The capability of an object to exist beyond the
execution of the program which created it.
• In other words :
– saving the state of the program in some
permanent storage device, such as file

63
 Use of Serialization
• Lightweight persistence
• communication via sockets
• Remote Method Invocation(RMI)

64
 Serialization Mechanism
• Serializable objects are converted into
stream of bytes and are stored in a file (in
other words objects are stored in encoded
form).
• Serializable objects implements
java.io.Serializable interface.

65
 De-Serialization Mechanism
• Serialized object is restored into its original
form.
• Information for restoring kept in Serialized
form of object itself.

66
 Object Serialization
import java.io.*;
public class SerializationDemo{
public static void main(String args[]){
try{ //Object Seriliazation
MyClass object1 = new MyClass ("hello",-7, 2.7);
System.out.println("object1:" + object1);
FileOutputStream fos = new FileOutputStream("seril");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(object1);
oos.flush();
fos.close();
}catch(Exception e) {
System.exit(0);
}
}
}

67
 Object Deserialization
try{
MyClass object2;
FileInputStream fis = new FileInputStream("serial");
ObjectInputStream ois = new ObjectInputStream(fis);
object2 = (MyClass)ois.readObject();
ois.close();
System.out.println("Object2: " + object2);
}catch(Exception e) {
System.exit(0);
}

68
 Object Serialization
class MyClass implements Serializable{
String s;
int i;
double d;
public MyClass (String s, int i, double d){
this.s = s;
this.i = i;
this.d = d;
}

public String toString(){

return "s=" + s + ";i=" + i + ";d= " + d ;
}
}
69
 Security issue in serialization
• Security: an issue in serialization
– Serialized objects can be sent over network
– Can be accidentally or deliberately modified
– Also sensitive data can be read
• Solution
– Encrypt the object during serialization using
Security API
– Ensure that sensitive objects do not implement
Serialializable or Externalizable

70
 Happy
Java Programming!