JAVA INTERVIEW QUESTIONS

1.)Difference between cohesion and coupling?

deep and shallow copy

how to make List don't allow duplicate.

how to allow duplicate in set?

how to make hashmap synchronised?

Why does ArrayList implement RandomAccess Interface?

Cohesion in Java

Last Updated: 31-10-2017

In object oriented design, cohesion refers all about how a single class is designed. Cohesion is the Object Oriented principle most closely associated with making sure that a class is designed with a single, well-focused purpose.
The more focused a class is, the cohesiveness of that class is more. The advantages of high cohesion is that such classes are much easier to maintain (and less frequently changed) than classes with low cohesion. Another benefit of high cohesion is that classes with a well-focused purpose tend to be more reusable than other classes.

Example : Suppose we have a class that multiply two numbers, but the same class creates a pop up window displaying the result. This is the example of low cohesive class because the window and the multiplication operation don’t have much in common.
To make it high cohesive, we would have to create a class Display and a class Multiply. The Display will call Multiply’s method to get the result and display it. This way to develop a high cohesive solution.

Lets understand the structure of high cohesive program :

edit

play_arrow

brightness_4

// Java program to illustrate 
// high cohesive behavior 
class Multiply { 
    int a = 5; 
    int b = 5; 
    public int mul(int a, int b) 
    { 
        this.a = a; 
        this.b = b; 
        return a * b; 
    } 
}  
  
class Display { 
    public static void main(String[] args) 
    { 
        Multiply m = new Multiply(); 
        System.out.println(m.mul(5, 5)); 
    } 
} 

Output:

edit

play_arrow

brightness_4

// Java program to illustrate 
// high cohesive behavior 
class Name { 
    String name; 
    public String getName(String name) 
    { 
        this.name = name; 
        return name; 
    } 
}  
  
class Age { 
    int age; 
    public int getAge(int age) 
    { 
        this.age = age; 
        return age; 
    } 
}  
  
class Number { 
    int mobileno; 
    public int getNumber(int mobileno) 
    { 
        this.mobileno = mobileno; 
        return mobileno; 
    } 
}  
  
class Display { 
    public static void main(String[] args) 
    { 
        Name n = new Name(); 
        System.out.println(n.getName("Geeksforgeeks")); 
        Age a = new Age(); 
        System.out.println(a.getAge(10)); 
        Number no = new Number(); 
        System.out.println(no.getNumber(1234567891)); 
    } 
} 

Output:

Geeksforgeeks
10
1234567891

Pictorial view of high cohesion and low cohesion:
Cohesion in Java
Explanation : In the above image, we can see that in low cohesion only one class is responsible to execute lots of job which are not in common which reduces the chance of re-usability and maintenance. But in high cohesion there is a separate class for all the jobs to execute a specific job, which result better usability and maintenance.

Difference between high cohesion and low cohesion:

High cohesion is when you have a class that does a well defined job. Low cohesion is when a class does a lot of jobs that don’t have much in common.
High cohesion gives us better maintaining facility and Low cohesion results in monolithic classes that are difficult to maintain, understand and reduces re-usability

Coupling in Java

Last Updated: 05-02-2020

In object oriented design, Coupling refers to the degree of direct knowledge that one element has of another. In other words, how often do changes in class A force related changes in class B.
There are two types of coupling:

Tight coupling : In general, Tight coupling means the two classes often change together. In other words, if A knows more than it should about the way in which B was implemented, then A and B are tightly coupled.
Example : If you want to change the skin, you would also have to change the design of your body as well because the two are joined together – they are tightly coupled. The best example of tight coupling is RMI(Remote Method Invocation).

brightness_4

// Java program to illustrate 
// tight coupling concept 
class Subject { 
    Topic t = new Topic(); 
    public void startReading() 
    { 
        t.understand(); 
    } 
} 
class Topic { 
    public void understand() 
    { 
        System.out.println("Tight coupling concept"); 
    } 
} 

Explanation: In the above program the Subject class is dependents on Topic class. In the above program Subject class is tightly coupled with Topic class it means if any change in the Topic class requires Subject class to change. For example, if Topic class understand() method change to gotit() method then you have to change the startReading() method will call gotit() method instead of calling understand() method.

edit

play_arrow

brightness_4

// Java program to illustrate 
// tight coupling concept 
class Volume  
{ 
     public static void main(String args[])  
     { 
         Box b = new Box(5,5,5); 
         System.out.println(b.volume); 
     } 
} 
class Box  
{ 
     public int volume; 
     Box(int length, int width, int height)  
     { 
         this.volume = length * width * height; 
     } 
} 

Output:

Explanation:In the above example, there is a strong inter-dependency between both the classes. If there is any change in Box class then they reflects in the result of Class Volume.

Loose coupling : In simple words, loose coupling means they are mostly independent. If the only knowledge that class A has about class B, is what class B has exposed through its interface, then class A and class B are said to be loosely coupled. In order to over come from the problems of tight coupling between objects, spring framework uses dependency injection mechanism with the help of POJO/POJI model and through dependency injection its possible to achieve loose coupling.
Example : If you change your shirt, then you are not forced to change your body – when you can do that, then you have loose coupling. When you can’t do that, then you have tight coupling. The examples of Loose coupling are Interface, JMS.

brightness_4

// Java program to illustrate  
// loose coupling concept 
public interface Topic 
{ 
    void understand(); 
} 
class Topic1 implements Topic { 
public void understand() 
    { 
        System.out.println("Got it"); 
    } 
} class Topic2 implements Topic { 
public void understand() 
    { 
        System.out.println("understand"); 
    } 
} public class Subject { 
public static void main(String[] args) 
    { 
        Topic t = new Topic1(); 
        t.understand(); 
    } 
} 

Explanation : In the above example, Topic1 and Topic2 objects are loosely coupled. It means Topic is an interface and we can inject any of the implemented classes at run time and we can provide service to the end user.

edit

play_arrow

brightness_4

// Java program to illustrate 
// loose coupling concept 
class Volume  
{ 
     public static void main(String args[])  
     { 
         Box b = new Box(5,5,5); 
         System.out.println(b.getVolume()); 
     } 
} 
final class Box  
{ 
     private int volume; 
     Box(int length, int width, int height)  
     { 
         this.volume = length * width * height; 
     } 
     public int getVolume()  
     {  
         return volume;  
           
     } 
} 

Output:

Explanation : In the above program, there is no dependency between both the classes. If we change anything in the Box classes then we dont have to change anything in Volume class.

Which is better tight coupling or loose coupling?

In general, Tight Coupling is bad in but most of the time, because it reduces flexibility and re-usability of code, it makes changes much more difficult, it impedes test ability etc. loose coupling is a better choice because A loosely coupled will help you when your application need to change or grow. If you design with loosely coupled architecture, only a few parts of the application should be affected when requirements change.
Lets have a look on the pictorial view of tight coupling and loose coupling:
Coupling in Java

Difference between tight coupling and loose coupling

Tight coupling is not good at the test-ability. But loose coupling improves the test ability.
Tight coupling does not provide the concept of interface. But loose coupling helps us follow the GOF principle of program to interfaces, not implementations.
In Tight coupling, it is not easy to swap the codes between two classes. But it’s much easier to swap other pieces of code/modules/objects/components in loose coupling.
Tight coupling does not have the changing capability. But loose coupling is highly changeable.

This article is contributed by Bishal Kumar Dubey. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important Java and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready.

=======================================================================================================================

Answer:

Random access in this case means, that accessing any element takes the same amount of time as accessing another one does. This applies to an array (and thus to an ArrayList), as you can access any item by its index. Since arrays are stored in memory sequentually, the rules for Random Access Memory apply. For a LinkedList however, this is not the case, as you always need to follow the references to the element you want.

ArrayLists do not need to be accessed sequentially, even though they are stored sequentially, because the index is just an offset from the array's address in memory.

1) There are two classes which implement RandomAccess Interface. They are:

ArrayList (Part of List<I>)
Vector    (Part of List<I>)

2) The purpose of RandomAccess Interface is to retrieve any random element in the Collection at the same speed. Example: I have a collection of 1 million objects. Implementing RandomAccess interface makes your time to retrieve the 10th element and 17869th element the same. This makes ArrayList and Vector more powerful.

3) RandomAccess Interface has no methods or fields and is also called a Marker Interface. These are used to indicate something to the compiler, in other words implementing these interfaces is meant to imply some special treatment of the implementing class.

Software Engineering Tips

Monday, September 14, 2020