java basics

Java Basics

Click ★ if you like the project. Your contributions are heartily ♡ welcome.

Related Topics

• Multithreading
• Collections
• Java Database Connectivity (JDBC)
• Java Programs
• Java String Methods
• Jakarta Server Pages (JSP)
• Servlets
• Java Multiple Choice Questions
• Java Design Pattern
• Hibernate
• Spring Framework Basics

Table of Contents

• Introduction
• Java Architecture
• Java Data Types
• Java Methods
• Java Functional programming
• Java Lambda expressions
• Java Classes
• Java Constructors
• Java Array
• Java Strings
• Java Reflection
• Java Streams
• Java Regular Expressions
• Java File Handling
• Java Exceptions
• Java Inheritance
• Java Method Overriding
• Java Polymorphism
• Java Abstraction
• Java Interfaces
• Java Encapsulation
• Java Generics
• Miscellaneous

# 1. INTRODUCTION

Q. What are the important features of Java 8 release?

• Interface methods by default;
• Lambda expressions;
• Functional interfaces;
• References to methods and constructors;
• Repeatable annotations
• Annotations on data types;
• Reflection for method parameters;
• Stream API for working with collections;
• Parallel sorting of arrays;
• New API for working with dates and times;
• New JavaScript Nashorn Engine ;
• Added several new classes for thread safe operation;
• Added a new API for Calendarand Locale;
• Added support for Unicode 6.2.0 ;
• Added a standard class for working with Base64 ;
• Added support for unsigned arithmetic;
• Improved constructor java.lang.String(byte[], *) and method performance java.lang.String.getBytes();
• A new implementation AccessController.doPrivileged that allows you to set a subset of privileges without having to check all * other access levels;
• Password-based algorithms have become more robust;
• Added support for SSL / TLS Server Name Indication (NSI) in JSSE Server ;
• Improved keystore (KeyStore);
• Added SHA-224 algorithm;
• Removed JDBC Bridge – ODBC;
• PermGen is removed , the method for storing meta-data of classes is changed;
• Ability to create profiles for the Java SE platform, which include not the entire platform, but some part of it;
• Tools
  • Added utility jjs for using JavaScript Nashorn;
  • The command java can run JavaFX applications;
  • Added utility jdeps for analyzing .class files.

↥ back to top

Q. What is Nashorn?

Nashorn is a JavaScript engine developed in Java by Oracle. Designed to provide the ability to embed JavaScript code in Java applications. Compared to Rhino , which is supported by the Mozilla Foundation, Nashorn provides 2 to 10 times better performance, as it compiles code and transfers bytecode to the Java virtual machine directly in memory. Nashorn can compile JavaScript code and generate Java classes that are loaded with a special loader. It is also possible to call Java code directly from JavaScript.

↥ back to top

Q. What is jjs?

jjs – This is a command line utility that allows you to execute JavaScript programs directly in the console.

↥ back to top

Q. In Java, How many ways you can take input from the console?

In Java, there are three different ways for reading input from the user in the command line environment ( console ).

1. Using Buffered Reader Class:

This method is used by wrapping the System.in ( standard input stream ) in an InputStreamReader which is wrapped in a BufferedReader, we can read input from the user in the command line.

/**
 * Buffered Reader Class
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test {
    public static void main(String[] args) throws IOException {
        // Enter data using BufferReader
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        // Reading data using readLine
        String name = reader.readLine();

        // Printing the read line
        System.out.println(name);
    }
}

2. Using Scanner Class:

The main purpose of the Scanner class is to parse primitive types and strings using regular expressions, however it is also can be used to read input from the user in the command line.

/**
 * Scanner Class
 */
import java.util.Scanner;

class GetInputFromUser {
    public static void main(String args[]) {
        // Using Scanner for Getting Input from User
        Scanner in = new Scanner(System.in);

        String s = in.nextLine();
        System.out.println(\"You entered string \" + s);

        int a = in.nextInt();
        System.out.println(\"You entered integer \" + a);

        float b = in.nextFloat();
        System.out.println(\"You entered float \" + b);
    }
}

3. Using Console Class:

It has been becoming a preferred way for reading user\’s input from the command line. In addition, it can be used for reading password-like input without echoing the characters entered by the user; the format string syntax can also be used ( like System.out.printf() ).

/**
 * Console Class
 */
public class Sample {
    public static void main(String[] args) {
        // Using Console to input data from user
        String name = System.console().readLine();
        System.out.println(name);
    }
}

↥ back to top

Q. What is the purpose of using javap?

The javap command displays information about the fields, constructors and methods present in a class file. The javap command ( also known as the Java Disassembler ) disassembles one or more class files.

/**
 * Java Disassembler
 */
class Simple {
   public static void main(String args[]) {
       System.out.println(\"Hello World\");
   }
}

cmd> javap Simple.class  

Output

Compiled from \".java\"  
class Simple {  
  Simple();  
  public static void main(java.lang.String[]);  
}  

↥ back to top

Q. Explain the expression System.out::println?

The specified expression illustrates passing a reference to a static method of a println()class System.out.

↥ back to top

Q. Tell us about parallel processing in Java 8?

Streams can be sequential and parallel. Operations on sequential streams are performed in one processor thread, on parallel streams – using several processor threads. Parallel streams use the shared stream ForkJoinPoolthrough the static ForkJoinPool.commonPool()method. In this case, if the environment is not multi-core, then the stream will be executed as sequential. In fact, the use of parallel streams is reduced to the fact that the data in the streams will be divided into parts, each part is processed on a separate processor core, and in the end these parts are connected, and final operations are performed on them.

You can also use the parallelStream()interface method to create a parallel stream from the collection Collection.

To make a regular sequential stream parallel, you must call the Streammethod on the object parallel(). The method isParallel()allows you to find out if the stream is parallel.

Using, methods parallel()and sequential()it is possible to determine which operations can be parallel, and which only sequential. You can also make a parallel stream from any sequential stream and vice versa:

collection
  .stream ()
  .peek ( ... ) // operation is sequential
  .parallel ()
  .map ( ... ) // the operation can be performed in parallel,
  .sequential ()
  .reduce ( ... ) // operation is sequential again

As a rule, elements are transferred to the stream in the same order in which they are defined in the data source. When working with parallel streams, the system preserves the sequence of elements. An exception is a method forEach()that can output elements in random order. And in order to maintain the order, it is necessary to apply the method forEachOrdered().

• Criteria that may affect performance in parallel streams:
• Data size – the more data, the more difficult it is to separate the data first, and then combine them.
• The number of processor cores. Theoretically, the more cores in a computer, the faster the program will work. If the machine has one core, it makes no sense to use parallel threads.
• The simpler the data structure the stream works with, the faster operations will occur. For example, data from is ArrayListeasy to use, since the structure of this collection assumes a sequence of unrelated data. But a type collection LinkedListis not the best option, since in a sequential list all the elements are connected with previous / next. And such data is difficult to parallelize.
• Operations with primitive types will be faster than with class objects.
• It is highly recommended that you do not use parallel streams for any long operations (for example, network connections), since all parallel streams work with one ForkJoinPool, such long operations can stop all parallel streams in the JVM due to the lack of available threads in the pool, etc. e. parallel streams should be used only for short operations where the count goes for milliseconds, but not for those where the count can go for seconds and minutes;
• Saving order in parallel streams increases execution costs, and if order is not important, it is possible to disable its saving and thereby increase productivity by using an intermediate operation unordered():

collection.parallelStream ()
    .sorted ()
    .unordered ()
    .collect ( Collectors . toList ());

↥ back to top

# 2. JAVA ARCHITECTURE

Q. What is JVM and is it platform independent?

Java Virtual Machine (JVM) is a specification that provides runtime environment in which java bytecode(.class files) can be executed. The JVM is the platform. The JVM acts as a \”virtual\” machine or processor. Java\’s platform independence consists mostly of its Java Virtual Machine (JVM). JVM makes this possible because it is aware of the specific instruction lengths and other particularities of the platform (Operating System).

The JVM is not platform independent. Java Virtual Machine (JVM) provides the environment to execute the java file(. Class file). So at the end it\’s depends on kernel and kernel is differ from OS (Operating System) to OS. The JVM is used to both translate the bytecode into the machine language for a particular computer and actually execute the corresponding machine-language instructions as well.

↥ back to top

Q. What is JIT compiler in Java?

The Just-In-Time (JIT) compiler is a component of the runtime environment that improves the performance of Java applications by compiling bytecodes to native machine code at run time.

Java programs consists of classes, which contain platform-neutral bytecodes that can be interpreted by a JVM on many different computer architectures. At run time, the JVM loads the class files, determines the semantics of each individual bytecode, and performs the appropriate computation. The additional processor and memory usage during interpretation means that a Java application performs more slowly than a native application. The JIT compiler helps improve the performance of Java programs by compiling bytecodes into native machine code at run time. The JIT compiler is enabled by default. When a method has been compiled, the JVM calls the compiled code of that method directly instead of interpreting it.

↥ back to top

Q. What is Classloader in Java?

The Java ClassLoader is a part of the Java Runtime Environment that dynamically loads Java classes into the Java Virtual Machine. Java code is compiled into class file by javac compiler and JVM executes Java program, by executing byte codes written in class file. ClassLoader is responsible for loading class files from file system, network or any other source.

Types of ClassLoader:

1. Bootstrap Class Loader:

It loads standard JDK class files from rt.jar and other core classes. It loads class files from jre/lib/rt.jar. For example, java.lang package class.

2. Extensions Class Loader:

It loads classes from the JDK extensions directly usually JAVA_HOME/lib/ext directory or any other directory as java.ext.dirs.

3. System Class Loader:

It loads application specific classes from the CLASSPATH environment variable. It can be set while invoking program using -cp or classpath command line options.

↥ back to top

Q. Java Compiler is stored in JDK, JRE or JVM?

1. JDK:

Java Development Kit is the core component of Java Environment and provides all the tools, executables and binaries required to compile, debug and execute a Java Program.

2. JVM:

JVM is responsible for converting Byte code to the machine specific code. JVM is also platform dependent and provides core java functions like memory management, garbage collection, security etc. JVM is customizable and we can use java options to customize it, for example allocating minimum and maximum memory to JVM. JVM is called virtual because it provides an interface that does not depend on the underlying operating system and machine hardware.

2. JRE:

Java Runtime Environment provides a platform to execute java programs. JRE consists of JVM and java binaries and other classes to execute any program successfully.

↥ back to top

Q. What is difference between Heap and Stack Memory in java?

1. Java Heap Space:

Java Heap space is used by java runtime to allocate memory to Objects and JRE classes. Whenever we create any object, it\’s always created in the Heap space.

Garbage Collection runs on the heap memory to free the memory used by objects that doesn\’t have any reference. Any object created in the heap space has global access and can be referenced from anywhere of the application.

2. Java Stack Memory:

Stack in java is a section of memory which contains methods, local variables and reference variables. Local variables are created in the stack.

Stack memory is always referenced in LIFO ( Last-In-First-Out ) order. Whenever a method is invoked, a new block is created in the stack memory for the method to hold local primitive values and reference to other objects in the method.

As soon as method ends, the block becomes unused and become available for next method. Stack memory size is very less compared to Heap memory.

Difference:

↥ back to top

Q. How many types of memory areas are allocated by JVM?

JVM is a program which takes Java bytecode and converts the byte code (line by line) into machine understandable code. JVM perform some particular types of operations:

• Loading of code
• Verification of code
• Executing the code
• It provide run-time environment to the users

Types of Memory areas allocated by the JVM:

1. Classloader: Classloader is a subsystem of JVM that is used to load class files.

2. Class(Method) Area: Class(Method) Area stores per-class structures such as the runtime constant pool, field and method data, the code for methods.

3. Heap: It is the runtime data area in which objects are allocated.

4. Stack: Java Stack stores frames.It holds local variables and partial results, and plays a part in method invocation and return. Each thread has a private JVM stack, created at the same time as thread.

5. Program Counter Register: PC (program counter) register. It contains the address of the Java virtual machine instruction currently being executed.

6. Native Method Stack: It contains all the native methods used in the application.

↥ back to top

# 3. JAVA DATA TYPES

Q. What are autoboxing and unboxing?

The automatic conversion of primitive data types into its equivalent Wrapper type is known as boxing and opposite operation is known as unboxing.

Example: Autoboxing

/**
 * Autoboxing
 */
class BoxingExample {
    public static void main(String args[]) {
        int a = 50;
        Integer a2 = new Integer(a); // Boxing
        Integer a3 = 5; // Boxing

        System.out.println(a2 + \" \" + a3);
    }
} 

Example: Unboxing

/**
 * Unboxing
 */
class UnboxingExample {
    public static void main(String args[]) {
        Integer i = new Integer(50);
        int a = i;

        System.out.println(a);
    }
}

↥ back to top

Q. What is the difference between transient and volatile variable in Java?

1. Transient:

The transient modifier tells the Java object serialization subsystem to exclude the field when serializing an instance of the class. When the object is then deserialized, the field will be initialized to the default value; i.e. null for a reference type, and zero or false for a primitive type.

Example:

/**
 * Transient
 */
public transient int limit = 55;   // will not persist
public int b;   // will persist

2. Volatile:

The volatile modifier tells the JVM that writes to the field should always be synchronously flushed to memory, and that reads of the field should always read from memory. This means that fields marked as volatile can be safely accessed and updated in a multi-thread application without using native or standard library-based synchronization.

Example:

/**
 * Volatile
 */
public class MyRunnable implements Runnable {
   private volatile boolean active;
   public void run() {
      active = true;
      while (active) {    
      }
   }
   public void stop() {
      active = false;  
   }
}

↥ back to top

Q. What are assertions in Java?

An assertion allows testing the correctness of any assumptions that have been made in the program. Assertion is achieved using the assert statement in Java.

While executing assertion, it is believed to be true. If it fails, JVM throws an error named AssertionError. It is mainly used for testing purposes during development.

The assert statement is used with a Boolean expression and can be written in two different ways.

// First way 
assert expression;

// Second way
assert expression1 : expression2;

Example:

/**
 * Assertions
 */
public class Example {
    public static void main(String[] args) {
        int age = 14;
        assert age <= 18 : \"Cannot Vote\";
        System.out.println(\"The voter\'s age is \" + age);
    }
}

↥ back to top

Q. What is the final variable, final class, and final blank variable?

1. Final Variable:

Final variables are nothing but constants. We cannot change the value of a final variable once it is initialized.

Example:

/**
 * Final Variable
 */
class Demo {

    final int MAX_VALUE = 99;

    void myMethod() {
        MAX_VALUE = 101;
    }

    public static void main(String args[]) {
        Demo obj = new Demo();
        obj.myMethod();
    }
}

Output

Exception in thread \"main\" java.lang.Error: Unresolved compilation problem: 
	The final field Demo.MAX_VALUE cannot be assigned

	at beginnersbook.com.Demo.myMethod(Details.java:6)
	at beginnersbook.com.Demo.main(Details.java:10)

2. Blank final variable:

A final variable that is not initialized at the time of declaration is known as blank final variable. We must initialize the blank final variable in constructor of the class otherwise it will throw a compilation error ( Error: variable MAX_VALUE might not have been initialized ).

Example:

/**
 * Blank final variable
 */
class Demo {
    // Blank final variable
    final int MAX_VALUE;

    Demo() {
        // It must be initialized in constructor
        MAX_VALUE = 100;
    }

    void myMethod() {
        System.out.println(MAX_VALUE);
    }

    public static void main(String args[]) {
        Demo obj = new Demo();
        obj.myMethod();
    }
}

Output

100

3. Final Method:

A final method cannot be overridden. Which means even though a sub class can call the final method of parent class without any issues but it cannot override it.

Example:

/**
 * Final Method
 */
class XYZ {
    final void demo() {
        System.out.println(\"XYZ Class Method\");
    }
}

class ABC extends XYZ {
    void demo() {
        System.out.println(\"ABC Class Method\");
    }

    public static void main(String args[]) {
        ABC obj = new ABC();
        obj.demo();
    }
}

↥ back to top

Q. What is a compile time constant in Java?

If a primitive type or a string is defined as a constant and the value is known at compile time, the compiler replaces the constant name everywhere in the code with its value. This is called a compile-time constant.

Compile time constant must be:

• Declared final
• Primitive or String
• Initialized within declaration
• Initialized with constant expression

They are replaced with actual values at compile time because compiler know their value up-front and also knows that it cannot be changed during run-time.

private final int x = 10;

↥ back to top

Q. What are the different access specifiers available in java?

• access specifiers/modifiers helps to restrict the scope of a class, constructor, variable, method, or data member.
• There are four types of access modifiers available in java:
  1. default – No keyword required, when a class, constructor,variable, method, or data member declared without any access specifier then it is having default access scope i.e. accessible only within the same package.
  2. private – when declared as a private , access scope is limited within the enclosing class.
  3. protected – when declared as protocted, access scope is limited to enclosing classes, subclasses from same package as well as other packages.
  4. public – when declared as public, accessible everywhere in the program.

    ... /* data member variables */
    String firstName=\"Pradeep\";     /* default scope */
    protected isValid=true;         /* protected scope */
    private String otp=\"AB0392\";    /* private scope */
    public int id = 12334;          /* public scope */
    ...
    ... /* data member functions */
    String getFirstName(){ return this.firstName; } /* default scope */
    protected boolean getStatus(){this.isValid;}    /* protected scope */
    private void generateOtp(){                     /* private scope */
        this.otp = this.hashCode() << 16;
    };    
    public int getId(){ return this.id; }           /* public scope */
    ...
    .../* inner classes */
    class A{}            /* default scope */
    protected class B{}  /* protected scope */
    private class C{}    /* private scope */
    public class D{}     /* public scope */
    ...

↥ back to top

# 4. JAVA METHODS

Q. Can you have virtual functions in Java?

In Java, all non-static methods are by default virtual functions. Only methods marked with the keyword final, which cannot be overridden, along with private methods, which are not inherited, are non-virtual.

Example: Virtual function with Interface

/**
 * The function applyBrakes() is virtual because
 * functions in interfaces are designed to be overridden.
 **/
interface Bicycle {
    void applyBrakes();
}

class ACMEBicycle implements Bicycle {
    public void applyBrakes() { // Here we implement applyBrakes()
        System.out.println(\"Brakes applied\"); // function
    }
}

↥ back to top

Q. What is a native method?

A native method is a Java method (either an instance method or a class method) whose implementation is also written in another programming language such as C/C++. Moreover, a method marked as native cannot have a body and should end with a semicolon:

Main.java:

public class Main {
    public native int intMethod(int i);

    public static void main(String[] args) {
        System.loadLibrary(\"Main\");
        System.out.println(new Main().intMethod(2));
    }
}

Main.c:

#include <jni.h>
#include \"Main.h\"

JNIEXPORT jint JNICALL Java_Main_intMethod(
    JNIEnv *env, jobject obj, jint i) {
  return i * i;
}

Compile and Run:

javac Main.java
javah -jni Main
gcc -shared -fpic -o libMain.so -I${JAVA_HOME}/include \\
  -I${JAVA_HOME}/include/linux Main.c
java -Djava.library.path=. Main

Output

4

↥ back to top

Q. What are the restrictions that are applied to the Java static methods?

If a method is declared as static, it is a member of a class rather than belonging to the object of the class. It can be called without creating an object of the class. A static method also has the power to access static data members of the class.

There are a few restrictions imposed on a static method

• The static method cannot use non-static data member or invoke non-static method directly.
• The this and super cannot be used in static context.
• The static method can access only static type data ( static type instance variable ).
• There is no need to create an object of the class to invoke the static method.
• A static method cannot be overridden in a subclass

Example:

/**
 * Static Methods
 */
class Parent {
    static void display() {
        System.out.println(\"Super class\");
    }
}

public class Example extends Parent {
    void display()  // trying to override display() {
       System.out.println(\"Sub class\");  
    }

    public static void main(String[] args) {
        Parent obj = new Example();
        obj.display();
    }
}

This generates a compile time error. The output is as follows −

Example.java:10: error: display() in Example cannot override display() in Parent
void display()  // trying to override display()
     ^
overridden method is static

1 error

↥ back to top

Q. What is a lambda?

What is the structure and features of using a lambda expression?
A lambda is a set of instructions that can be separated into a separate variable and then repeatedly called in various places of the program.

The basis of the lambda expression is the lambda operator , which represents the arrow ->. This operator divides the lambda expression into two parts: the left side contains a list of expression parameters, and the right actually represents the body of the lambda expression, where all actions are performed.

The lambda expression is not executed by itself, but forms the implementation of the method defined in the functional interface. It is important that the functional interface should contain only one single method without implementation.

interface  Operationable {
     int  calculate ( int  x , int  y );
}

public  static  void main ( String [] args) {
    Operationable operation = (x, y) - > x + y;     
    int result = operation.calculate ( 10 , 20 );
    System.out.println (result); // 30 
}

In fact, lambda expressions are in some way a shorthand form of internal anonymous classes that were previously used in Java.

• Deferred execution lambda expressions – it is defined once in one place of the program, it is called if necessary, any number of times and in any place of the program.

• The parameters of the lambda expression must correspond in type to the parameters of the functional interface method:

operation = ( int x, int y