The copy constructor is use for initialising a new instance from an old instance,

Posted on May 14, 2024 in Computers

Apart from the above rules, there are also some facts to keep in mind:

• Only inherited methods can be overridden. That means methods can be overridden only in child classes

  
  
• 
  

  Constructors and private methods are not inherited, so they cannot be overridden

• 
  

  Abstract methods must be overridden by the first concrete (non-abstract) subclass

• 
  

  Final methods cannot be overridden

• 
  

  A subclass can use super.Overridden_method() to call the superclass version of an overridden method

String Cheat Sheet

1. What is the difference between equals() method and == operator?

The equals() method matches content of the strings whereas == operator matches object or reference of the strings.

2.Java String intern()

It can be used to return string from memory if it is created by a new keyword. It creates an exact copy of the heap string object in the String Constant Pool.

3. Explain String pool in Java

String Pool, also known as SCP (String Constant Pool), is a special storage space in Java heap memory that is used to store unique string objects. Whenever a string object is created, it first checks whether the String object with the same string value is already present in the String pool or not, and if it is available, then the reference to the string object from the string pool is returned. Otherwise, the new string object is added to the string pool, and the respective reference will be returned.

4. Is String immutable or final in Java? If so, then what are the benefits of Strings being Immutable?

Yes, Strings are immutable in Java. Immutable objects mean they can’t be changed or altered once they’ve been created. However, we can only modify the reference to the string object. The String is immutable in Java because of many reasons like security, caching, synchronization and concurrency, and class loading.

5. Is String thread-safe in Java?

Strings are immutable objects, which means they can’t be changed or altered once they’ve been created. As a result, whenever we manipulate a String object, it creates a new String rather than modifying the original string object. In Java, every immutable object is thread-safe, which means String is also thread-safe. As a result, multiple threads can access a string. For instance, if a thread modifies the value of a string, instead of modifying the existing one, a new String is created, and therefore, the original string object that was shared among the threads remains unchanged.

6. Why is a string used as a HashMap key in Java?

Basically, the HashMap object can store key-value pairs. When creating a HashMap object and storing a key-value pair in that object, you will notice that while storing, the hash code of the key will be calculated, and its calculated value will be placed as the resultant hash code of the key. Now, when the key is passed to fetch its value, then the hash code of the key is calculated again, and if it’s equal to the value of the hash code initially calculated, the initial value placed as the resultant hash code of the key is retrieved or fetched.

7. How to create Immutable class in Java?

• Immutable class in java means that once an object is created, we cannot change its content. In Java, all the wrapper classes (like Integer, Boolean, Byte, Short) and String class is immutable.
• The class must be declared as final so that child classes can’t be created.
• Data members in the class must be declared private so that direct access is not allowed.
• Data members in the class must be declared as final so that we can’t change the value of it after object creation.
• A parameterized constructor should initialize all the fields performing a deep copy so that data members can’t be modified with an object reference.
• Deep Copy of objects should be performed in the getter methods to return a copy rather than returning the actual object reference)
• 
  

  Note

  There should be no setters or in simpler terms, there should be no option to change the value of the instance variable.

8. Object Cloning in Java

The object cloning is a way to create exact copy of an object. The clone() method of Object class is used to clone an object.
The java.Lang.Cloneable interface must be implemented by the class whose object clone we want to create. If we don’t implement
Cloneable interface, clone() method generates CloneNotSupportedException.
The clone() method is defined in the Object class. Syntax of the clone() method is as follows:
protected Object clone() throws CloneNotSupportedException
Student18 s1=new Student18(101,”amit”);  
Student18 s2=(Student18)s1.Clone(); 

Differences between final and immutability

• final means that you can’t change the object’s reference to point to another reference or another object, but you can still mutate its state (using setter methods e.G). Whereas immutable means that the object’s actual value can’t be changed, but you can change its reference to another one.
• final modifier is applicable for variable but not for objects, Whereas immutability applicable for an object but not for variables.
• By declaring a reference variable as final, we won’t get any immutability nature, Even though reference variable is final. We can perform any type of change in the corresponding Object. But we can’t perform reassignment for that variable.
• final ensures that the address of the object remains the same whereas the Immutable suggests that we can’t change the state of the object once created.

Singleton Method Design Pattern in Java

Serialization and Deserialization in Java

Parameters

Interface

Abstract class

Speed

Slow

Fast

Multiple Inheritances

Implement several Interfaces

Only one abstract class

Structure

Abstract methods

Abstract & concrete methods

When to use

Future enhancement

To avoid independence

Inheritance/ Implementation

A Class can implement multiple interfaces

The class can inherit only one Abstract Class

Default Implementation

While adding new stuff to the interface, it is a nightmare to find all the implementors and implement newly defined stuff.

In case of Abstract Class, you can take advantage of the default implementation

Access Modifiers

The interface does not have access modifiers. Everything defined inside the interface is assumed public modifier

Abstract Class can have an access modifier

When to use

It is better to use interface when various implementations share only method signature. Polymorphic hierarchy of value types.

It should be used when various implementations of the same kind share a common behavior

Data fields the interface cannot contain data fields.

The class can have data fields

Multiple Inheritance Default

A class may implement numerous interfaces

A class inherits only one abstract class

Implementation

An interface is abstract so that it can’t provide any code

An abstract class can give complete, default code which should be overridden

Use of Access modifiers

You cannot use access modifiers for the method, properties, etc

You can use an abstract class which contains access modifiers

Usage

Interfaces help to define the peripheral abilities of a class

An abstract class defines the identity of a class

Defined fields

No fields can be defined

An abstract class allows you to define both fields and constants

Inheritance

An interface can inherit multiple interfaces but cannot inherit a class

An abstract class can inherit a class and multiple interfaces

Constructor or destructors

An interface cannot declare constructors or destructors

An abstract class can declare constructors and destructors

Limit of Extensions

It can extend any number of interfaces

It can extend only one class or one abstract class at a time

Abstract keyword

In an abstract interface keyword, is optional for declaring a method as an abstract

In an abstract class, the abstract keyword is compulsory for declaring a method as an abstract

Class type

An interface can have only public abstract methods

An abstract class has protected and public abstract methods

Comparator Vs Comparable In Java

Comparison Basis

Comparable
Comparator

Method

Comparable provides compareTo() method to sort elements in Java

Comparator provides compare() method to sort elements in Java

Package

A comparable interface is present in java.Lang package

A comparator interface is present in java.Util package

Logic of Sorting

The logic of sorting must be in the same class as the object you are going to sort

The logic of sorting should be in separate classes to write different sorts based on different attributes of objects.

Class Object

The class whose objects you want to sort must implement the Comparable interface

A class whose objects you want to sort does not need to implement a comparator interface

Sorting Sequences

It provides single sorting sequences

It provides multiple sorting sequences

Sorting Order

This method can sort the data according to the natural sorting order

This method sorts the data according to the customized sorting order

Class

It affects the original class. I.E., the actual class is altered

It doesn’t affect the original class, i.E., the actual class is not altered

Usage

Implemented frequently in the API by Calendar, Wrapper classes, Date, and String

It is implemented to sort instances of third-party classes

Implement

All wrapper classes and string classes implement comparable interfaces

The only implemented classes of Comparator are Collator and RuleBasedColator

publicclass
Comparingimplements
Comparable<Comparing> {
privateint x;
private String y;

@Override
publicintcompareTo(Comparing o)
{
if(this
.GetX() == o.GetX()){
returnthis
.GetY().CompareTo(o.GetY());
}
else {
returnthis
.GetX() > o.GetX() ? 1 : –1 ;
}
}

}Comparing comparing1 = new
Comparing(1,“a”)
;
Comparing comparing2 = new
Comparing(2,“c”)
;
Comparing comparing3 = new
Comparing(4,“b”)
;
List<Comparing> list = new
ArrayList<>();
list.Add(comparing1);
list.Add(comparing2);
list.Add(comparing3);
Collections.Sort(list);

publicclass
ComparingComparable {
@Override
publicintcompare(Comparing car1, Comparing car2)
{
if (car1.Fuel == car2.Fuel) return 0; return car1.Fuel < car2.Fuel ? -1 : 1;

}