Adv Java Programming

Performing Basic
Tasks
in Java
 Topics We Will Cover Today
 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
 OOP in java (Defining and using classe)
 Last Lecture Example
 File: HelloWorldApp.java

public class HelloWorldApp{

public static void main(String[] args) {

System.out.println("Hello world");

}
}
 Things to remember
 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)
 An idiom explained
 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
 Things to Remember
 “+” 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

methos.
 == compares addresses (shallow comparison) while equals
compares values (deep comparison)
 E.g string1.equals(string2)
 String Concatenation
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”);
}
}
}
Compile and Execute
Taking in Command
Line Arguments
 Taking in Command Line
Arguments
/* 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]);
}
}
 Passing any Number of Arguments
/* 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] );

}
}
}
Compile and Execute
Primitives Vs. Objects
 Primitives Vs. Objects
 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  1 byte
 char, short  2 bytes
 int, float  4 bytes
 long, double  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
 Stack vs. Heap
Stack Heap
public static void main(String args[])
{
int num= 5; num
5
Student st = new Student();

} 0F59
name ali
st
0F59
Primitives (cont)
 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
Wrapper Classes
 Wrapper Classes
 Each primitive data type
has a corresponding object Primitive Corresponding
(wrapper class) Data Type Object Class
byte Byte
short Short
 These Wrapper classes int Integer
provides additional long Long
float Float
functionality (conversion, double Double
size checking etc), which a char Character
primitive data type can not boolean Boolean
provide
Wrapper Use
 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 vs. Heap
Stack Heap
public static void main(String args[])
{
int num= 5; num
5
Integer numObj = new Integer (10);
}
04E2

10
numObj

04E2
 Wrapper Uses
 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);
Wrappers: Converting Strings
Data Type Convert String using either …
byte Byte.parseByte(string )
new Byte(string ).byteValue()
short Short.parseShort(string )
new Short(string ).shortValue()
int (stringstring
Integer.parseInteger( ) )
new Integer(string ).intValue()
long Long.parseLong(string )
new Long(string ).longValue()
float Float.parseFloat(string )
new Float(string ).floatValue()
double Double.parseDouble(string )
new Double(string ).doubleValue()
Wrapper Uses
 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 the
l

 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();
Input / Output
Console based Output
System.out
 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
Input / Output

/* 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
}
}
Compile and Execute
Selection Structures
if-else and switch
 if–else Selection Structure
/* 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”);
}
}
}
Compile and Execute
 Boolean Operators
 ==, !=
 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.
 switch Selection Structure
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 Selection Structure…
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);
}
}
Compile and Execute
Control Structures
for, while & do-while
Looping Constructs
 while
while (continueTest) {
body;
}
 do
do {
body;
} while (continueTest);
// ^ don’t forget semicolon

 for
for(init; continueTest; updateOp) {
body;
Control Structures
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);
}
}
Compile and Execute