JAVA
Lecture
By: Muhammad Zeeshan Ali
Performing Basic
Tasks
in Java
Topics We Will Cover Today
Naming Conventions
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 class)
Understanding Basics
Naming Conventions
MyClass
myMethod()
myVariable
MY_CONSTANT
Last Lecture Example
File: HelloWorldApp.java
public class HelloWorldApp{
public static void main(String[] args) {
System.out.println("Hello world");
}
}
Compile and Execute
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?
Why static ?
So that run time can call it from outside
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]);
}
}
Compile and Execute
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
public static void main(String args[])
{
int num= 5;
Student st = new Student();
Stack
Heap
num
5
0F59
name
st
0F59
ali
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
(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
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
Stack vs. Heap
Stack
public static void main(String args[])
{
int num= 5;
Integer numObj = new Integer (10);
Heap
num
04E2
numObj
04E2
10
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
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()
Integer.parseInteger( string )
Integer( string ).intValue()
Long.parseLong( string )
Long( string ).longValue()
Float.parseFloat( string )
Float( string ).floatValue()
Double.parseDouble( string )
Double( string ).doubleValue()
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
Input Using Scanner
import java.util.Scanner;
public class RunTimeInput{
public static void main(String args[]){
Scanner inputScanner = new Scanner(System.in);
int a , b;
float f;
System.out.print("Enter 1st Number = ");
a = inputScanner.nextInt();
System.out.print("Enter 2nd Number = ");
b = inputScanner.nextInt();
System.out.print("Enter Float Number = ");
f = inputScanner.nextFloat();
System.out.println("Sum = " + (a+b));
}
}
Compile and Execute
Selection Structures
if-else and switch
ifelse 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 java.util.Scanner;
public class SwitchStatement{
public static void main(String args[]){
char ch = 'a';
switch(ch){
case 'a':
System.out.println("Vowel");
break;
case 'e':
System.out.println("Vowel");
break;
case 'i':
System.out.println("Vowel");
break;
switch Selection Structure
case 'o':
System.out.println("Vowel");
break;
case 'u':
System.out.println("Vowel");
break;
default:
System.out.println("Not a Vowel");
}
}
}
Compile and Execute
Control Structures
for, while & do-while
Looping Constructs
while
while (continueTest) {
body;
}
do
do {
body;
} while (continueTest);
// ^ dont 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
