• Simple: Java is easy to learn. The syntax of Java is based on C++ which makes easier to write the program in it.


• Object-Oriented: Java follows the object-oriented paradigm which allows us to maintain our code as the combination of different type of objects that incorporates both data and behavior.


• Portable: Java supports read-once-write-anywhere approach. We can execute the Java program on every machine. Java program (.java) is converted to bytecode (.class) which can be easily run on every machine.


• Platform Independent: Java is a platform independent programming language. It is different from other programming languages like C and C++ which needs a platform to be executed. Java comes with its platform on which its code is executed. Java doesn't depend upon the operating system to be executed.


• Secured: Java is secured because it doesn't use explicit pointers. Java also provides the concept of ByteCode and Exception handling which makes it more secured.


• Robust: Java is a strong programming language as it uses strong memory management. The concepts like Automatic garbage collection, Exception handling, etc. make it more robust.


• Architecture Neutral: Java is architectural neutral as it is not dependent on the architecture. In C, the size of data types may vary according to the architecture (32 bit or 64 bit) which doesn't exist in Java.


• Interpreted: Java uses the Just-in-time (JIT) interpreter along with the compiler for the program execution.


• High Performance: Java is faster than other traditional interpreted programming languages because Java bytecode is "close" to native code. It is still a little bit slower than a compiled language (e.g., C++).


• Multithreaded: We can write Java programs that deal with many tasks at once by defining multiple threads. The main advantage of multi-threading is that it doesn't occupy memory for each thread. It shares a common memory area. Threads are important for multi-media, Web applications, etc.


• Distributed: Java is distributed because it facilitates users to create distributed applications in Java. RMI and EJB are used for creating distributed applications. This feature of Java makes us able to access files by calling the methods from any machine on the internet.


• Dynamic: Java is a dynamic language. It supports dynamic loading of classes. It means classes are loaded on demand. It also supports functions from its native languages, i.e., C and C++.

Answer: All Java codes are defined in a Class. It has variables and methods.

Variables are attributes which define the state of a class.

Methods are the place where the exact business logic has to be done. It contains a set of statements (or) instructions to satisfy the particular requirement.

Answer: An instance of a class is called an object. The object has state and behavior.

Whenever the JVM reads the “new()” keyword then it will create an instance of that class.

Example:

The above code creates the object for the Addition class.

The constructor can be defined as the special type of method that is used to initialize the state of an object. It is invoked when the class is instantiated, and the memory is allocated for the object. Every time, an object is created using the new keyword, the default constructor of the class is called. The name of the constructor must be similar to the class name. The constructor must not have an explicit return type.

Based on the parameters passed in the constructors, there are two types of constructors in Java.

• Default Constructor: default constructor is the one which does not accept any value. The default constructor is mainly used to initialize the instance variable with the default values. It can also be used for performing some useful task on object creation. A default constructor is invoked implicitly by the compiler if there is no constructor defined in the class.
• Parameterized Constructor: The parameterized constructor is the one which can initialize the instance variables with the given values. In other words, we can say that the constructors which can accept the arguments are called parameterized constructors.

The output of the above code will be

30Javatpoint
                        

                    Javatpoint1020
                    

It is a programming paradigm based on objects having data and methods defined in the class to which it belongs. Object-oriented paradigm aims to incorporate the advantages of modularity and reusability. Objects are the instances of classes which interacts with one another to design applications and programs. There are the following features of the object-oriented paradigm.

• Follows the bottom-up approach in program design.
• Focus on data with methods to operate upon the object's data
• Includes the concept like Encapsulation and abstraction which hides the complexities from the user and show only functionality.
• Implements the real-time approach like inheritance, abstraction, etc.
• The examples of the object-oriented paradigm are C++, Simula, Smalltalk, Python, C#, etc.

Inheritance allows you to let a derived class acquire the methods from a base class.

Constructor in java is a special type of method which is different from normal java methods/ordinary methods. Constructors are used to initialize an object. Automatically a constructor is called when an object of a class is created. It is syntactically similar to a method but it has the same name as its class and a constructor does not have a return type.
Java constructor can not be final

There are the following uses of this keyword.

• this can be used to refer to the current class instance variable.
• this can be used to invoke current class method (implicitly)
• this() can be used to invoke the current class constructor.
• this can be passed as an argument in the method call.
• this can be passed as an argument in the constructor call.
• this can be used to return the current class instance from the method.

There are the following uses of super keyword.

• super can be used to refer to the immediate parent class instance variable.
• super can be used to invoke the immediate parent class method.
• super() can be used to invoke immediate parent class constructor.

There are the following differences between this and super keyword.

• The super keyword always points to the parent class contexts whereas this keyword always points to the current class context.
• The super keyword is primarily used for initializing the base class variables within the derived class constructor whereas this keyword primarily used to differentiate between local and instance variables when passed in the class constructor.
• The super and this must be the first statement inside constructor otherwise the compiler will throw an error.