Download FDP_CORE_JAVA

Core Java
Prof Darshana Mistry
HOD of Computer Department
Gandhinagar Institute Of Technology
1
History

James Gosling and Sun Microsystems

Oak

Java, May 20, 1995, Sun World

HotJava
◦ The first Java-enabled Web browser

JDK Evolutions

J2SE, J2ME, and J2EE (not mentioned in
the book, but could discuss here
optionally)
2
Characteristics of Java











Java is simple
Java is object-oriented
Java is distributed
Java is interpreted
Java is robust
Java is secure
Java is architecture-neutral
Java is portable
Java’s performance
Java is multithreaded
Java is dynamic
3
Versions of Java

Java Language vs Java Platform

Java 2 Micro Edition (J2ME)

Java 2 Standard Edition (J2SE)

Java 2 Enterprise Edition (J2EE)
◦ Current version of the language is 1.4.1
◦ Core language plus additional APIs is called the Java 2
platform
◦ Three versions of the Java 2 Platform, targetted at
different uses
◦ Very small Java environment for smart cards, pages,
phones, and set-top boxes
◦ Subset of the standard Java libraries aimed at limited
size and processing power
◦ The basic platform, which this course will cover
◦ For business applications, web services, mission-critical
systems
◦ Transaction processing, databases, distribution,
replication
The Java APIs
Sun are constantly adding new features and APIs
 The Core Java API is now very large

◦ Often difficult to keep up with every change

Separate set of extension APIs for specific purposes
◦ E.g. Telephony, Web applications, Game programming

All new developments reviewed through Java
Community Process (http://www.jcp.org)
◦ Chance for developers to provide feedback on emerging
standards and APIs
◦ Useful to keep an eye on what's coming through

Also a wide range of “open source“ APIs available
◦ E.g. through the Jakarta project (http://jakarta.apache.org)
Useful Resources
Useful resources on the web
 Java home (http://java.sun.com)

◦ Articles, Software and document downloads, Tutorials

Java Developer Services
http://developer.java.sun.com
◦ Early access downloads, forums, newsletters, bug
database

Javaworld (http://www.javaworld.com)
◦ Java magazine site, good set of articles and tutorials

IBM developerWorks
(http://www.ibm.com/developerWorks)
◦ Technology articles and tutorials
Is Java Interpreted or Compiled?
BOTH!!
Java programs are compiled to Bytecode
 Bytecode is then interpreted by a JVM, or Java
Virtual machine.The virtual machine is what runs
your program.
It’s the JVM that cares about your Operating
system, NOT THE PROGRAM!
WORA - Write Once, Run Anywhere!



Compiling and
Executing of
Java Program
The Virtual Machine

Java is both compiled and interpreted
◦ Source code is compiled into Java bytecode
◦ Which is then interpreted by the Java Virtual Machine
(JVM)
◦ Therefore bytecode is machine code for the JVM

Java bytecode can run on any JVM, on any
platform
◦ …including mobile phones and other hand-held devices

Networking and distribution are core features
◦ In other languages these are additional APIs
◦ Makes Java very good for building networked
applications, server side components, etc.
Features of the JVM

The Garbage Collector
◦ Java manages memory for you, the developer has no
control over the allocation of memory (unlike in C/C++).
◦ This is much simpler and more robust (no chance of
memory leaks or corruption)
◦ Runs in the background and cleans up memory while
application is running

The Just In Time compiler (JIT)
◦ Also known as “Hot Spot”
◦ Continually optimises running code to improve
performance
◦ Can approach the speed of C++ even though its
interpreted
Features of the JVM

Security

Class Loading
◦ Java offers very fine control over what an application is
allowed to do
◦ E.g. Read/write files, open sockets to remote machines,
discover information about the users environment, etc
◦ Used in Java Applets to create a “sandbox”. Stops a rogue
applet attacking your machine.
◦ Makes Java very safe, an important feature in distributed
systems
◦ Loading of bytecode into the virtual machine for execution
◦ Code can be read from a local disk, over a network, or the
Internet
◦ Allows downloading of applications and applets on the fly
◦ …and even ‘mobile code’
Is Java Object Oriented?
YES!
Every bit of code in a Java program is in a “Class”
Code Reuse, Encapsulation, Polymorphism, Inheritance
Object-Oriented Programming

Understanding OOP is fundamental to writing
good Java applications
◦ Improves design of your code
◦ Improves understanding of the Java APIs

There are several concepts underlying OOP:
◦
◦
◦
◦
◦
Abstract Types (Classes)
Encapsulation (or Information Hiding)
Aggregation
Inheritance
Polymorphism
What is OOP?


Modelling real-world objects in software
Why design applications in this way?
◦ We naturally classify objects into different types.
◦ By attempting to do this with software aim to make
it more maintainable, understandable and easier to
reuse

In a conventional application we typically:
◦ decompose it into a series of functions,
◦ define data structures that those functions act upon
◦ there is no relationship between the two other than
the functions act on the data
What is OOP?

How is OOP different to conventional
programming?
◦ Decompose the application into abstract data
types by identifying some useful
entities/abstractions
◦ An abstract type is made up of a series of
behaviours and the data that those behaviours
use.

Similar to database modelling, only the
types have both behaviour and state
(data)
Abstract Data Types

Identifying abstract types is part of the
modelling/design process
◦ The types that are useful to model may vary according to
the individual application
◦ For example a payroll system might need to know about
Departments, Employees, Managers, Salaries, etc
◦ An E-Commerce application may need to know about Users,
Shopping Carts, Products, etc

Object-oriented languages provide a way to define
abstract data types, and then create objects from
them
◦ It’s a template (or ‘cookie cutter’) from which we can create new
objects
◦ For example, a Car class might have attributes of speed, colour,
and behaviours of accelerate, brake, etc
◦ An individual Car object will have the same behaviours but its own
values assigned to the attributes (e.g. 30mph, Red, etc)
-----------------
-----------------
-----------------
"Conventional Programming" -Functions or Procedures operating on independent data
"OO Programming" -Abstract Types combine data and behaviour
Encapsulation
The data (state) of
an object is private –
it cannot be accessed
directly.
 The state can only be
changed through its
behaviour, otherwise
known as its public
interface or contract
 This is called
encapsulation

"The Doughnut Diagram"
Showing that an object has
private state and public
behaviour. State can only be
changed by invoking some
behaviour
Private Data
Public Interface
Encapsulation

Main benefit of encapsulation
◦ Internal state and processes can be changed
independently of the public interface
◦ Limits the amount of large-scale changes required to a
system
What is an OO program?

What does an OO program consist of?
◦ A series of objects that use each others behaviours in
order to carry out some desired functionality
◦ When one object invokes some behaviour of another it
sends it a message
◦ In Java terms it invokes a method of the other object
◦ A method is the implementation of a given behaviour.

OO programs are intrinsically modular
◦ Objects are only related by their public behaviour
(methods)
◦ Therefore objects can be swapped in and out as required
(e.g. for a more efficient version)
◦ This is another advantage of OO systems
Aggregation

Aggregation is the ability to create new classes
out of existing classes
◦ Treating them as building blocks or components

Aggregation allows reuse of existing code
◦ “Holy Grail” of software engineering
Two forms of aggregation
 Whole-Part relationships

◦ Car is made of Engine, Chassis, Wheels

Containment relationships
◦ A Shopping Cart contains several Products
◦ A List contains several Items
Inheritance

Inheritance is the ability to define a new class in
terms of an existing class
◦ The existing class is the parent, base or superclass
◦ The new class is the child, derived or subclass

The child class inherits all of the attributes and
behaviour of its parent class
◦ It can then add new attributes or behaviour
◦ Or even alter the implementation of existing behaviour

Inheritance is therefore another form of code
reuse
Polymorphism




Means ‘many forms’
Difficult to describe, easier to show, so we’ll look
at this one in a later lesson
In brief though, polymorphism allows two
different classes to respond to the same message
in different ways
E.g. both a Plane and a Car could respond to a
‘turnLeft’ message,
◦ however the means of responding to that message
(turning wheels, or banking wings) is very different for
each.

Allows objects to be treated as if they’re identical
A Simple Application
Example
//This application program prints Welcome
//to Java!
Import java.io.*;
package chapter1;
public class Hello {
public static void main(String[] args) {
System.out.println(“Hello World!");
}
}
The import statement tells the compiler to make
available classes and methods of another package
 A main method indicates where to begin executing a class
(if it is designed to be run as a program)



public = can be seen from any package
static = not “part of” an object
24
Creating and Compiling Programs

On command line
◦ javac file.java
(it produce
file.class
file)
Create/Modify Source Code
Source Code
Compile Source Code
i.e. javac Welcome.java
If compilation errors
Bytecode
Run Byteode
i.e. java Welcome
Result
If runtime errors or incorrect result
25
Executing Applications

On command line
◦ java classname (Starts the JVM and runs
the main method)
Bytecode
Java
Interpreter
on Windows
Java
Interpreter
on Linux
...
Java
Interpreter
on Sun Solaris
26
Example
javac Hello.java
Java Hello
output:...Hello World
27
Downloading a Java JDK
You want a JDK, not just a JRE
Create a “Temp” directory on your PC or laptop
Go to http://java.sun.com
Go to the “Popular Downloads” section and select “Java SE”
Select a JDK without Netbeans (We’ll talk about this later)
Agree to the accept the use policy
Right Click and Save the Offline Windows JDK to your temp dir
Installing a Java JDK
Go to your “Temp” dir using Windows Explorer
Make sure no other apps are running and double click the install program
you just downloaded. Follow the steps.
I install in C:\Java
Watch fom multiple JREs and JDKs! In Windows the Registry runs the
show now, not the JAVA_HOME env variable
Test with a Command Prompt Window and “java –version”
Add C:\Java\”Java ver”\bin to your PATH var
Be sure to add “current directory” to the CLASSPATH (if you had one)
Now, Lets test it
DOS - Command Prompt
Make a directory structure
Type “Edit” and Voila
PSVM
Test JAVAC and JAVA
Create Bytecode ( the *.class file) with “Javac”
Run Program with “Java”
If we were
lucky we
got
something
that looks
like this…
Help on the Web
http://java.sun.com/javase/6/docs/api/
http://www.javaranch.com
http://java.sun.com/docs/books/tutorial/
http://www.sorcon.com/java2/
http://remus.rutgers.edu/freestuff
Got an Error?
Just type it verbatim into Google and you usually can find the
answer to your question or solve your problem.
Wikipedia is a good place to get background and history
On anything, and Java is no exception
References and Primitive Data
Types

Java distinguishes two kinds of entities
◦ Primitive types
◦ Objects
Primitive-type data is stored in primitivetype variables
 Reference variables store the address of
an object

◦ No notion of “object (physically) in the stack”
◦ No notion of “object (physically) within an
object”
33
Primitive Data Types
Represent numbers, characters, boolean
values
 Integers: byte, short, int, and long
 Real numbers: float and double
 Characters: char

34
Primitive Data Types
Data type
Range of values
byte
-128 .. 127 (8 bits)
short
-32,768 .. 32,767 (16 bits)
int
-2,147,483,648 .. 2,147,483,647 (32 bits)
long
-9,223,372,036,854,775,808 .. ... (64 bits)
float
+/-10-38 to +/-10+38 and 0, about 6 digits precision
double
+/-10-308 to +/-10+308 and 0, about 15 digits precision
char
Unicode characters (generally 16 bits per char)
boolean
True or false
35
Primitive Data Types (continued)
36
Operators
1.
2.
3.
4.
5.
6.
7.
8.
9.
subscript [ ], call ( ), member access .
pre/post-increment ++ --, boolean
complement !, bitwise complement ~, unary
+ -, type cast (type), object creation new
* / %
binary + - (+ also concatenates strings)
signed shift << >>, unsigned shift >>>
comparison < <= > >=, class test
instanceof
equality comparison == !=
bitwise and &
bitwise or |
37
Operators
11.logical
(sequential) and &&
12.logical (sequential) or ||
13.conditional cond ? true-expr :
false-expr
14.assignment =, compound assignment +=
-= *= /= <<= >>= >>>= &= |=
38
Type Compatibility and Conversion

Widening conversion:
◦ In operations on mixed-type operands, the
numeric type of the smaller range is converted
to the numeric type of the larger range
◦ In an assignment, a numeric type of smaller
range can be assigned to a numeric type of
larger range
byte to short to int to long
 int kind to float to double

39
Declaring and Setting Variables
int square;
square = n * n;
 double cube = n * (double)square;

◦ Can generally declare local variables where
they are initialized
◦ All variables get a safe initial value anyway
(zero/null)
40
Referencing and Creating Objects

You can declare reference variables
◦ They reference objects of specified types
Two reference variables can reference the
same object
 The new operator creates an instance of a
class
 A constructor executes when a new
object is created
 Example: String greeting = ″hello″;

41
Java Control Statements

A group of statements executed in order
is written
◦ { stmt1; stmt2; ...; stmtN; }
The statements execute in the order 1, 2,
..., N
 Control statements alter this sequential
flow of execution

42
Java Control Statements
(continued)
43
Java Control Statements
(continued)
44
Methods




A Java method defines a group of statements
as performing a particular operation
static indicates a static or class method
A method that is not static is an instance
method
All method arguments are call-by-value
◦ Primitive type: value is passed to the method
◦ Method may modify local copy but will not affect
caller’s value
◦ Object reference: address of object is passed
◦ Change to reference variable does not affect caller
◦ But operations can affect the object, visible to
caller
45
The Class Math
Appendix A: Introduction to
Java
46
Escape Sequences
An escape sequence is a sequence of two
characters beginning with the character \
 A way to represents special
characters/symbols

Appendix A: Introduction to
Java
47
OO Programming Concepts
A Circle object
An object
Data Field
radius = 5
data field 1
...
State
Method
findArea
data field n
method 1
...
method n
Behavior
Class and Objects
UML Graphical notation for classes
Circle
radius: double
UML Graphical notation for fields
UML Graphical notation for methods
findArea(): double
new Circle()
new Circle()
circle1: Circle
radius = 2
circlen: Circle
...
radius = 5
UML Graphical notation
for objects
Class Declaration
class Circle {
double radius = 1.0;
double findArea(){
return radius * radius * 3.14159;
}
}
Declaring Object Reference
Variables
ClassName objectReference;
Example:
Circle myCircle;
Creating Objects
objectReference = new ClassName();
Example:
myCircle = new Circle();
The object reference is assigned to the
object reference variable.
Declaring/Creating Objects
in a Single Step
ClassName objectReference = new ClassName()
Example:
Circle myCircle = new Circle();
Differences between variables of
primitive Data types and object
types
Primitive type
int i = 1
i
1
Object type
Circle c
c
reference
c: Circle
Created using
new Circle()
radius = 1
Copying Variables of Primitive
Data Types and Object Types
Primitive type assignment
i=j
Object type assignment
c1 = c2
Before:
After:
i
1
i
2
c1
c1
j
2
j
2
c2
c2
Before:
After:
c1: Circle
c2: Circle
radius = 5
radius = 9
Garbage Collection
As shown in the previous figure, after the
assignment statement c1 = c2, c1 points to the
same object referenced by c2. The object
previously referenced by c1 is no longer useful.
This object is known as garbage. Garbage is
automatically collected by JVM.
Garbage Collection, cont
TIP: If you know that an object is no longer
needed, you can explicitly assign null to a
reference variable for the object. The Java VM
will automatically collect the space if the object
is not referenced by any variable.
Accessing Objects

Referencing the object’s data:
objectReference.data
myCircle.radius

Invoking the object’s method:
objectReference.method
myCircle.findArea()
Constructors
Circle(double r) {
radius = r;
}
Constructors are
Circle() {
radius = 1.0;
}
a special kind of
methods that are
invoked to
construct objects.
myCircle = new Circle(5.0);
Constructors, cont.
A constructor with no parameters is referred
to as a default constructor.

Constructors must have the same name as
the class itself.

Constructors do not have a return type—
not even void.

Constructors are invoked using the new
operator when an object is created.
Constructors play the role of initializing
objects.
Visibility Modifiers and
Accessor Methods
By default, the class, variable, or data can be
accessed by any class in the same package.

public
The class, data, or method is visible to any
class in any package.

private
The data or methods can be accessed only by
the declaring class.
The get and set methods are used to read and
modify private properties.
Scope of Variables

The scope of instance and class
variables is the entire class. They can
be declared anywhere inside a class.

The scope of a local variable starts
from its declaration and continues to
the end of the block that contains the
variable. A local variable must be
declared before it can be used.
The Keyword this

Use this to refer to the current object.

Use this to invoke other constructors of
the object.
Array of Objects
Circle[] circleArray = new Circle[10];
An array of objects is actually an array of
reference variables. So invoking
circleArray[1].findArea() involves two levels of
referencing as shown in the next figure.
circleArray references to the entire array.
circleArray[1] references to a Circle object.
Array of Objects, cont.
Circle[] circleArray = new
Circle[10];
circleArray
reference
circleArray[0]
circleArray[1]
Circle object 0
…
Circle object 1
circleArray[9]
Circle object 9
Class Abstraction
Class abstraction means to separate class
implementation from the use of the class.
The creator of the class provides a
description of the class and let the user
know how the class can be used. The user
of the class does not need to know how the
class is implemented. The detail of
implementation is encapsulated and hidden
from the user.
Java API and Core Java
classes

java.lang
Contains core Java classes, such as numeric
classes, strings, and objects. This package
is implicitly imported to every Java
program.

java.awt
Contains classes for graphics.

java.applet
Contains classes for supporting applets.
Java API and Core Java
classes, cont.

java.awt.image
Contains classes for managing bitmap
images.

java.awt.peer
Platform-specific GUI implementation.

Others:
java.sql
java.rmi
Summary
Java
is
interpreted
and
compiled
language.
 Java is fully object oriented and machine
independent language.
