There are 4 types of access specifiers in java for SDET:

• Public: Public class, public methods, or public variables can be accessed from anywhere.

• Protected: Protected methods or fields can be accessed from the same class, or subclass, or from the class within the same package.

• Private: Private methods or fields can be accessed only from the same class to which they belong.

• Default: Default methods or Default fields or Default class can be accessed only from the same class or from the same package.

The OOPS principles in Java are as follows:

• Abstraction: Abstraction is used to hide internal details and showing only the functionality. In Java, we use abstract class and interface to achieve abstraction.

• Encapsulation: Encapsulation means to bind or wrap code and data together into a single unit. A Java class is an example of Encapsulation.

• Polymorphism: Polymorphism means that one task is performed in different ways. There are 2 types of Polymorphism: Run-time Polymorphism and Compile-Type polymorphism.

• Inheritance: Inheritance means acquiring all the properties and behavior of an object. It provides code re-usability.

An inner class is defined as a class which is nested within another class. An inner class can access all methods and variables that are defined in the outer class.

Subclass is defined as a class which is inherited from some another class, which is called a superclass. A subclass can access only public and protected method and fields of its superclass.

Yes, we can overload main() method like other methods.

But when we run the program, the program doesn’t execute the overloaded main method, so we need to call the overloaded main method from the actual main method only.

In Java for SDET, Final keyword can be used with variable, method and class.

If a variable is declared using a Final keyword, then its value can be assigned only once and after assignment, it can’t be changed.

If a method is declared using a Final keyword, then this method cannot be overridden by the subclasses.

If a class is declared using a Final keyword, then this class cannot be inherited.

Abstract ClassInterfaceIt can have abstract and non-abstract methods It can have abstract methods only.

Abstract keyword is used to declare an abstract class Interface keyword is used to declare an interface. It can extend another Java class and implement multiple Java interfaces. It can extend another Java interface only It can have class members like private, protected, etc. Members of Interface are public by default It can have final, non-final, static and non-static variables It has only static and final variables. It can provide the implementation of interface, It can’t provide the implementation of abstract class

Local Variables: Local Variables are defined within a block or method or constructor.

These variables are created when the block is entered and destroyed after exiting from the block. We can access these variables only within the block where they are declared. We cannot use any access specifier with local variables.

Instance Variables: Instance variables are declared in a class outside any method, block or constructor.

These variables are created when an object of the class is created and destroyed when the object is destroyed. We can access these variables only by creating objects.

We can use access specifiers for instance variables. If no access specifier is specified, then the default access specifier is used.

Java Tutorials

The main method must always be public static in order to run any application correctly in Java. If the main method is declared as private, then it will not give any compilation error, but the program will not get executed and will give a run-time error.

A constructor is defined as a member function in a class which has the same name as of class.

It is automatically called at the run-time whenever an object class is created. It doesn’t have any return type.

Need of Constructor:There might be a situation where exposing the class variable to the main program is not secured. At that time, the class variables can be declared as private because the private variables are not accessible from the other class. In such a situation, if constructors are defined, then the main method need not access the class variables directly.

There are 2 types of constructors in Java:

• Default Constructor: In Java, the Default constructor is the one which does not accept any input. It is used to initialize the instance variable with the default values and is majorly used for object creation. A default constructor is invoked implicitly by the compiler if no constructor is defined by the user.

• Parameterized Constructor: In Java, the Parameterized constructor is the one which is capable of initializing the instance variables with the given values. In other words, those constructors that accept the arguments are called parameterized constructors.

this() and super() both are used to call the constructor.

this()super()It represents the current instance of a class.It represents the current instance of parent class.It is used to call the default constructor of the same class.It is used to call the default constructor of the parent class.It is used for pointing the instance of a current class.It is used to point the instance of parent class.It is used to access methods of the current class.It is used to access the methods of parent class.

Try block always needs to be followed by either catch block or finally block, or both.

If any exception is thrown from try block, then it should either be caught in catch block or if any specific tasks needs to be performed before abortion, then they are put in a final block.

A thread is a piece of code which can be executed independently.

In Java, all program has at least one thread called as the main thread that is created by JVM. The main thread is used to invoke the main() method of the program. Threads are executed concurrently.

The user can create their own threads by following 2 ways:

• By extending Thread class:

public class Test extends Thread{public void test2() {}}

• By Implementing Runnable Interface:

publicclass Test implements Runnable{ publicvoid test2() { }}

New: In this state, the thread has been created but start() method is not invoked yet.

Runnable: The thread is in the runnable state after start() method is invoked but before the invocation of run() method.

Running: The thread is in running state after the invocation of run() method.

Blocked: The thread is alive, but it is not eligible to run.

Terminated: The thread is in the terminated state when the run() method is completed

Method overloading is a feature that allows a class to have more than one method with the same name and different parameters.

We can overload the method by either changing the number of arguments or changing the data

public class Test {
public static int add(int a, int b) {return a+b};
public static int add(int a, int b, int c) {return a+b+c};
}
public class TestOverloadingMethod {
public static void main(String[] args)
{ System.out.println(Test.add(10,11));
System.out.println(Test.add(10,11,12)); }

Method overriding is a feature that allows a sub-class (child class) to have the same method (with the same name and same parameters) as that in the superclass (parent class).

Method Overriding is used for run time polymorphism

public class Vehicle
{
void run()
{
System.out.println(“Vehicle is running”);
}
}
//Creating a child class
class Bike extends Vehicle{
public static void main(String args[]){
//creating an instance of child class
Bike obj = new Bike();
//calling the method with child class instance
obj.run();
}
}

A collection is a group of objects represented as a single unit. It is a framework that provides an architecture to store the objects and manipulate a group of objects.

Collections are used to perform the following operations:

• Searching

• Sorting

• Manipulation

• Insertion

• Deletion

Exception is a problem that occurs when the normal flow of program is disrupted and therefore a program or application terminates abnormally.

Exceptions are a subclass of java.lang.Exception

To maintain the normal flow of application, we can handle the Exception through Exception handling.

Exception handling is a process to handle run-time errors such as IOException, SQLException, etc.

There are two types of Exception:

• Checked Exceptions: Checked Exceptions are the exceptions that are checked at the time of compilation by the compiler. These type of exceptions should be handled by the programmer.

• Eg.: FileNotFoundException, SQLException,etc.

• Unchecked Exceptions: Unchecked Exceptions are the exceptions that are not checked at the time of compilation, but they occur at the time of execution. They are also called as Runtime Exceptions.

• Eg.: Arithmetic Exception, NullPointerException.

👉Certified SDET Professional Training

👉Certified SDET Python Training