Transcript Web Application Development

Web Application Development
Slides Credit
Umair Javed
LUMS





History of Java
Why Java ?
Some Sample Java Based Applications
Writing a Basic Java Program
Java Program Development and Execution
Steps

Java
 Based on C and C++
 Developed in 1991 for intelligent consumer electronic devices
 Green Project (According to Gosling, "the goal was ... to build a
system that would let us do a large, distributed, heterogeneous
network of consumer electronic devices all talking to each other." )
 James Gosling Modified C++
 Named Oak then Java







Platform independent
Interpreted Language
Intermediate Code (Byte Code)
Reliable
Multiple inheritance and Operator
overloading removed
No Pointers because of security reasons
Built in network support
 Internet exploded in 1993, saved project
▪ Reliability
▪ Security
▪ Platform Independence
 Java formally announced in 1995
 Now used to create interactive web
applications, distributed enterprise application
for consumer devices (pagers, cell phones) and
much more..





Portable WORA!!!!!!
Simple
“Pure” Object Oriented Language
Support for Distributed and Web Applications
Rich Libraries
 Multithreading , Swing , RMI , NET , SQL …..


Automatic Garbage Collection
More Robust


“Write-Once Run-Anywhere”
The Java Virtual Machine becomes the
common denominator
 Bytecodes are common across all platforms
 JVM hides the complexity of working on a
particular platform
▪ Difficult to implement a JVM
▪ But simpler for the application developer

Java does this well
App1
App2
App3
App4
App5
Java Virtual Machine
Windows
Intel
Linux
OS X
PowerPC
Solaris
Linux
SPARC


Similar to C/C++ in syntax
In-fact Java is C++ minus




operator overloading
direct pointer manipulation or pointer arithmetic
multiple inheritance
Destructors (Garbage Collector– handles memory
automatically)
 No Templates
 Header/make files

Lots of other things which make Java more attractive.

Fundamentally based on OOP

All functions belong to classes or objects. No global variables
or functions exist

All classes by default inherit from a common ancestor known
as “Object”

“Almost” all data types are objects

OOP will be covered in a little more detail later.

Java grew up in the days of the Internet
 Inherently network friendly
 Original release of Java came with Networking
libraries
 Newer releases contain even more for handling
distributed applications
 RMI, Transactions

Given below are some of the Java technologies that can be
used for web and enterprise application development







Servlets
JSP
Applets
JDBC
RMI
EJBs
JSF
And many more…

Designed with the intention of being secure
 No pointer arithmetic or memory management!
 The JVM “verifier”
 Checks integrity of byte-codes
 Dynamic runtime checking for pointer and array access
 No buffer overflow bugs!
 SecurityManager to check which operations a piece of code is
allowed to do
 “Sandbox” operation for applets and other untrusted code
 Limited set of operations or resources made available
 Contrast to ActiveX







Multithreading
Swing
Regular Expression
NET
SQL
Util
Serialization …………….

Faster Development
 More programmer friendly
 Less error prone

OOP
 Easier to manage large development projects

Robust memory system
 No pointer arithmetic and manual memory
management. Garbage collector!

Libraries
 Re-use of code

Java performance IS slower than C/C++
 Tradeoff between development time vs. run time
 Additional checks in Java which make is secure and robust and
network aware etc, all have a small cost.

BUT
 JIT compilation and HotSpot
 Dynamic compilation of bytecode to native code at runtime to
improve performance
 HotSpot optimizes code on the fly based on dynamic execution
patterns
 Can sometimes be even faster than compiled C code!

Increasing processing speeds helps in overcoming this short
fall

Java is platform independent
 Was considered a threat to Microsoft’s dominance
 Sun vs. Microsoft Law Suit

Microsoft’s latest response to Java
 C#
 Very similar to Java in structure and style
 Some improvements over past releases of Java (which
have now emerged in Java 1.5)
 NASA Goddard’s most
successful project ever
 Launched in 1990.
 Has sensitive light
detectors and cameras
 Provided view of galaxies
up to 10 billion light years
away
 Used for world-wide data
viewing
 Winner of the 1997 NASA
software of the year
 The current rover location is
displayed, along with visual
indications of “targets”
 Provides close-ups of the
wedge photograph
 Java Programmable
 RoboJDE™ java enabled
robotics software
development environment
 Makes developing,
debugging robotics program
a snap
 Cross platform Office
suite completely written
in java
Syntax for C++ programmers

For the start following software will do the
job
 You need to have the latest version of JDK. (J2SE
6.0) You can download it for free from
 http://java.sun.com/j2se/
 A little older versions such as JDK 5 ( JDK 1.5) or 1.4 will
also work
 Notepad
 And you should set your path variable.
/* The HelloWorldApp class implements an application that simply
displays "Hello World!" to the standard output. */
public class HelloWorldApp {
public static void main(String[] args) {
//Display the string. No global main
System.out.println("Hello World!");
}
}

Save this file in some directory and compile it
using
 javac HelloWorldApp.java

Run the compiled file by using the command
 java HelloWorldApp

Java Systems
 Consist of environment, language, Java Applications Programming
Interface (API)
 Java programs have five phases
1. Edit
▪ .java extension
2. Compile
▪ javac command: javac MyProgram.java
▪ Creates .class file containing bytecodes with similar name
3. Loading
▪ Class loader transfers .class file into memory
▪ Classes loaded and executed by interpreter with
java command
▪ To load,
java MyProgram
4. Verify
▪ Bytecode verifier makes sure bytecodes are valid
and do not violate security
5. Execute
▪ Computer interprets program one bytecode at a
time
▪ Performs actions specified in program
Phase 1
Editor
Disk
Phase 2
Compiler
Disk
Primary
Memory
Phase 3
Phase 5
Compiler creates
bytecodes and stores
them on disk.
Class Loader
Disk
Phase 4
Program is created in
the editor and stored
on disk.
Class loader puts
bytecodes in memory.
..
..
..
Primary
Memory
Bytecode Verifier
Interpreter
..
..
..
Primary
Memory
..
..
..
Bytecode verifier
confirms that all
bytecodes are valid
and do not violate
Java’s security
restrictions.
Interpreter reads
bytecodes and
translates them into a
language that the
computer can
understand, possibly
storing data values as
the program executes.

Naming Conventions
 MyClass
 myMethod()
 myVariable
 MY_CONSTANT

Things to Remember

Taking in command line arguments

Primitives vs. Objects

Wrapper classes and Conversions

Taking Input and Output using Swing

Selection and Control Structures

File: HelloWorldApp.java
public class HelloWorldApp{
public static void main(String[] args) {
System.out.println("Hello world");
}
}

Name of file must match name of class
 It is case sensitive

Processing starts in main
 public static void main(String[] args)

Printing is done with System.out
 System.out.println, System.out.print

Compile with “javac”
 Open DOS/command prompt window; work from there
 Supply full case-sensitive file name (with file extension)

Execute with “java”
 Supply base class name (no file extension)

You will see the following line of code often:
 public static void main(String args[]) { …}

About main()
 “main” is the function from which your program starts
 Why public?
▪ So that run time can call it from outside
 Why static ?
▪ it is made static so that we can call it without creating an object
 What is String args[] ?
▪ Way of specifying input at startup of application

“+” operator when used with Strings concatenates them
 System.out.pritln(“Hello” + “World”) will produce Hello World on console
 String concatenated with any other data type such as int will also convert
that datatype to String and the result will be a concatenated String
displayed on console
▪ For Example
▪ int i = 4
▪ int j = 5 ;
▪ System .out.println (“Hello” + i) // will print Hello 4 on screen
▪ However
▪ System,.out..println( i+j) ; // will print 9 on the console
 For comparing Strings never use == operator, use equals method.
▪ == compares addresses (shallow comparison) while equals compares values
(deep comparison)
▪ E.g string1.equals(string2)
public class StringTest {
public static void main(String[] args) {
int i = 4;
int j = 5;
System.out.println("Hello" + i);
System.out.println(i + j);
String s1 = new String (“pakistan”);
String s2 = “pakistan”;
if (s1 == s2) {
System.out.println(“comparing string using == operator”);
}
}
if (s1.equals( s2) ) {
System.out.println(“comparing string using equal method”);
}
}
/* This program will take two arguments Hello World from the command prompt and
prints them to standard console. If you specify less than two arguments an
exception will be thrown */
public class TwoArgsApp {
public static void main(String[] args) {
//Displays the first argument on console
System.out.println(“First argument “ + args[0]);
//Displays the second argument on console
System.out.println(“Second argument “ + args[1]);
}
}
/* This program is able to receive any number of arguments and prints them to console
using for loop. In java, arrays knows about their size by using length property
*/
public class AnyArgsApp {
public static void main(String[] args) {
for (int i=0; i<args.length; i++) {
// The “+” operator here works similar to “<<“ operator in C++. This line is
// equivalent to cout<<“Arguments:”<<i<<“value”<<args[i];
// where cout is replaced by System.out.println, and “<<“ is replaced by + for
// concatenation
}
}
}
System.out.println(“Argument:” + i + “value: ” + args[i] );

Everything in Java is an “Object”, as every class by default inherits from class
“Object” , except a few primitive data types, which are there for efficiency reasons.

Primitive Data Types

8 Primitive Data types of java
▪ boolean, byte
▪ char, short
▪ int, float
▪ long, double




1 byte
2 bytes
4 bytes
8 bytes

Primitive data types are generally used for local variables, parameters and instance
variables (properties of an object)

Primitive datatypes are located on the stack and we can only access their value,
while objects are located on heap and we have a reference to these objects

Also primitive data types are always passed by value while objects are always passed
by reference in java. There is no C++ like methods
 void someMethod(int &a, int & b ) // not available in java
public static void main(String args[])
{
int num= 5;
Student st = new Student();
Stack
Heap
num
5
0F59
}
name
st
0F59
ali

For all built-in primitive data types java uses
lowercase. E.g int , float etc

Primitives can be stored in arrays

You cannot get a reference to a primitive
 To do that you need an Object or a Wrapper class


Each primitive data type has
a corresponding object
(wrapper class)
These Wrapper classes
provides additional
functionality (conversion,
size checking etc), which a
primitive data type can not
provide
Primitive
Data Type
byte
short
int
long
float
double
char
boolean
Corresponding
Object Class
Byte
Short
Integer
Long
Float
Double
Character
Boolean

You can create an object of Wrapper class using a String or a
primitive data type
 Integer num = new Integer(4); or
 Integer num = new Integer(“4”);
 Num is an object over here not a primitive data type

You can get a primitive data type from a Wrapper using the
corresponding value function
 int primNum = num.intValue();
Stack
public static void main(String args[])
{
int num= 5;
Heap
num
5
Integer numObj = new Integer (10);
}
04E2
numObj
04E2
10

Defines useful constants for each data type
 For example,
Integer.MAX_VALUE

Convert between data types
 Use parseXxx method to convert a String to the corresponding
primitive data type
▪ String value = “532";
int d = Integer.parseInt(value);
▪ String value = "3.14e6";
double d = Double.parseDouble(value);
Data Type
byte
new
short
new
int
new
long
new
float
new
double
new
Convert String using either …
Byte.parseByte(string )
Byte(string ).byteValue()
Short.parseShort(string )
Short(string ).shortValue()
(string)
Integer.parseInteger(string
)
Integer(string ).intValue()
Long.parseLong(string )
Long(string ).longValue()
Float.parseFloat(string )
Float(string ).floatValue()
Double.parseDouble(string )
Double(string ).doubleValue()

When a method does not except an int primitive but still you need to
pass an int value, you can use the corresponding Wrapper.
 someVector.add(new Integer(4) ); // this was required prior to jdk5.0

Boxing/Unboxing Conversions
 New feature added in j2se 5.0
 Boxing
▪ Integer iWrapper = 10;
▪ Prior to J2SE 5.0, we use
▪ Integer a = new Integer(10);
 Unboxing
▪ int iPrimitive = iWrapper;
▪ Prior to J2SE 5.0, we use
▪ int b = iWrapper.intValue();

System class
 Out represents the screen

System.out.println()
 Prints the string followed by an end of line
 Forces a flush

System.out.print()
 Does not print the end of line
 Does not force a flush

System.out.flush()
 Force a flush
/* This program will takes the input (number) through GUI and prints its square on the
console as well as on the GUI. */
import javax.swing.*;
public class InputOutputTest {
}
public static void main(String[] args) {
//takes input through GUI
String input = JOptionPane.showInputDialog("Enter the number");
int number = Integer.parseInt(input);
int square = number * number;
//Display square on console
System.out.println("square:" + square);
//Display square on GUI
JOptionPane.showMessageDialog(null, "square:"+ square);
System.exit(0); //Don’t forget to write when using JOptionPane. Don’t need it in
//J2SE 5.0
}
/* This program will demonstrates the use of if-else selection structure. Note that its syntax is very similar to
C++
*/
public class IfElseTest {
public static void main(String[] args) {
int firstNumber = 10;
int secondNumber = 20;
//comparing first number with second number
if (firstNumber > secondNumber) {
System.out.println(“first number is greater than second”);
}
else if (firstNumber == secondNumber) {
System.out.println(“first number is equals to second number”);
}
else {
System.out.println(“first number is smaller than second number”);
}
}
}

==, !=
 Equality, inequality. In addition to comparing primitive types, ==
tests if two objects are identical (the same object), not just if
they appear equal (have the same fields). More details when we
introduce objects.

<, <=, >, >=
 Numeric less than, less than or equal to, greater than, greater
than or equal to.

&&, ||
 Logical AND, OR. Both use short-circuit evaluation to more
efficiently compute the results of complicated expressions.

!
 Logical negation.
import javax.swing.*;
public class SwitchTest {
public static void main(String[] args) {
int operand1 = 10;
int operand2 = 20;
String choice = JOptionPane.showInputDialog(“Enter 1 for
sum, 2 for product”);
int ch = Integer.parseInt(choice);
// continue….
switch(ch)
{
case 1:
int sum = operand1 + operand2;
System.out.println(“sum: ” + sum );
break;
case 2:
int product = operand1 * operand2;
System.out.println(“product: ” + product );
break;
default:
System.out.println(“wrong choice!”);
}
System.exit(0);
}
}

while
while (continueTest) {
body;
}

do-while
do {
body;
} while (continueTest);
// ^ don’t forget semicolon

for
for(init; continueTest; updateOp) {
body;
}
public class ControlStructTest {
public static void main(String[] args) {
}
// for loop
for (int i=1; i<= 5; i++) {
System.out.println("hello from for");
// while loop
int j = 1;
while (j <= 5) {
System.out.println("Hello from while");
j++;
}
}
}
//do while loop
int k =1;
do{
System.out.println("Hello from do-while");
k++;
}while(k <= 5);