Interview

Duplicate Code is bad. Code will always Changed.
OOP is Providing Code Reuse ability with reduce duplication of code and you have to change every where which leads to performance
code can be changed any time so when you want to change it in any application, OOP make it easy
Four main Concepts.

• Polymorphism
  • Overloading / Static Binding /Compile Time / Early Binding : Same Methods with Different Properties, methods contain same name but having different Parameters which is compile on run time and shows error while compile time. It is also known as Static Binding or Early Binding.
    • Example :

      public void result(){}
      public void result(int numbers){}
      public void result(String names){}
      

  • Overriding / Dynamic Binding /Run Time / Late Binding : child class can implement a parent class method based on its requirement. Overriding means to override the functionality of an existing method.
    • Example :

      class Animal {
      public void move() {
            System.out.println("Animals can move");
         }
      }
      class Dog extends Animal {
         public void move() {
            System.out.println("Dogs can walk and run");
         }
      }
      public class TestDog {
         public static void main(String args[]) {
            Animal a = new Animal();   // Animal reference and object
            Animal b = new Dog();   // Animal reference but Dog object
            a.move();   // runs the method in Animal class
            b.move();   // runs the method in Dog class
         }
      }

• Encapsulation
• Abstraction
• Inheritance

• A class is a Body for any functional entity which defines its properties and its functions. Like Human Being, having body parts, and performing various actions.

• Primitive Data Type: such as boolean, char, int, short, byte, long, float, and double
• Non-Primitive Data Type or Object Data type: such as String, Array, etc.

The Model-View-Controller (MVC) is an architectural pattern that separates an application into three main logical components: the model, the view, and the Controller

Using the MVC pattern for websites, requests are routed to a Controller that is responsible for working with the Model to perform actions and/or retrieve data. The Controller chooses the View to display and provides it with the Model. The View renders the final page, based on the data in the Model.

In REST Architecture everything is a resource. RESTful web services are light weight, highly scalable and maintainable and are very commonly used to create APIs for web-based applications.

Hibernate is a Java framework that simplifies the development of Java application to interact with the database. It is an open source, lightweight, ORM (Object Relational Mapping) tool. Hibernate implements the specifications of JPA (Java Persistence API) for data persistence

Repository management framework, it can implement all dependencies through its POM file where we put library name in Dependency Tag

Spring is Framework where we can create web applications, Spring is a huge framework  where we can develop big applications
we can manage exception handling manually,
we can implement spring Security to secure the app
Its annotation base framework

List list = new ArrayList(); // before generics
list.add(10);
list.add("100");
List<Integer> list1 = new ArrayList<Integer>(); // adding generics
list1.add(10);
list1.add("100"); // compile-time error.

Generalization is the process of extracting shared characteristics from two or more classes, and combining them into a generalized superclass
Specialization converting a super class type into a sub class type is called ‘Specialization‘. Here, we are coming down from more general form to a specific form and hence the scope is narrowed. Hence, this is called narrowing or down-casting.

Access Modifiers in Java helps to restrict the scope of a class, constructor, variable, method, or data member. There are four types of access modifiers available in java: 

• Access: default, public , private , protected .

Non Access Modifiers They are used with classes, methods, variables, constructors etc to provide information about their behavior to JVM

• Non-access: static, final, abstract, synchronized, volatile, transient and native .

Dynamic bindings are also known as Overload 

Static bindings are also known as Override

The Generics Object is the superclass of all other classes and Object reference can refer to any type object.
The Object class is the parent class of all the classes in java by default. In other words, it is the topmost class of java

Aggregation: In Aggregation, the direction specifies which object contains the other object. There are mutual dependencies among objects.
For example, departments and employees, a department has many employees but a single employee is not associated with multiple departments

Composition: In this type of Aggregation the child object does not have their own life cycle. The child object’s life depends on the parent’s life cycle.

Association: Association in Java is a connection or relation between two separate classes that are set up through their objects.

<struts>
<Package name = "default" namespace = "/anyNameForURL" extends = "struts-default">
<action name= "URL name" class = "Class complete path with package name" method = "someOtherMethod"> 
<result name = "SucessjSP">/JSPPageCallHere.JSP</result>
<result name = "ErrorJSP">/AnotherJSPPageCallHere.JSP</result>
</action>
</package>
</struts>

<method> : calls when one class have many methods.
Example :
http://<server>:<port>/<webapp>/<namespace>/<action.action>

Example:
<action name= "URL*" class = "Class complete path with package name"> 
<result name = "SucessjSP">/JSPPageCallHere.JSP</result>

it Hit the action class which is start with URL.

Structured Query Language(SQL) as we all know is the database language by the use of which we can perform certain operations on the existing database and also we can use this language to create a database. SQL uses certain commands like Create, Drop, Insert etc. to carry out the required tasks.

These SQL commands are mainly categorized into four categories as discussed below:

1. DDL(Data Definition Language) : DDL or Data Definition Language actually consists of the SQL commands that can be used to define the database schema. It simply deals with descriptions of the database schema and is used to create and modify the structure of database objects in database.

   Examples of DDL commands:

   • CREATE – is used to create the database or its objects (like table, index, function, views, store procedure and triggers).
   • DROP – is used to delete objects from the database.
   • ALTER-is used to alter the structure of the database.
   • TRUNCATE–is used to remove all records from a table, including all spaces allocated for the records are removed.
   • COMMENT –is used to add comments to the data dictionary.
   • RENAME –is used to rename an object existing in the database.
2. DML(Data Manipulation Language) : The SQL commands that deals with the manipulation of data present in database belong to DML or Data Manipulation Language and this includes most of the SQL statements.

   Examples of DML:

   • SELECT – is used to retrieve data from the a database.
   • INSERT – is used to insert data into a table.
   • UPDATE – is used to update existing data within a table.
   • DELETE – is used to delete records from a database table.
3. DCL(Data Control Language) : DCL includes commands such as GRANT and REVOKE which mainly deals with the rights, permissions and other controls of the database system.

   Examples of DCL commands:

   • GRANT-gives user’s access privileges to database.
   • REVOKE-withdraw user’s access privileges given by using the GRANT command.
4. TCL(transaction Control Language) : TCL commands deals with the transaction within the database.

   Examples of TCL commands:

   • COMMIT– commits a Transaction.
   • ROLLBACK– rollbacks a transaction in case of any error occurs.
   • SAVEPOINT–sets a savepoint within a transaction.
   • SET TRANSACTION–specify characteristics for the transaction.

Statefull Web Services

a stateful web service looks like? Let’s say you log into a resource, and in doing so, you pass your password and username. If the web server stores this data in a backend manner and uses it to identify you as a constantly connected client,

Stateless Web Services

you use a variety of stateless services and applications. When you read the news, you are using HTTP to connect in a stateless manner, utilizing messages that can be parsed and worked with in isolation of each other and your state.

If you have Twitter on your phone, you are constantly utilizing a stateless service. When the service requests a list of recent direct messages using the Twitter REST API, it issues the following request:

Soap is statefull

Rest is stateless

ArrayList and Vector both implements List interface and maintains insertion order.

However, there are many differences between ArrayList and Vector classes that are given below.

ArrayList	Vector
1) ArrayList is not synchronized.	Vector is synchronized.
2) ArrayList increments 50% of current array size if the number of elements exceeds from its capacity.	Vector increments 100% means doubles the array size if the total number of elements exceeds than its capacity.
3) ArrayList is not a legacy class. It is introduced in JDK 1.2.	Vector is a legacy class.
4) ArrayList is fast because it is non-synchronized.	Vector is slow because it is synchronized, i.e., in a multithreading environment, it holds the other threads in runnable or non-runnable state until current thread releases the lock of the object.
5) ArrayList uses the Iterator interface to traverse the elements.	A Vector can use the Iterator interface or Enumeration interface to traverse the elements.

/**
 *
 * @author Usman Mughal
 */
public class calculateIntFromString {
    
    public static void main(String[] args){
        try {
            
    String calculateInt = "A1B2C3";
    int num1 = Integer.parseInt(calculateInt.substring(1,2));
    int num2 = Integer.parseInt(calculateInt.substring(3,4));
    int num3 = Integer.parseInt(calculateInt.substring(5,6));
    int sum = num1 + num2 + num3;
        System.out.println("num1 = " + sum);

        
        } catch (NumberFormatException e) {
            e.getMessage();
                
       }
     }

}

/**
 *
 * @author Usman Mughal
 */
public class calculateIntFromString {
    
    public static void main(String[] args){

        String calculateInt = "A124B2C355CF85GT5";

        int total = 0;
        char[] data = calculateInt.toCharArray();
        for(int i = 0; i < data.length; i++){
        if(Character.isDigit(calculateInt.charAt(i)))
        {
            String number = "";
            number = number + calculateInt.charAt(i);
            total = total + Integer.parseInt(number);
        }
      }
        System.out.println("Total number = " + total);
     }

}