Java Lec03


  • File:

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 methos.
      • == 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 (“test”);

String s2 = “test”;

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 à   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



A Stack is a Last In First Out (LIFO) data structure. It supports two basic operations called push and pop. The push operation adds an element at the top of the stack, and the pop operation removes an element from the top of the stack. Java provides a Stack class which models the Stack data structure and The Java heap is the area of memory used to store objects instantiated by applications running on the JVM. When the JVM is started, heap memory is created and any objects in the heap can be shared between threads as long as the application is running. following is the example program:

public static void main(String args[])


int num= 5;


Student  st = new Student();



public static void main(String args[])


int num= 5;


Integer numObj = new Integer (10);



  • 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 Corresponding
Data Type Object Class
  byte   Byte
  short   Short
  int   Integer
  long   Long
  float   Float
  double   Double
  char   Character
  boolean   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();

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);

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();


Data Type Convert String using either …
  byte        Byte.parseByte(string)
   new Byte(string).byteValue()
  short        Short.parseShort(string)
   new Short(string).shortValue()
  int        Integer.parseInteger(string)
   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()


  • 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 Example Program

/*  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);




/* 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);



case 1:

int sum = operand1 + operand2;

System.out.println(“sum: ” + sum );


case 2:

int product = operand1 * operand2;

System.out.println(“product: ” + product );



System.out.println(“wrong choice!”);





  • while
    • while (continueTest) {
    • body;
    • }
  • do
    • 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”);




//do while loop

int k =1;


System.out.println(“Hello from do-while”);


}while(k <= 5);



Learn More:

For solution, online support and query email us at .

Leave a Comment

Your email address will not be published. Required fields are marked *

error: Content is protected !!