What is String?

In Java, String is the type of objects that can store the sequence of characters enclosed by double quotes and every character is stored in 16 bits i.e using UTF 16-bit encoding. A string acts the same as an array of characters. Java provides a robust and flexible API for handling strings, allowing for various operations such as concatenation, comparison, and manipulation.

Example:  

String name = “Java”;

String num = “1234”;

Ways of Creating a Java String

There are two ways to create a string in Java: 

• String Literal
• Using new Keyword

Syntax:  

<String_Type> <string_variable> = “<sequence_of_string>”; 

1. String literal (Static Memory)

To make Java more memory efficient (because no new objects are created if it exists already in the string constant pool). 

Example:

String demoString = “Java In String”;

2. Using new keyword (Heap Memory)

• String s = new String(“Welcome”);
• In such a case, JVM will create a new string object in normal (non-pool) heap memory and the literal “Welcome” will be placed in the string constant pool. The variable s will refer to the object in the heap (non-pool)

In the given example only one object will be created. Firstly JVM will not find any string object with the value “Welcome” in the string constant pool, so it will create a new object. After that it will find the string with the value “Welcome” in the pool, it will not create a new object but will return the reference to the same instance.

Example:

String demoString = new String (“Java In String”);

Interfaces and Classes in Strings in Java

• CharBuffer: This class implements the CharSequence interface. This class is used to allow character buffers to be used in place of CharSequences. An example of such usage is the regular-expression package java.util.regex.
• String: It is a sequence of characters. In Java, objects of String are immutable which means a constant and cannot be changed once created.

CharSequence Interface

CharSequence Interface is used for representing the sequence of Characters in Java. Classes that are implemented using the CharSequence interface are mentioned below and these provides much of functionality like substring, lastoccurence, first occurence, concatenate , toupper, tolower etc.

1. String
2. StringBuffer
3. StringBuilder

1. String

String is an immutable class which means a constant and cannot be changed once created and if wish to change , we need to create an new object and even the functionality it provides like toupper, tolower, etc all these return a new object , its not modify the original object. It is automatically thread safe.

Syntax

// Method 1
String str= “geeks”;

// Method 2
String str= new String(“geeks”)

2. StringBuffer

StringBuffer is a peer class of String, it is mutable in nature and it is thread safe class , we can use it when we have multi threaded environment and shared object of string buffer i.e, used by mutiple thread. As it is thread safe so there is extra overhead, so it is mainly used for multithreaded program.

Syntax:

StringBuffer demoString = new StringBuffer(“GeeksforGeeks”);

3. StringBuilder

StringBuilder in Java represents an alternative to String and StringBuffer Class, as it creates a mutable sequence of characters and it is not thread safe. It is used only within the thread , so there is no extra overhead , so it is mainly used for single threaded program.

Syntax:

StringBuilder demoString = new StringBuilder(); demoString.append(“GFG”);

Immutable String in Java

A String is an unavoidable type of variable while writing any application program. String references are used to store various attributes like username, password, etc. In Java, String objects are immutable. Immutable simply means unmodifiable or unchangeable.

Once String object is created its data or state can’t be changed but a new String object is created.

Example:

As you can see in the above figure that two objects are created but s reference variable still refers to “Sachin” not to “Sachin Tendulkar”.

But if we explicitly assign it to the reference variable, it will refer to “Sachin Tendulkar” object.

Why String objects are immutable in Java?

As Java uses the concept of String literal. Suppose there are 5 reference variables, all refer to one object “Sachin”. If one reference variable changes the value of the object, it will be affected by all the reference variables. That is why String objects are immutable in Java.

Following are some features of String which makes String objects immutable.

1. ClassLoader:

A ClassLoader in Java uses a String object as an argument. Consider, if the String object is modifiable, the value might be changed and the class that is supposed to be loaded might be different.

To avoid this kind of misinterpretation, String is immutable.

2. Thread Safe:

As the String object is immutable we don’t have to take care of the synchronization that is required while sharing an object across multiple threads.

3. Security:

As we have seen in class loading, immutable String objects avoid further errors by loading the correct class. This leads to making the application program more secure. Consider an example of banking software. The username and password cannot be modified by any intruder because String objects are immutable. This can make the application program more secure.

4. Heap Space:

The immutability of String helps to minimize the usage in the heap memory. When we try to declare a new String object, the JVM checks whether the value already exists in the String pool or not. If it exists, the same value is assigned to the new object. This feature allows Java to use the heap space efficiently.

Why String class is Final in Java?

The reason behind the String class being final is because no one can override the methods of the String class. So that it can provide the same features to the new String objects as well as to the old ones.

Static Keyword in Java

The static keyword in Java is used for memory management primarily. It can be applied to variables, methods, blocks, and nested classes. When a member is declared static , it belongs to the class rather than instances of the class.

This means that only one instance of the static member exists, regardless of how many objects of the class are created.

Usage of Static Variables

Static variables are shared among all instances of a class. They are also known as class variables.

Example:

class Example {
    static int counter = 0;
}

Static Methods

Static methods can be called without creating an instance of the class. They can access static data members and can change their values.

Example:

class Example {
    static void display() {
        System.out.println("Static method called");
    }
}

Static Blocks

Static blocks are used for static initializations of a class. This code inside the static block is executed only once when the class is loaded into memory.

Example :

class Example {
    static {
        System.out.println("Static block executed");
    }
}

Static Nested Classes

Static nested classes do not have access to other members of the enclosing class.

Example:

class OuterClass {
    static class NestedStaticClass {
        void display() {
            System.out.println("Static nested class method called");
        }
    }
}

Tips and Best Practices

Memory Efficiency: Use static variables and methods to save memory and improve performance when the same value or method is used across all instances.

Utility Methods: Declare utility methods as static, as they do not require any state from the class instances. (TBD).

public class MathUtils {
    public static int add(int a, int b) {
        return a + b;
    }
}

Initialization: Use static blocks for complex static variable initialization.

Access Control: Be mindful of access control; static members can be accessed directly using the class name, which might expose them unintentionally.

Avoid Overuse: Overusing static members can lead to code that is difficult to test and maintain. Use them judiciously. (TBD).

Common Mistakes and Errors

Non-static Context: Attempting to access non-static members from a static context will result in a compilation error.

Overuse of Static: Overusing static variables/methods can lead to issues with thread safety and maintenance complexity. Use static members only when necessary.

2. Why can’t a Java class be declared as static?

In Java, the static keyword typically flags a method or field as existing not once per instance of a class, but once ever. A class exists once anyway so in effect, all classes are “static” in this way and all objects are instances of classes.

Access Modifiers in Java

There are two types of modifiers in Java: access modifiers and non-access modifiers.

The access modifiers in Java specifies the accessibility or scope of a field, method, constructor, or class. We can change the access level of fields, constructors, methods, and class by applying the access modifier on it.

There are four types of Java access modifiers:

1. Private: The access level of a private modifier is only within the class. It cannot be accessed from outside the class.
2. Default: The access level of a default modifier is only within the package. It cannot be accessed from outside the package. If you do not specify any access level, it will be the default.
3. Protected: The access level of a protected modifier is within the package and outside the package through child class. If you do not make the child class, it cannot be accessed from outside the package.
4. Public: The access level of a public modifier is everywhere. It can be accessed from within the class, outside the class, within the package and outside the package.

There are many non-access modifiers, such as static, abstract, synchronized, native, volatile, transient, etc. Here, we are going to learn the access modifiers only.

---

Understanding Java Access Modifiers :

Access Modifier	within class	within package	outside package by subclass only	outside package
Private	Y	N	N	N
Default	Y	Y	N	N
Protected	Y	Y	Y	N
Public	Y	Y	Y	Y

1) Private

The private access modifier is accessible only within the class.

Role of Private Constructor

If you make any class constructor private, you cannot create the instance of that class from outside the class.

2) Default

If you don’t use any modifier, it is treated as default by default. The default modifier is accessible only within package. It cannot be accessed from outside the package. It provides more accessibility than private. But, it is more restrictive than protected, and public.

Example

public class Customer
{

Customer()

{

System.out.println(“Customer”);

}
public static void main(String[] args)
{

Customer prod = new Customer();

}

}

3) Protected

The protected access modifier is accessible within package and outside the package but through inheritance only.

The protected access modifier can be applied on the data member, method and constructor. It can’t be applied on the class.

It provides more accessibility than the default modifer.

4) Public

The public access modifier is accessible everywhere. It has the widest scope among all other modifiers.

2. What is Package ?

A java package is a group of similar types of classes, interfaces and sub-packages.

Package in java can be categorized in two form, built-in package and user-defined package.

There are many built-in packages such as java, lang, awt, javax, swing, net, io, util, sql etc.

Advantage of Java Package

1) Java package is used to categorize the classes and interfaces so that they can be easily maintained.

2) Java package provides access protection.

3) Java package removes naming collision.

---

Example :

package com.billed;

public class Billed
{
public static void main(String[] args)
{
System.out.println(“Billed a value”);

}
}

How to compile java package

• javac -d directory javafilename  

How to access package from another package?

There are three ways to access the package from outside the package.

1. import package.*;
2. import package.classname;
3. fully qualified name.

1) Using packagename.*

If you use package.* then all the classes and interfaces of this package will be accessible but not subpackages.

The import keyword is used to make the classes and interface of another package accessible to the current package.

2) Using packagename.classname

If you import package.classname then only declared class of this package will be accessible.

3) Using fully qualified name

If you use fully qualified name then only declared class of this package will be accessible. Now there is no need to import. But you need to use fully qualified name every time when you are accessing the class or interface.

Note: Sequence of the program must be package then import then class.

Subpackage in java

Package inside the package is called the subpackage. It should be created to categorize the package further.

Method Overloading:

If a class has multiple methods having same name but different in parameters, it is known as Method Overloading.

If we have to perform only one operation, having same name of the methods increases the readability of the program.

Suppose you have to perform addition of the given numbers but there can be any number of arguments, if you write the method such as a(int,int) for two parameters, and b(int,int,int) for three parameters then it may be difficult for you as well as other programmers to understand the behavior of the method because its name differs.

Advantage of method overloading :

• Method overloading increases the readability of the program.

Different ways to overload the method :

There are two ways to overload the method in java

1. By changing number of arguments
2. By changing the data type

1) Method Overloading: changing no. of arguments

In this example, we have created two methods, first add() method performs addition of two numbers and second add method performs addition of three numbers.

//Method overloading changing no of arguments

class Adder
{

public static int add(int a,int b)
{
return a+b;
}
public static int add(int a,int b,int c)
{
return a+b+c;
}
public static void main(String[] srga)
{
System.out.println(Adder.add(1,12));
System.out.println(Adder.add(1,12,2));
}
}

Out put :

13

15

2) Method Overloading: changing data type of arguments

In this example, we have created two methods that differs in data type. The first add method receives two integer arguments and second add method receives two double arguments.

class Adder
{
static int add(int a,int b)
{
return a+b;
}
static double add(double a,double b)
{
return a+b;
}
public static void main(String[] args)
{
System.out.println(Adder.add(2,13));
System.out.println(Adder.add(2.3,2.3));
}
}

Out put :

15

4.6

2. What is Constructor ?

In Java, a constructor is a block of codes similar to the method. It is called when an instance of the class is created. At the time of calling constructor, memory for the object is allocated in the memory.

It is a special type of method which is used to initialize the object.

Every time an object is created using the new keyword, at least one constructor is called.

It calls a default constructor if there is no constructor available in the class. In such case, Java compiler provides a default constructor by default.

Rules for Creating Java Constructor :

1. Constructor name must be the same as its class name.
2. A Constructor must have no explicit return type.
3. A Java constructor cannot be abstract, static, final, and synchronized.(TBD).

Types of Java Constructors :

There are two types of constructors in Java:

1. Default Constructor (no-arg constructor)
2. Parameterized Constructor

Default Constructor :

A constructor is called “Default Constructor” when it does not have any parameter.

Syntax:

• <class_name>(){}  

Example :

public class Customer
{

Customer()

{

System.out.println(“Customer”);

}
public static void main(String[] args)
{

Customer prod = new Customer();

}

}

Out put :

“Customer”.

What is the purpose of a default constructor?

The default constructor is used to provide the default values to the object like 0, null, etc., depending on the type.

Parameterized Constructor :

A constructor which has a specific number of parameters is called a parameterized constructor.

Why use the parameterized constructor?

The parameterized constructor is used to provide different values to distinct objects. However, you can provide the same values also.

Example :

public class Constroctor1
{
String name;
int price;

public Constroctor1(String name, int price)
{
System.out.println(“Milk rate is”);
this.name = name;
this.price = price;
}
public static void main(String[] args)
{

Constroctor1 cus = new Constroctor1(“milk”, 35);
System.out.println(cus.name);
System.out.println(cus.price);

}
}

Out put :

Milk rate is
milk
35

Constructor Overloading in Java

In Java, a constructor is just like a method but without return type. It can also be overloaded like Java methods.

Constructor overloading in Java is a technique of having more than one constructor with different parameter lists. They are arranged in a way that each constructor performs a different task. They are differentiated by the compiler by the number of parameters in the list and their types.

Example:

public class SuperMarket
{
String name;
int price;

public SuperMarket(String name,int price)
{
this.name = name;
this.price = price;
}

public SuperMarket()
{

}

public static void main(String[] args)
{
SuperMarket prod1 = new SuperMarket(“milk”,30);
SuperMarket prod2 = new SuperMarket(“curd”,20);
SuperMarket prod3 = new SuperMarket();
System.out.println(prod1.name);
System.out.println(prod1.price);
System.out.println(prod2.name);
System.out.println(prod2.price);
prod1.buy();

}

public void buy()
{
System.out.println(price);
System.out.println(name);

}

}

Out put :

milk
30
curd
10
30
milk

Difference Between Constructor and Method in Java

Java Constructor	Java Method
A constructor is used to initialize the state of an object.	A method is used to expose the behavior of an object.
A constructor must not have a return type.	A method must have a return type.
The constructor is invoked implicitly.	The method is invoked explicitly.
The Java compiler provides a default constructor if we do not have any constructor in a class.	The method is not provided by the compiler in any case.
The constructor name must be same as the class name.	The method name may or may not be same as the class name.

Java Copy Constructor

There is no copy constructor in Java. However, we can copy the values from one object to another like copy constructor in C++.

There are the following ways to copy the values of one object into another:

• By Using Constructor
• By Assigning the Values of One Object into Another
• By Using clone() Method of the Object Class

Java Super Class Constructor :

In Java, the concept of the “super constructor” refers to a subclass’s ability to explicitly invoke a constructor of its superclass. It is a fundamental aspect of Java’s inheritance feature, which allows one class to inherit fields and methods from another. Using the super keyword to call a superclass’s constructor is crucial for the proper initialization of an object’s inheritance hierarchy.

SIMPLE EXAMPLES :

1. What is class ?

In object-oriented programming, a class is a basic building block. It can be defined as template that describes the data and behaviour associated with the class instantiation. Instantiating is a class is to create an object (variable) of that class that can be used to access the member variables and methods of the class.

1. Modifiers: A class can be public or has default access.
2. class keyword: The class keyword is used to create a class.
3. Class name: The name must begin with an initial letter (capitalized by convention).
4. Superclass (if any): The name of the class’s parent (superclass), if any, preceded by the keyword extends. A class can only extend (subclass) one parent.
5. Interfaces (if any): A comma-separated list of interfaces implemented by the class, if any, preceded by the keyword implements. A class can implement more than one interface.
6. Body: The class body surrounded by braces, { }.

2. What is Object ?

An entity that has state and behavior is known as an object e.g., chair, bike, marker, pen, table, car, etc. It can be physical or logical (tangible and intangible). The example of an intangible object is the banking system.

• State: represents the data (value) of an object.
• Behavior: represents the behavior (functionality) of an object such as deposit, withdraw, etc.
• Identity: An object identity is typically implemented via a unique ID. The value of the ID is not visible to the external user. However, it is used internally by the JVM to identify each object uniquely.

3. What is data types ?

Data types specify the different sizes and values that can be stored in the variable. There are two types of data types in Java:

1. Primitive data types: The primitive data types include boolean, char, byte, short, int, long, float and double.
2. Non-primitive data types: The non-primitive data types include Classes, Interfaces, and Arrays.

Java Primitive data types:

1. boolean data type
2. byte data type
3. char data type
4. short data type
5. int data type
6. long data type
7. float data type
8. double data type

Non-Primitive Data Types in Java

In Java, non-primitive data types, also known as reference data types, are used to store complex objects rather than simple values. Unlike primitive data types that store the actual values, reference data types store references or memory addresses that point to the location of the object in memory. This distinction is important because it affects how these data types are stored, passed, and manipulated in Java programs.

4. What is variables ?

Variables are containers for storing data values.

In Java, there are different types of variables, for example:

• String – stores text, such as “Hello”. String values are surrounded by double quotes
• int – stores integers (whole numbers), without decimals, such as 123 or -123
• float – stores floating point numbers, with decimals, such as 19.99 or -19.99
• char – stores single characters, such as ‘a’ or ‘B’. Char values are surrounded by single quotes
• boolean – stores values with two states: true or false

Syntax :

1	type variableName = value;

5. What is Methods ?

The method in Java or Methods of Java is a collection of statements that perform some specific tasks and return the result to the caller. A Java method can perform some specific tasks without returning anything. Java Methods allows us to reuse the code without retyping the code. In Java, every method must be part of some class that is different from languages like C, C++, and Python.

• A method is like a function i.e. used to expose the behavior of an object.
• It is a set of codes that perform a particular task.

Two types of Method :

Static vs Non-static Method

This table summarizes the key differences between static and non-static methods in Java or similar object-oriented programming languages.

Aspect	Static Methods	Non-static Methods
Associated with	Class	Instance
Accessing Members and Methods	Can only directly access static members and methods of the class.	Can directly access both static and non-static members and methods of the class.
Initialization	Initialized when the class is loaded into memory.	Initialized when an instance of the class is created.
Scope	Available throughout the program execution	Available as long as the instance exists
Usage	Useful for utility methods, where the method does not depend on instance-specific data.	Useful for operations that require access to instance-specific data.
Calling Process	Can be called using the class name.	Must be called using an instance of the class.
Binding Process	Bound at compile-time.	Bound at runtime.
Overriding Process	Cannot be overridden.	Can be overridden in subclasses.
Memory Allocation	Memory is allocated only once for the entire program execution.	Memory allocated each time an instance is created.

6. Features of Java

The primary objective of Java programming language creation was to make it portable, simple and secure programming language. Apart from this, there are also some excellent features which play an important role in the popularity of this language. The features of Java are also known as Java buzzwords.

A list of the most important features of the Java language is given below.

1. Simple
2. Object-Oriented
3. Portable
4. Platform independent
5. Secured
6. Robust
7. Architecture neutral
8. Interpreted
9. High Performance
10. Multithreaded
11. Distributed
12. Dynamic

7. Java Architecture

Java Architecture is a collection of components, i.e., JVM, JRE, and JDK. It integrates the process of interpretation and compilation. It defines all the processes involved in creating a Java program. Java Architecture explains each and every step of how a program is compiled and executed.

Java Architecture can be explained by using the following steps:

• There is a process of compilation and interpretation in Java.
• Java compiler converts the Java code into byte code.
• After that, the JVM converts the byte code into machine code.
• The machine code is then executed by the machine.