JAVA Syntax

First Java

public class HelloWorld{
	public static void main (String[] args){     
		/* 
			
		*/
		System.out.println("HelloWorld");
	}
}

What is package?

• java.lang the basic package automatically imported for every java program. Including stuff like Object, String, String Buffer, System, etc

• java.util the utilities packages

• java.iosystem input and output

• java.netfor network related functions

//import the Date class under the util
import java.util.Date;

//import the Random class under util
import java.util.Random;

// for the package that we created ourselves

import your.package.name.TestClass;

public class HelloWorld{
	public static void main (String[] args){
		System.out.println("HelloWorld");

		Random random = new Random();
		boolean flag = random.nextBoolean();
		System.out.println(flag);
	}
}

Java access modifier

• Public allow the code to be access by all external parties

• Protected allow access for the code in the same package and all child class

• Default allow access for code in the same package

• Private allow access for code in the same class only

package Chap4_2.Father;

public class Father {

    protected static void protected_method(){
        System.out.println("under protected");
        private_method();
    }
    private static void private_method(){
        System.out.println("This is printed under private");
    }
}

package Chap4_2.MainTest;
import Chap4_2.Father.Father;
public class MainTest extends Father{
    public static void main(String[] arg){
        Father father = new Father();
        father.protected_method();

        System.out.println("This is from the main function");
    }
}

Java basic data types

Java Array

//Declare array without initalising values
int [] numbers;

//use new to create array
int [] numbers2 = new int[100];

//initialise an array
int[] numbers = { 1,2,3,4,5,6 };

//create and initialise
int [][] numbers = {[1,2,3],[4,5,6],[7,8,9]}

//create
int [][] numbers2 = new int[3][3];

Stack and Heap

Non-primitive data have two storage area (one in stack one in heap)

• an object will request a space in heap in the ram to store it

• another area in the stack will be requested to store the address of the object in the heap space

 

int [] a = {1,2,3};
int [] b = a;
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));
b[0] = 0;
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));

Variable types

• declared using a static modifier

• can exist without any object

• can be access by ClassName.staticVariableName

• No matter now many objects has created from the class there is only one set of class varaible

• it is shared with all the objects created

• it is stored in method area different from heap and stack

public class Student{
	public static final String Prefix = "My name";
}

• Need to use Object.VariableName to access (for public variable)

• After instantiation the variable value is confirmed

• It is destroyed when the object is destroyed

• The object variable usually declared with private modifiers

• access to these variables through methods

public class Student{
	private age;
	private name;
	
	public void setAge(int age){
		this.age = age;
	}
	public void setName(String name){
		this.name = name;
	}
	public int getAge(){
		return this.age;	
	)
	public String getName(){
		return this.name;
	}
	
}

• the variable in method

• they are destroyed when the method finish executing

• modifiers cannot be used in the local variables

public class Student(){
	public void introduce(){
		String content = "My name is bla bla bla";
		System.out.println(content);	
	}
}

Java method parameter and return type

//if got something to return for the method
modifier returnType methodName (dataType1 dataName1,dataType2 dataName2...){
	//Code Block
	return
}
//if got nothing to return for the method
modifier void methodName (dataType1 dataName1,dataType2 dataName2...){
	//Code Block	
}

While loop

//keep carry out the loop content until the booleanExpression is false
while (booleanExpression){
	//loop content
}

//carry out the loop content once before looking at the boolean expression
do{
	//loop content
}while(booleanExpression);

For loop

for(initalisation;booleanExpression;update){
	//for loop content
}

//example

for (i=0;i<20;i++){
	Sysyem.out.println(i);
}

for(variableType variableName: arrayToBeLooped){
	//loop content
}

Switch

switch(expression){
	case value1:
		statement1; 
		break;
	case value2:
		statement2; 
		break;
	...

	default : //optional
	//statements
}

public class Test {

   public static void main(String args[]) {
      // char grade = args[0].charAt(0);
      char grade = 'C';

      switch(grade) {
         case 'A' :
            System.out.println("Excellent!"); 
            break;
         case 'B' :
         case 'C' :
            System.out.println("Well done");
            break;
         case 'D' :
            System.out.println("You passed");
         case 'F' :
            System.out.println("Better try again");
            break;
         default :
            System.out.println("Invalid grade");
      }
      System.out.println("Your grade is " + grade);
   }
}

Data Structures

• List (Ordered, Repetitive)

• Set (Unordered, Unrepetitive)

• Map (Key and value pair)

List Interface

• ArrayList
• It is a dynamic array, the capacity can grow on demand
• can only store objects but not primitive datatypes like int
• get and set operation are faster than LinkList
 

• LinkList
• The nodes have data and pointer segment where the pointer store the address of the next node
• The storage space in ram does not have to be continuous
• insertion and deletion of data is fast
• searching for data is slow since it involve the navigation of the pointer
 

import java.util.ArrayList;
public class ListTest {
    public static void main(String []args){
        ArrayList <String> arrayList = new ArrayList<>();
        arrayList.add("Tom");
        arrayList.add("Marry");
        arrayList.add("Jerry");
        arrayList.add("Jack");
        arrayList.add("Bob");

        System.out.println(arrayList);
        //[Tom, Marry, Jerry, Jack, Bob]

        String element = arrayList.get(2);
        System.out.println(element);
        //Jerry

        System.out.println(arrayList.size());
        //5

        arrayList.set(2,"Maria");
        System.out.println(arrayList);
        //[Tom, Marry, Maria, Jerry, Jack, Bob]

        System.out.println(arrayList.isEmpty());
        //false

        arrayList.remove(1);
        System.out.println(arrayList);
        //[Tom, Maria, Jack, Bob]

        arrayList.remove("Bob");
        System.out.println(arrayList);
        //[Tom, Maria, Jack]

        arrayList.clear();
        System.out.println(arrayList.isEmpty());
        //true
		}
}

import java.util.LinkedList;
public class ListTest {
    public static void main(String []args){
			LinkedList<String> linkedList = new LinkedList<>();
			//Operation similar to ArrayList, with few additional function
			linkedList.getFirst(); //first element in the linked list
			linkedList.getLast();//last element in the linked list
	}
}

Map

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapTest {
    public static void main(String [] args){
        HashMap <String, Integer> hashMap = new HashMap<>();
        hashMap.put("Bob",20);
        hashMap.put("Sandy",21);
        hashMap.put("Bob",22);   // overwrite the previous Bob with new value 22
        hashMap.put("Maria",20);
        hashMap.put("Fahar",20);

        System.out.println(hashMap.get("Sandy"));
        //21

        System.out.println(hashMap.containsKey("Fahar"));
        //true

        System.out.println(hashMap.containsValue(20));
        //true

        System.out.println(hashMap.values());
        //[22, 20, 21, 20]

        System.out.println(hashMap.size());
        //4

        System.out.println(hashMap.keySet());
        //[Bob, Fahar, Sandy, Maria]

        Set<Map.Entry<String, Integer>> entrySet = hashMap.entrySet();
        System.out.println(entrySet);
        //[Bob=22, Fahar=20, Sandy=21, Maria=20]

        hashMap.clear();
        
        System.out.println(hashMap.isEmpty());
        //true
    }
}

• Hash map is quick in indexing and storing but it is unsorted

• Tree map is sorted but slower in indexing and storing

• jdk1.7 vs jdk 1.8
• In jdk 1.7 Hash Map uses a combination of Array and Linked list
• in jdk 1.8 Hash Map uses a combination of Array, Linked list and red-black tree
• When the linked list is greater than 8(by default), it will be changed to a red-black tree