Author: admin

In Java, this is a reference variable, this can be used inside any method or constructor to refer to the current object.

Following demonstrating the use of this

volume(double w, double h, double d) 
 {  
  this.width = w; 
  this.height = h; 
  this.depth = d;
 }  

Use of this Keyword in constructor:

class Student
 {
  String name;
  int marks;

  Student(String name, int marks)
  {
   this.name = name;   //use of this
   this.marks = marks; // use of this
  }
  void display()
  {
   System.out.println("Name: " + name + " marks:" + marks);
  }
 }
 public class main
 {
  public static void main (String[] args) 
  {
   Student st = new Student("Daniel", 90);
   st.display();
  }
 } 

Output:

Name: Daniel marks:90

Note: that, Java does not allow to declare two local variables with the same name inside the same or enclosing scopes, so the use of the same parameter name and data-members(instance variable) is possible because of this operator.
this keyword used within the constructor refers to the instance variable of that constructor or class.

In the above example, this.name = name, this.name refers to the instance variable whereas the name on the right side refers to the parameter value. and equal(=) sign assign parameter value to an instance variable. Also called Instance Variable Hiding.

If we do not use this keyword violating the Java declaration process, we get the following result:

class Student
 {
  String name;
  int marks;

  Student(String name, int marks)
  {
   name = name;   //not using of this
   marks = marks; //not using of this
  }
  void display()
  {
   System.out.println("Name: " + name + " marks:" + marks);
  }
 }
 public class main
 {
  public static void main (String[] args) 
  {
   Student st = new Student("Daniel", 90);
   st.display();
  }
 }

Output:

Name: null marks:0

this Keyword: to pass as an argument in the method:

class Method
 {
  void m1(Method obj)
  {
   System.out.println("This is method m1");
  }
  void m2()
  {
   m1(this);
  }
 }
 class Main
 {
  public static void main (String[] args) 
  {
   Method m = new Method();
   m.m2();
  }
 }

Output:

This is method m1

this: Invoke current class method:

The method of the current class can be invoked by using this keyword. If this keyword is not used then the compiler automatically adds this keyword while invoking the method.

source code:

 class Method
 {
  void m1()
  {
   System.out.println("This is method m1");
  }
  void m2()
  {
   System.out.println("This is method m2");
   this.m1();
  }
 }
 class Main
 {
  public static void main (String[] args) 
  {
   Method m = new Method();
   m.m2();
  }
 }

Output:

This is method m2
This is method m1

StringBuffer and StringBuilder in java is a class that provides the mutable(changeable) ability.
Since a String is immutable that is its value cannot be changed once the object is created. So to modify the String, StringBuffer and StringBuilder class is used.

Both these classes work fine but the difference is that the StringBuffer is thread-safe whereas StringBuilder is not.

• Far a faster process, consider using StringBuilder because it is faster than StringBuffer.
• For safety, purposes consider using StringBuilder.

StringBuffer Methods:

1. StringBuffer append() method:

This method concatenates the two string and updates the result. The method takes boolean, char, int, long, Strings, etc.

Example for StringBuffer append() in Java:

 public class StringBufferTest
  {  
   public static void main(String args[])
   {  
    StringBuffer s =  new StringBuffer("Long ");  
    s.append("Day");//changed with Day  
    System.out.println(s);//prints the concatenated result  
   }  
  }

Output:

 Long Day

2. StringBuffer insert() method:

This String inserts the new string in a specified position. We need to offset the position before the value as shown in an example.

Example for StringBuffer insert() in Java:

 public class StringBufferTest
  {  
  public static void main(String args[])
  {  
    StringBuffer s = new StringBuffer("Long ");  
    s.insert(1,"Day");//now original string is changed  

    System.out.println(s);//prints HJavaello  
  }  
  }

Output:

 LDayong 

3. StringBuffer delete() method:

As the name suggest, this method is used to remove/delete the string by index number. We need to specify the beginIndex and endIndex.

Example for StringBuffer delete() in Java:

 public class StringBufferTest 
  {
  public static void main(String args[]) 
  {
    StringBuffer s = new StringBuffer("ABCDEFGHIJK");
    s.delete(4, 8); 

    System.out.println(s); 
  }  
  }

Output:

ABCDIJK

4. StringBuffer replace() method:

This method is used to replace a String with another String within a specified index.

This content three values one to remove from beginIndex to endIndex and then the String value for replacement.

Example for StringBuffer replace() in Java:

 public class StringBufferTest 
  {
   public static void main(String args[]) 
   {
     StringBuffer s = new StringBuffer("ABCDEFGHIJKJ");
     s.replace(4, 9, "xyz");

     System.out.println(s); 
   }  
  }

Output:

 ABCDxyzJKJ 

5. StringBuffer reverse() method:

This method reverses the value of the string that is invoked.

Example for StringBuffer reverse() in Java:

 public class StringBufferTest 
 {
  public static void main(String args[])
  {
   StringBuffer s = new StringBuffer("Sting Buffer");
   s.reverse();

   System.out.println(s);
  }  
 }

Output:

 reffuB gnirtS 

List of some other methods that are similar to string class:

1. void ensureCapacity(int minimumCapacity):
   This method ensures that the buffer capacity is at least to minimum capacity.
2. int capacity():
   It returns the current capacity of the string buffer.
3. int indexOf(String str):
   The index of the first occurrence of the specified substring is returned within this string.
4. int indexOf(String str, int fromIndex):
   The index of the first occurrence of the specified substring is returned within this string and it starts from the index specified.
5. int lastIndexOf(String str, int fromIndex):
   The index of the last occurrence of the specified substring is returned within this string and from the specified index.
6. void setLength(int newLength):
   This method sets the length of the string buffer.
7. int length():
   It is used to return the length of the string buffer.
8. String toString():
   The data represented to this string buffer is converted to a string through this method
9. char charAt(int index):
   It returns the sequence currently represented by the string buffer that is specified the index argument.
10. CharSequence subSequence(int start, int end):
    This method returns a new character sequence that is a sub-part of this sequence.

There are more String methods such as, String substring(int start, int end),  String substring(int start),  void setCharAt(int index, char ch), int lastIndexOf(String str), void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin).

The Association of the method call to the method body is known as binding. There are two types of binding in java:

• Static binding.
• Dynamic bindinng.

1. Static Binding or Early Binding in Java:

The binding that resolved at compile time is known as Static Binding or Early Binding. There are three methods that cannot be overridden and the type of the class is determined at the compile time.

They are static, private and final methods. They are bind at compile time. In this type, the compiler knows the type of object or class to which object belongs to during the execution.

Example of Static Binding or Early Binding in Java:

class SuperClass 
 { 
    static void display() 
    { 
        System.out.println("Displaying superclass."); 
    } 
 } 
 class SubClass extends SuperClass 
 { 
    static void display() 
    { 
        System.out.println("Displaying subclass."); 
    } 
 } 
 public class StaticTest 
 {
  public static void main(String[] args) 
  { 
    //Reference is of SuperClass type and object is SuperClass type
    SuperClass sup = new SuperClass();
    
    //Reference is of SuperClass type and object is SubClass type
    SuperClass sub = new SubClass(); 
    
    sup.display(); 
    sub.display(); 
  } 
 }

Output of Static Binding:

 Displaying superclass.
 Displaying superclass.

In this above example, two objects are created (sup, sub) of different types referring to the same class type(SuperClass type). Here the display() method of SuperClass is static, and therefore compiler knows that it will not be overridden in subclasses and also knows which display() method to call and hence no ambiguity.

2. Dynamic Binding or Late Binding in Java:

The binding that resolved at run time is known as Static Binding or Late Binding. The perfect example of this would be Overriding. Consider a method overriding where parent class and child class has the same method.

Example Dynamic Binding in Java:
In the following example, the overriding of a method is possible because no methods are declared static, private, and final.

class SuperClass 
 { 
  void display() 
  { 
    System.out.println("Displaying superclass."); 
  }  
 } 
 class SubClass extends SuperClass 
 { 
  void display() 
  {  
    System.out.println("Displaying subclass."); 
  } 
 } 
 public class StaticTest 
 {
  public static void main(String[] args) 
  { 
   //Reference is of SuperClass typ and object is SuperClass type
   SuperClass sup = new SuperClass();

   //Reference is of SuperClass typ and object is SubClass type
   SuperClass sub = new SubClass(); 

   sup.display(); 
   sub.display(); 
  } 
 }

Output of Dynamic Binding:

 Displaying superclass.
 Displaying subclass.

A string is defined as a series of characters or an array of characters in java. They are present within the double quote.

Create a String:

One way to create a String is to directly declare it within the double quote that is by String Literal:

String s = "SimpleToCode";

Like any other object, it is possible to create a string object with the help of a new keyword.
such as:

char[] s = {'S','i','m','p','l','e','T','o','C','o','d','e'};  
String obj = new String(s);

Example:

 public class StringTest 
 {

  public static void main(String args[]) 
  {
    String s = "Simple To Code";
    System.out.println( s );
  }
 }

Output:

 Simple To Code

Example of string with object in Java:

 public class StringTest 
 {

  public static void main(String args[]) 
  {
    char[] s = {'S','i','m','p','l','e',' ','T','o',' ','C','o','d','e'};  
    String obj = new String(s);
    System.out.println( obj );
  }
 }

Output:

Simple To Code

Note that: it also takes blank space as a character.
Also, string objects are immutable that is their values are unchangeable once the object is created.

String Methods:

Java provides Various String Methods for String Operation such as compare(), concat(), equals(), length(), compareTo() and amany more.

List of some string Methods supported by Java are:

1. char charAt(int index):
   This method returns the character at the specified index.
2. int compareTo(String secondString):
   The method compares the two strings depending upon their Unicode Value.
3. int compareTo(Object o):
   Compares the present String to another object.
4. String concat(String str):
   This method concatenates the String ‘str’ at the end of the string.
5. boolean equals(Object obj):
   This method compares the string to the specified object.
6. boolean endsWith(String suffix):
   This method checks or tests whether the string ends with the specified suffix or not.
7. boolean startsWith(String prefix):
   It checks for the string to have a specified prefix and depending on that it returns a true or false boolean value.
8. int compareToIgnoreCase(String str):
   It compares the string the same as compareTo() but here it ignores the case of the string.
9. int hashCode():
   This method returns the hash code of the string.
10. int indexOf(int ch):
    The index of the first occurrence of the specified character ‘ch’ is returned in the string.
11. int lastIndexOf(int ch):
    This one returns the last occurrence ‘ch’ in the string.
12. int indexOf(String str):
    The index of the first occurrence of the specified substring ‘str’ is returned through this method.
13. int lastindexOf(String str):
    similarly, this method returns the last occurrence of the string ‘str’.
14. String intern():
    This method first searches for the particular string and returns the reference of it otherwise it allocates the memory to the particular string and assigns the reference to it.
15. int length():
    This method returns the length of the string.
16. char[] toCharArray():
    It is used to convert the string to a new array.
17. String toString():
    This already present string is itself return.
18. String toLowerCase():
    It is used to all the characters of the string to lower case by the default locale.
19. String toUpperCase():
    It is used to all the characters of the string to upper case by the default locale.
20. String trim():
    It returns the substring of the original string after omitting leading and trailing white spaces.

There are many more String methods such as, static String copyValueOf(char[] data),  static String valueOf(),  byte[] getBytes(),  boolean matches(String regex),  static String copyValueOf(char[] data, int offset, int count),  string[] split(String regex) and so on.

The decision-making statement in Java is used when the user wants a specific block of code to be executed when the given condition is fulfilled.

Java programming language provides the following types of decision-making statements:

• if statement 
• if-else statement 
• nested-if statement 
• if-else-if ladder statement 
• switch-case statement 

if statement

Among the decision making statements, it is the most simple one. It checks if the condition is true or not, and if it is true then it executes the block of code inside if otherwise, it will not. The block that is executed is placed within the curly braces({}).

Syntax of if statement in Java:

  if (boolean expression)
  {
   /* if expression is true */
   statements... ; /* Execute statements */
  }

Example: Click here

if-else statement

There are two-part in this statement. First is the if statement, here it checks for the condition to be true and if it is true then it will execute the code present inside the if. But if the condition is false then the code inside the else statement will be executed.

Syntax of if-else statement in Java:

 if (condition) 
 {
  //code executed if condition true 
 }
 else
 {
  //code executed if condition false 
 }

Example: Click here

nested-if statement

This statement allows the user to use if block inside the other if block. And the inner if is executed only if the outer if is true in condition.

Syntax of nested if statement in java:

 if(condition1)
 {    
    //block of code to be executed    
    if(condition2)
    {  
      //block of code to be executed    
    }    
 } 

Example: Click here

if-else-if ladder statement

This statement allows the user to have multiple options to check for different conditions. Here, if one of the if or else-if condition is true then that part of the code will be executed and the rest will be bypassed. if none of the conditions is true then the final else statement at the end will be executed.

Syntax of if-else-if ladder statement in java:

 if(condition1)
 {  
   //code to be executed if condition1 is true  
 }
  else if(condition2){  
   //code to be executed if condition2 is true  
   }  
  else if(condition3){  
   //code to be executed if condition3 is true  
   }  
    ...  
   else{  
    //final else if all the above condition are false 
    }

Example: Click here

switch-case statement

A switch statement allows a variable to be tested for equality against multiple values. It provides the case for the different blocks of code to be executed. Switch expression and case value must be of the same type. There must be at least one case or multiple cases with unique case values.

In the end, it can have a default case which is optional that is executed if no cases are matched. It can also have an optional break that is useful to exit the switch otherwise it continues to the next case.

Syntax of switch statements in Java:

  {
    case value1:    
    //code to be executed;    
    break;  //optional  
    case value2:    
    //code to be executed;    
    break;  //optional  
    .
    .
    .
    .    
    case valueN:    
    //code to be executed;    
    break;  //optional 
        
    default:     
    code to be executed if all cases are not matched;    
  }

Example: Click here