Synchronized Keyword

http://www.try2catch.in

Synchronized is a keyword use for thread concepts. There are chances when two or more threads are trying to access same resource. At this point, program will get stuck or hang. So to come over this situation java has synchronized keyword.

We just need to share those resources to synchronized block.

public class TryCatch {

       public static void main(String args[]) {

              CounterDemo counterDemo = new CounterDemo();

              ThreadDemo thread1 = new ThreadDemo("Thread - 1 ", counterDemo);

              ThreadDemo thread2 = new ThreadDemo("Thread - 2 ", counterDemo);

              thread1.start();

              thread2.start();

              try {

                     thread1.join();

                     thread2.join();

              } catch (Exception e) {

                     System.out.println("Interrupted");

              }

       }

}

class CounterDemo {

       public void counterCount() {

              try {

                     for (int i = 0; i <= 10; i++) {

                           System.out.println("Counter   ---   " + i);

                     }

              } catch (Exception e) {

                     System.out.println("Thread  interrupted.");

              }

       }

}

class ThreadDemo extends Thread {

       private Thread thread;

       private String threadName;

       CounterDemo counterDemo;

       ThreadDemo(String name, CounterDemo counterDemo) {

              threadName = name;

              this.counterDemo = counterDemo;

       }

       public void run() {

              /*

               * Try to run this code with uncomment and comment line 53. You will see

               * the difference

               */

             

              // counterDemo.counterCount();

              synchronized (counterDemo) {

                     counterDemo.counterCount();

              }

              System.out.println("Thread " + threadName + " running...");

       }

       public void start() {

              System.out.println("Starting " + threadName);

              if (thread == null) {

                     thread = new Thread(this, threadName);

                     thread.start();

              }

       }

}

Instanceof Keyword

http://www.try2catch.in

It is very common, when we get ClassCastException. To get over this, we have instanceof keyword.

instanceof keyword is use to check the object is a instance of specified type.

if (objectReference instanceof type)
The following if statement returns true.

public class TryCatch {
public static void main(String[] args) {

String name = null;
if (name instanceof java.lang.String) {
System.out.println("True");
} else {
System.out.println("False");
}
}

}

Above code will print True.


When we apply instanceof on a null variable, it returns False. Below is the code sample for reference.

public class TryCatch {
  public static void main(String[] args) {

    String name = null;
    if (name instanceof java.lang.String) {
      System.out.println("True");
    } else {
      System.out.println("False");
    }
  }

}


Is a child class also the instance of parent class? Answer is Yes and to prove this refre to the below code.

class Vehicle {

public Vehicle(){

}

}

class Car extends Vehicle {

public Car(){

super();
}

}

public class TryCatch {
public static void main(String[] args) {

Car car = new Car();
if (car instanceof Vehicle) {
System.out.println("True");
} else {
System.out.println("False");
}

}

}

Exception Keywords

http://www.try2catch.in

Try: Try is a keyword and a block comes under Exception handling tasks. Between this block, we write the tricky codes or the codes which may raise exception at runtime.

Catch: Catch is a keyword and a block. Which is use to handle the exceptions raise due to the code in try block. There can be multiple catch blocks with a single try block.

Finally: Finally is a keyword use to free the resources after the execution of code, written in try and catch block. This is the only block which will always execute, whether there is any exception or not.

Throw: Throw is use to generate custom exceptions, created by developer. We can generate both compile and runtime exceptions both. In this case, declared methods will handle the exception

Throws: Throws keyword is use to define, what type of exception may occur while execution of the method. The implementing class will handle the exception.

TryCatch

Exception

What is Exception?

Exception is an episode that breaks the flow of program. Exceptions can handle in java by using handling method.

Now, let’s discuss about exception in brief.

Exceptions are of two types, CompileTimeException and RunTimeException.

CompileTimeException: This type of exception also known as Checked Exception. It means the exceptions which are caught at time of coding by compiler. If there is exception then, it must be handled or specify the exception using throws keyword.

Example, you write a java program that read a file from location “C:\java\file.txt” and prints text written in it. The program doesn’t compile, because the function main() uses FileReader() which throws a checked exception FileNotFoundException. It also uses readLine() and close() methods, and these methods also throw IOException.

import java.io.*;

public class FileReadOperation {

       public static void main(String[] args) {

              FileReader file = new FileReader("C:\\java\\file.txt");

              BufferedReader fileInput = new BufferedReader(file);

            for (int counter = 0; counter < 5; counter++)

                     System.out.println(fileInput.readLine());

              fileInput.close();

       }

}

  

RunTimeException: This type of exception also known as Un-Checked and Error. It means the exceptions which are not caught at time of coding by compiler.

Example, below program compiles without any Checked Exception, but it throws ArithmeticException when run. The compiler allows it to compile, because ArithmeticException is an unchecked exception.

public class Divide {

          public static void main(String args[]) {

                    int a = 0;

                    int b = 10;

                    int c = y/x;

                }

}

Error: Errors are those events which could not handle at developer’s level and may not even at the same time of error generation. Like any type of hardware and software problem. Example heap’s OutOfMemoryError.

http://www/try2catch.in

Modifier Keywords (Protected, Final, Abstract, Default)

Protected: Protected keyword can be use with variable, methods and constructor. These member only could be accessible to child class in different package and with in the class of same package.

Final: Final keyword can be use with variable, method and class. It behaves different in each case.

Variable: Final Variable could not be re-initializing. It must be initializing at the time of declaration.

Method: Final Method never overrides.

Class: Final class never extends.

Abstract: Abstract keyword can be use with a class and method. When a class defined as abstract, it means the class may have abstract methods or a method, which do not have it body or implementation.

When a class declared as abstract, it’s not necessary that the class has abstract methods. It can contain normal methods. But if, a method declared as abstract then the class must be declared as abstract.

Default: When we are not declaring any modifier with members, compiler automatically declares as default. A method and a variable can be declared as default. But, accessible within same package.

Java Keywords (Return, Super, This)

http://www.try2catch.in

Return: This keyword is a keyword. This can be use with methods, loops, and statements. The behavior of return is different with different scenarios.

1)   Methods: Return keyword is always used with method when the return type is not void. Return type of methods could be anything. The return value must be as the return type declared with method signature.

package com.demo;

public class DemoClass {

       public String getName() {

              String name = "Try Catch";

              return name;

       }

}

2)   Loops: In context of loops, return keyword used when we want to exit from loop. Here is no need to declare return value.

package com.demo;

public class DemoClass {

       public void getName() {

              while (true) {

                     System.out.println("Try Catch");

                     return;

              }

       }

}

Super: Super is a keyword which is use to access the members of super or parent class. To use super keyword, inheritance must be there. This keyword could use with following statements:

package com.demo;

public class SuperClass {

       String name = "Instance varibale of SuperClass";

      

       public SuperClass() {

              System.out.println("Super class constructor...");

       }

      

       void getName(){

              System.out.println("Method of Super class...");

       }

}

1)    Instance Variables: Super keyword use to access or call the instance variable of parent or super class into child or base class.

2)    Constructor: Using super keyword, we can call the constructor of super class. You will see that, while calling super class constructor there is () brackets. This is because; constructor is also like a normal method. So to tell compiler that, we are calling constructor not other members of super class, we have to use these brackets.

3)    Methods: Methods of super call can be access using super keyword.

package com.demo;

public class BaseClass extends SuperClass {

       String name = "Try Catch";

       public BaseClass() {

              super();

       }

       public static void main(String[] args) {

              BaseClass base = new BaseClass();

              base.getName();

              base.showMethod();

             

       }

       void getName() {

              System.out.println(super.name);

       }

       void showMethod() {

              super.getName();

       }

}

This: This keyword is to use to call all the members of same class rather than super class. Rest behavior is always same as super keyword.

package com.demo;

public class BaseClass extends SuperClass {

       String name = "Try Catch";

       public BaseClass() {

              System.out.println("Basse class constructor...");

       }

       public static void main(String[] args) {

              BaseClass base = new BaseClass();

              base.getName();

              base.showMethod();

       }

       void getName() {

              System.out.println(this.name);

       }

       void showMethod() {

              this.getName();

       }

}