File handling is an important part of any application.

Java has several methods for creating, reading, updating, and deleting files.

Java File Handling

The File class from the java.io package, allows us to work with files.

To use the File class, create an object of the class, and specify the filename or directory name:

Example

import java.io.File;  // Import the File class

File myObj = new File("filename.txt"); // Specify the filename

Java Create and Write To Files

Create a File

To create a file in Java, you can use the createNewFile() method. This method returns a boolean value: true if the file was successfully created, and false if the file already exists. Note that the method is enclosed in a try...catch block. This is necessary because it throws an IOException if an error occurs (if the file cannot be created for some reason):

Example

import java.io.File;  // Import the File class
import java.io.IOException;  // Import the IOException class to handle errors

public class CreateFile {
  public static void main(String[] args) {
    try {
      File myObj = new File("filename.txt");
      if (myObj.createNewFile()) {
        System.out.println("File created: " + myObj.getName());
      } else {
        System.out.println("File already exists.");
      }
    } catch (IOException e) {
      System.out.println("An error occurred.");
      e.printStackTrace();
    }
  }
}

The output will be:

File created: filename.txt

To create a file in a specific directory (requires permission), specify the path of the file and use double backslashes to escape the “\" character (for Windows). On Mac and Linux you can just write the path, like: /Users/name/filename.txt

Example

File myObj = new File("C:\\Users\\MyName\\filename.txt");

Write To a File

In the following example, we use the FileWriter class together with its write() method to write some text to the file we created in the example above. Note that when you are done writing to the file, you should close it with the close() method:

Example

import java.io.FileWriter;   // Import the FileWriter class
import java.io.IOException;  // Import the IOException class to handle errors

public class WriteToFile {
  public static void main(String[] args) {
    try {
      FileWriter myWriter = new FileWriter("filename.txt");
      myWriter.write("Files in Java might be tricky, but it is fun enough!");
      myWriter.close();
      System.out.println("Successfully wrote to the file.");
    } catch (IOException e) {
      System.out.println("An error occurred.");
      e.printStackTrace();
    }
  }
}

The output will be:

Successfully wrote to the file.

Read a File

In the following example, we use the Scanner class to read the contents of the text file we created.

Example

import java.io.File;  // Import the File class
import java.io.FileNotFoundException;  // Import this class to handle errors
import java.util.Scanner; // Import the Scanner class to read text files

public class ReadFile {
  public static void main(String[] args) {
    try {
      File myObj = new File("filename.txt");
      Scanner myReader = new Scanner(myObj);
      while (myReader.hasNextLine()) {
        String data = myReader.nextLine();
        System.out.println(data);
      }
      myReader.close();
    } catch (FileNotFoundException e) {
      System.out.println("An error occurred.");
      e.printStackTrace();
    }
  }
}

The output will be:

Files in Java might be tricky, but it is fun enough!

Example

import java.io.File;  // Import the File class

public class GetFileInfo { 
  public static void main(String[] args) {
    File myObj = new File("filename.txt");
    if (myObj.exists()) {
      System.out.println("File name: " + myObj.getName());
      System.out.println("Absolute path: " + myObj.getAbsolutePath());
      System.out.println("Writeable: " + myObj.canWrite());
      System.out.println("Readable " + myObj.canRead());
      System.out.println("File size in bytes " + myObj.length());
    } else {
      System.out.println("The file does not exist.");
    }
  }
}

The output will be:

File name: filename.txt
Absolute path: C:\Users\MyName\filename.txt
Writeable: true
Readable: true
File size in bytes: 0

Note: There are many available classes in the Java API that can be used to read and write files in Java: FileReader, BufferedReader, Files, Scanner, FileInputStream, FileWriter, BufferedWriter, FileOutputStream, etc. Which one to use depends on the Java version you're working with and whether you need to read bytes or characters, and the size of the file/lines etc.

Delete a File

To delete a file in Java, use the delete() method:

Example

import java.io.File;  // Import the File class

public class DeleteFile {
  public static void main(String[] args) { 
    File myObj = new File("filename.txt"); 
    if (myObj.delete()) { 
      System.out.println("Deleted the file: " + myObj.getName());
    } else {
      System.out.println("Failed to delete the file.");
    } 
  } 
}

The output will be:

Deleted the file: filename.txt

Delete a Folder

You can also delete a folder. However, it must be empty:

Example

import java.io.File; 

public class DeleteFolder {
  public static void main(String[] args) { 
    File myObj = new File("C:\\Users\\MyName\\Test"); 
    if (myObj.delete()) { 
      System.out.println("Deleted the folder: " + myObj.getName());
    } else {
      System.out.println("Failed to delete the folder.");
    } 
  } 
}

The output will be:

Deleted the folder: Test

Java Files, Java File Handling, Java Create and Write to a file, Read a File, Delete a File was originally published in OOPS oriented Java Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.

Syntax:

package <pkg_name>
class classname{
  //Data Members and Methods
}

Packages are two different types

1. Predefined packages
2. User defined packages

The predefined packages are Java and Javax . The package consists of many sub packages.

Depending on the requirement of the user the respective package and the sub package will be imported into the user program using the keyword “import”.

Syntax:

import mainpkg.subpkg.classname

Incase of the user defined packages, the package definition and its path will be defined by the user.

Example

└── root
  └── mypack
    └── MyPackageClass.java

To create a package, use the package keyword:

MyPackageClass.java

package mypack;
class MyPackageClass {
  public static void main(String[] args) {
    System.out.println("This is my package!");
  }
}

Save the file as MyPackageClass.java, and compile it:

C:\Users\Your Name>javac MyPackageClass.java

Then compile the package:

C:\Users\Your Name>javac -d . MyPackageClass.java

This forces the compiler to create the “mypack” package.

The -d keyword specifies the destination for where to save the class file. You can use any directory name, like c:/user (windows), or, if you want to keep the package within the same directory, you can use the dot sign ".", like in the example above.

Note: The package name should be written in lower case to avoid conflict with class names.

When we compiled the package in the example above, a new folder was created, called “mypack”.

To run the MyPackageClass.java file, write the following:

C:\Users\Your Name>java mypack.MyPackageClass

The output will be:

This is my package!

Access Specifiers and their accessibility

In Java private, public, protected, default are the access specifiers. They define the level of access for each data member and the method and the class.

The following table demonstrates the level of access in Java program

Inner Classes

A class that is defined inside another class is an inner class.

class OuterClass{
   datamembers;
   class InnerClass{
      datamembers;
      methods;
   } 
   outer class methods;
}

With the help of an inner class we can have access to the data and methods of outer class directly. However, we can limit the scope of innerclass with in the outer class itself.

Local Classes

An inner class whose definition is given inside the method of a class is nothng but a local class.

class OuterClass{
   datamembers;

   public returntype method(){
      class InnerClass{
          datamembers;
          methods;
       }
   } 
   outer class methods;
}

Here in the class definition of the inner class is confined to the method in which it is defined.

Exception Handling

An abnormal solution i.e., raised during the program execution is nothing but exception. Every exception may lead to abnormal termination of program which may cause inconsistency in software reliability. Such exceptions may be handled by Java through a mechanism with which the program will be successfully executed even if an exception is raised.

When executing Java code, different errors can occur: coding errors made by the programmer, errors due to wrong input, or other unforeseeable things. When an error occurs, Java will normally stop and generate an error message. The technical term for this is: Java will throw an exception (throw an error).

Normally, the run time errors may be due to the external failures like memory errors, device errors and power failures. However, exception handling is not applicable for such errors. It can only be done for the runtime errors that are caused/raised due to the elements in the program.

Java supports the exception handling extensive through a predefined class library.

Every exception is a class in Java. Throwable is a super class for all Java exceptions. The main objective is to increase software reliability. No software should be terminated in the middle during the program execution for the trivial exceptions.

Exception handling is done by means of the following elements

1. try block
2. catch block
3. finally block
4. throw
5. throws

Java try and catch

The try statement allows you to define a block of code to be tested for errors while it is being executed.

The catch statement allows you to define a block of code to be executed, if an error occurs in the try block.

The try and catch keywords come in pairs:

Syntax

try {
  //  Block of code to try
}
catch(Exception e) {
  //  Block of code to handle errors
}

Consider the following example:

This will generate an error, because myNumbers[10] does not exist.

public class Main {
  public static void main(String[ ] args) {
    int[] myNumbers = {1, 2, 3};
    System.out.println(myNumbers[10]); // error!
  }
}

The output will be something like this:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10 at Main.main(Main.java:4)

If an error occurs, we can use try...catch to catch the error and execute some code to handle it:

Example

public class Main {
  public static void main(String[ ] args) {
    try {
      int[] myNumbers = {1, 2, 3};
      System.out.println(myNumbers[10]);
    } catch (Exception e) {
      System.out.println("Something went wrong.");
    }
  }
}

The output will be:

Something went wrong.

Finally

The finally statement lets you execute code, after try...catch, regardless of the result:

Example

public class Main {
  public static void main(String[] args) {
    try {
      int[] myNumbers = {1, 2, 3};
      System.out.println(myNumbers[10]);
    } catch (Exception e) {
      System.out.println("Something went wrong.");
    } finally {
      System.out.println("The 'try catch' is finished.");
    }
  }
}

The output will be:

Something went wrong.
The 'try catch' is finished.

The throw keyword

The throw statement allows you to create a custom error. The throw statement is used together with an exception type. There are many exception types available in Java: ArithmeticException, FileNotFoundException, ArrayIndexOutOfBoundsException, SecurityException, etc:

Example

Throw an exception if age is below 18 (print “Access denied”). If age is 18 or older, print “Access granted”:

public class Main {
  static void checkAge(int age) {
    if (age < 18) {
      throw new ArithmeticException("Access denied - You must be at least 18 years old.");
    }
    else {
      System.out.println("Access granted - You are old enough!");
    }
  }

  public static void main(String[] args) {
    checkAge(15); // Set age to 15 (which is below 18...)
  }
}

The output will be:

Exception in thread "main" java.lang.ArithmeticException: Access denied - You must be at least 18 years old.
        at Main.checkAge(Main.java:4)
        at Main.main(Main.java:12)

If age was 20, you would not get an exception:

Example

checkAge(20);
The output will be:
Access granted - You are old enough!

Packages, Access Specifiers, Exception Handling was originally published in OOPS oriented Java Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.

Inheritance

It is the ability to extract the properties of one class into another class.

The main objective is to provide code reusability. It reduces the code redundancy to a greater extent which saves lot of developer time.

Types of Inheritance:

1. Single
2. Multi level
3. Hierarchical

Multiple and Hybrid inheritances can be achieved through Interfaces but not through classes.

In order to inherit one class to another class we use the keyword “extends”.

Single Inheritance

Here only two classes are involved in which one is parent class and the other one is the child class.

Once A is inherited into B we need not create object for class A. All the public methods of A can be accessed through object of class B.

Syntax:

class SuperClass{

       //body;
}
class SubClass extends SuperClass{ 
      //body; 
}

An example program for single Inheritance,

class Vehicle {
  protected String brand = "Ford";        // Vehicle attribute
  public void honk() {                    // Vehicle method
    System.out.println("Tuut, tuut!");
  }
}

class Car extends Vehicle {
  private String modelName = "Mustang";    // Car attribute
  public static void main(String[] args) {

    // Create a myCar object
    Car myCar = new Car();

    // Call the honk() method (from the Vehicle class) on the myCar object
    myCar.honk();

    // Display the value of the brand attribute (from the Vehicle class) and the value of the modelName from the Car class
    System.out.println(myCar.brand + " " + myCar.modelName);
  }
}

Constructors Using Inheritance

class CSE{
   private int tc;
   public CSE(int tc){
      this.tc = tc;
      System.out.print(this.tc);
   }
}

class CSE-A extends CSE{
   int ac;
   public CSE-A(int ac,int tc){
     super(tc);
     this.ac=ac;
     System.out.print(this.ac);
   }
}

public class CSEDemo{
  public static void main(String args[]){
      new CSE-A(64,2500;
  }
}

In order to call a super class method, the “Super” keyword is used.

Multi-Level Inheritance

In multilevel, a chain of classes are involved in Inheritance.

class Car{
   public Car()
   {
	System.out.println("Class Car");
   }
   public void vehicleType()
   {
	System.out.println("Vehicle Type: Car");
   }
}
class Maruti extends Car{
   public Maruti()
   {
	System.out.println("Class Maruti");
   }
   public void brand()
   {
	System.out.println("Brand: Maruti");
   }
   public void speed()
   {
	System.out.println("Max: 90Kmph");
   }
}
public class Maruti800 extends Maruti{

   public Maruti800()
   {
	System.out.println("Maruti Model: 800");
   }
   public void speed()
   {
	System.out.println("Max: 80Kmph");
   }
   public static void main(String args[])
   {
	 Maruti800 obj=new Maruti800();
	 obj.vehicleType();
	 obj.brand();
	 obj.speed();
   }
}

Output:

Class Car
Class Maruti
Maruti Model: 800
Vehicle Type: Car
Brand: Maruti
Max: 80Kmph

Abstract Classes and Methods

Data abstraction is the process of hiding certain details and showing only essential information to the user.
Abstraction can be achieved with either abstract classes or interfaces.

A class is a set of complete and incomplete methods is an abstract class.

The abstract keyword is a non-access modifier, used for classes and methods:

• Abstract class: is a restricted class that cannot be used to create objects (to access it, it must be inherited from another class).
• Abstract method: can only be used in an abstract class, and it does not have a body. The body is provided by the subclass (inherited from).

Abstract is the keyword to be prefixed before the method name and the class name as well. If at least one method is incomplete the entire class becomes incomplete. The definition to the incomplete method can be given in corresponding subclasses.

Each subclass can have its own definition to the abstract methods in the super class. The purpose of the abstract classes is to act as a base class. As it is abstract class we cannot create object for it. How ever an object reference can be created.

Most often the abstract classes are preferable to use in hierarchy inheritance.

An abstract class can have both abstract and regular methods:

abstract class Animal {
  public abstract void animalSound();
  public void sleep() {
    System.out.println("Zzz");
  }
}

From the example above, it is not possible to create an object of the Animal class:

Animal myObj = new Animal(); // will generate an error

To access the abstract class, it must be inherited from another class. To use the abstract class it must be inherited from another class.

Example

// Abstract class
abstract class Animal {
  // Abstract method (does not have a body)
  public abstract void animalSound();
  // Regular method
  public void sleep() {
    System.out.println("Zzz");
  }
}

// Subclass (inherit from Animal)
class Pig extends Animal {
  public void animalSound() {
    // The body of animalSound() is provided here
    System.out.println("The pig says: wee wee");
  }
}

class MyMainClass {
  public static void main(String[] args) {
    Pig myPig = new Pig(); // Create a Pig object
    myPig.animalSound();
    myPig.sleep();
  }
}

Output:

The pig says: wee wee
Zzz

Interfaces

Another way to achieve abstraction in Java, is with interfaces.

An interface is a completely "abstract class" that is used to group related methods with empty bodies:

Example

// interface
interface Animal {
  public void animalSound(); // interface method (does not have a body)
  public void run(); // interface method (does not have a body)
}

To access the interface methods, the interface must be “implemented” (kind like inherited) by another class with the implements keyword (instead of extends). The body of the interface method is provided by the "implement" class:

Example

// Interface
interface Animal {
  public void animalSound(); // interface method (does not have a body)
  public void sleep(); // interface method (does not have a body)
}

// Pig "implements" the Animal interface
class Pig implements Animal {
  public void animalSound() {
    // The body of animalSound() is provided here
    System.out.println("The pig says: wee wee");
  }
  public void sleep() {
    // The body of sleep() is provided here
    System.out.println("Zzz");
  }
}

class MyMainClass {
  public static void main(String[] args) {
    Pig myPig = new Pig();  // Create a Pig object
    myPig.animalSound();
    myPig.sleep();
  }
}

Output:

The pig says: wee wee
Zzz

Multiple Interfaces

To implement multiple interfaces, separate them with a comma:

Example

interface FirstInterface {
  public void myMethod(); // interface method
}

interface SecondInterface {
  public void myOtherMethod(); // interface method
}

class DemoClass implements FirstInterface, SecondInterface {
  public void myMethod() {
    System.out.println("Some text..");
  }
  public void myOtherMethod() {
    System.out.println("Some other text...");
  }
}

class MyMainClass {
  public static void main(String[] args) {
    DemoClass myObj = new DemoClass();
    myObj.myMethod();
    myObj.myOtherMethod();
  }
}

Output

some text..
Some other Text...

Final Keyword

In Java, data member of a class, a method of a class and the class itself can be prefixed by a keyword “final”. The keyword plays a significant role in defining the three different components in the class.

1. In case of a data member as final it behaves like a constant.

final int MAX=5;
final define PI=3.14

2. A method is declared as final then that method cannot be overwritten.

class superA{
   final public void show(){
     System.out.println("Hello CSE-A");}
}

class SubB extends SuperA{
   public void show(){
      System.out.println("Hi CSE-A");}
}

public class OverRidingDemo{
  public static void main(String args[]){
    SuperA x = new SuperA();
    x.show();
    SubB y = new subB();
    y.show();
 } 
}

The above program gives compilation error as the final method is overridden in the subclass. In the absence of final keywords, the code runs successfully.

3. In case of class is declared as final it cannot be inherited. It means that the class becomes an independent class.

final class superA{
   public void show(){
     System.out.println("Hello CSE-A");}
}

class SubB extends SuperA{
   public void show(){
      System.out.println("Hi CSE-A");}
}

public class OverRidingDemo{
  public static void main(String args[]){
    SuperA x = new SuperA();
    x.show();
    SubB y = new subB();
    y.show();
 } 
}

In case of method over riding the following access privilege's should be followed.

1. A public method can be overridden by a public method only.
2. A protected method can be overridden by either a protected or public method only.
3. A default method can be overridden by either a default or protected or public method only.
4. A private method can be overridden by either a private or default or protected or public method only.

Java Inheritance, Java Abstract Classes and Methods, Java Interfaces was originally published in OOPS oriented Java Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.

OOPs is a method of implementation where a co-operative collection of objects may be created, accessed and deployed.

Features:

1. Classes and Objects
2. Data Abstraction
3. Data Encapsulation
4. Polymorphism
5. Inheritance
6. Persistence
7. Extendability
8. Message Passing

Class

A class is a description of similar kind of objects or class is a blue print for several objects. A class is a logical entity that gives description of related objects.

Object

Object is a real world entity or An object is an instance of a class. An object is a physical entity which occupies certain space in memory.

Data Abstraction

It is a process of exhibiting the essential details by hiding the unwanted details on demand. It is a process of creating a new datatype called ADT [ Abstract Data Type].

Data Encapsulation

The process of wrapping up data and its methods into a single unit is nothing but encapsulation.

Poly Morphism

The ability to provide multiple definitions with same method signature.

Inheritance

The ability to extent the features of one class to another class is nothing but inheritance. The main Objective is code reusability.

Persistence

The process of making the object state permanent is nothing but persistence. The object by nature is temporary.

Extendibility

The ability to enhance the features or properties of the system without restructuring the existing system.

Message Passing

The process of invoking the method over an object is nothing but message passing.

An example program for demonstrating class and objects.

class Student{
  
  private int stno,year;
  private string name,branch;

  // method to set student details
  public setStudent() {
    stno = 1001;
    name = "Raju";
    branch = "CSE";
    year = 2;
  }

  // method to display the student details
  public void getStudent() {
    System.out.println(stno+" "+name+" "+br+" "+year);
  }
}

public class StudentDemo{
  public static void main(String[] args) {

    // create object s
    Student s = new Student();
   
    // set the student details
    // calling method setStudent()
    s.setStudent();

    // displaying the student details
    // calling method getStudent()
    s.getStudent();
  }
}

Output:

1001 Raju CSE 2

Constructors

A constructor is a special method that initializes an object of a class. Initialization is a process of assigning values to the data methods (or) instant variables of a class. Unless an object is initialized it cannot be kept in use.

A constructor initializes such objects when ever they are created. It is the first function to be executed when ever the object is created. It is executed only once and is invoked/implicitly called by the compiler.

The constructor must have the same name as its class name. Generally the constructor should be declared as public as it is meant for object initialization it doesn’t return any value. Even void should not be mentioned.

An example program for demonstrating Constructors

class Box{
 private int height,width,depth;

//Constructor
 public Box(){
  height=5;
  width=4;
  depth=3;
 }

//A method for setting height 
 public void setHeight(int h){
  height=h;
 }

//A method for setting width 
 public void setWidth(int w){
  width=w;
 }

//A method for setting depth 
 public void setDepth(int d){
  depth=d;
 }

//A method for setting all the attributes 
 public void setBox(int h,int w,int d){
  
  height=h;
  depth=d;
  width=w;
 }

//A method for getting height 
 public int getHeight(){
  return height;
 }

//A method for getting width 
 public int getWidth(){
  return width;
 }

//A method for getting depth 
 public int getDepth(){
  return depth;
 }

//A method for getting volume 
 public int getVolume(){
  return height*depth*width;
 }

}

public class BoxDemo{
 public static void main(String[] args) {
  Box b = new Box();
  System.out.println("Volume="+b.getVolume());
  b.setBox(1,2,3);
  System.out.println("Volume="+b.getVolume());
  b.setHeight(10);
  System.out.println("Volume="+b.getVolume());
  b.setBox(12,22,23);
  System.out.println("Volume="+b.getVolume());

System.out.println("Displaying the values of Height, Width, Depth");
  System.out.println(b.getHeight() + " "+b.getWidth()+" "+b.getDepth());

}
}

Output:

Volume=60
Volume=6
Volume=60
Volume=6072
Displaying the values of Height, Width, Depth
12 22 23

Parameterized Constructors

A constructor that accepts data as an argument is a parameterized constructor.

class Box{
 private int height,width,depth;

//Constructor
 public Box(int h,int w,int d){
  height=h;
  width=w;
  depth=d;
 }

//A method for setting height 
 public void setHeight(int h){
  height=h;
 }

//A method for setting width 
 public void setWidth(int w){
  width=w;
 }

//A method for setting depth 
 public void setDepth(int d){
  depth=d;
 }

//A method for setting all the attributes 
 public void setBox(int h,int w,int d){
  
  height=h;
  depth=d;
  width=w;
 }

//A method for getting height 
 public int getHeight(){
  return height;
 }

//A method for getting width 
 public int getWidth(){
  return width;
 }

//A method for getting depth 
 public int getDepth(){
  return depth;
 }

//A method for getting volume 
 public int getVolume(){
  return height*depth*width;
 }

}

public class BoxDemo{
 public static void main(String[] args) {
  Box b = new Box(1,2,3);
  System.out.println("Volume="+b.getVolume());
  b.setBox(1,2,3);
  System.out.println("Volume="+b.getVolume());
  b.setHeight(10);
  System.out.println("Volume="+b.getVolume());
  b.setBox(12,22,23);
  System.out.println("Volume="+b.getVolume());

System.out.println("Displaying the values of Height, Width, Depth");
  System.out.println(b.getHeight() + " "+b.getWidth()+" "+b.getDepth());

}
}

Output:

Volume=60
Volume=6
Volume=60
Volume=6072
Displaying the values of Height, Width, Depth
12 22 23

Static keyword

In a class either data or method can be declared as static.

1. In case of data as static the variable becomes sharable among all the object of the class has only one instance of the static variable is created in the method.
2. In case of method as static, it doesn’t use the object of a class. When a class doesn’t hold any data members then it is better to declare the method as static. A static method can be increased with the help of class name.
3. A class method can have access to static data only.

class Account {
//define variables
private int accno;
private double balance; // balance for account
private double annualInterestRate; //stores the current interest rate
private static int minbal=500;

//no arg construtor
Account () {
    balance = 0.0;
    annualInterestRate = 0.0;
}
//constructor with specific id and initial balance

Account(int no, double newBalance) {
    accno= no;
    balance = newBalance;
}

Account(int newno, double newBalance, double newAnnualInterestRate) {
    accno= newno;
    balance = newBalance;
    annualInterestRate = newAnnualInterestRate;
}

//accessor/mutator methods for accno, balance, and     annualInterestRate

public int getaccno() {
    return accno;
}

public double getBalance() {
    return balance;
}

public double getAnnualInterestRate() {
    return annualInterestRate;
}

public void setAccNo(int acc_no) {
    accno= acc_no;
}

public void setBalance(double newBalance) {
    balance = newBalance;
}

public void setAnnualInterestRate(double newAnnualInterestRate) {
    annualInterestRate = newAnnualInterestRate;
}

//define method getMonthlyInterestRate
double getMonthlyInterestRate() {
    return annualInterestRate/12;
}

//define method withdraw
double withdraw(double amount) {

if((balance-amount)>minbal)    
return balance -= amount;

else
return 0;
}
   
//define method deposit
double deposit(double amount) {
    return balance += amount;   
}
public static void changeMinBalance(){
minbal+=1000;
System.out.println("Minimum Balance Changed");

}

public class StaticDemo{

public static void main(String[] args) {
    
Account account1 = new Account(1122, 20000, .045);
account1.withdraw(2500);
account1.deposit(3000);

System.out.println("Account No:" + account1.accno);
System.out.println("Balance:" + account1.getBalance());
System.out.println("Interest Rate:" + account1.getAnnualInterestRate());
System.out.println("Balance after withdraw of 2500:" +       account1.getAnnualInterestRate());
System.out.println("Balance after deposit of 3000:" + account1.getAnnualInterestRate());
System.out.println("Monthly Interest:" + account1.accno);

Account.changeMinBalance();//Static method call
System.out.println("Process completed.");
}
}

Output

Account No:1122
Balance:20500.0
Interest Rate:0.045
Balance after withdraw of 2500:0.045
Balance after deposit of 3000:0.045
Monthly Interest:1122
Minimum Balance Changed
Process completed.

Polymorphism

It is the ability to provide multiple definations to the same method signature.

Here poly means many and morphism means forms.

Advantages

Polymorphism is used to build complex software system where the methods that form similar activity can have the same name.

The compiler is able to discriminate one method with another based on arguments. To be more specific the number of arguments, type of arguments and order of arguments.

Syntax of a method:

A method signature doesn’t include returntype. Here some of the valid and invalid methods are given below.

/* File name : Employee.java */
public class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }

   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }

   public String getAddress() {
      return address;
   }

   public void setAddress(String newAddress) {
      address = newAddress;
   }

   public int getNumber() {
      return number;
   }
}

Now suppose we extend Employee class as follows −

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary; // Annual salary
   
   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName()
      + " with salary " + salary);
   }
   
   public double getSalary() {
      return salary;
   }
   
   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

Now, you study the following program carefully and try to determine its output −

/* File name : VirtualDemo.java */
public class VirtualDemo {

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");   
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

Output

Constructing an Employee
Constructing an Employee

Call mailCheck using Salary reference --
Within mailCheck of Salary class
Mailing check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--
Within mailCheck of Salary class
Mailing check to John Adams with salary 2400.0

Here, we instantiate two Salary objects. One using a Salary reference s, and the other using an Employee reference e.

While invoking s.mailCheck(), the compiler sees mailCheck() in the Salary class at compile time, and the JVM invokes mailCheck() in the Salary class at run time.

mailCheck() on e is quite different because e is an Employee reference. When the compiler sees e.mailCheck(), the compiler sees the mailCheck() method in the Employee class.

Here, at compile time, the compiler used mailCheck() in Employee to validate this statement. At run time, however, the JVM invokes mailCheck() in the Salary class.

This behavior is referred to as virtual method invocation, and these methods are referred to as virtual methods. An overridden method is invoked at run time, no matter what data type the reference is that was used in the source code at compile time.

Constructor Overloading

As a constructor is also a mthod, it can also be overloaded.

If a class consists of multiple constructors it provides flexibility in creating objects for class.

// Java program to illustrate
// Constructor Overloading

class Box{

double width, height, depth;

// constructor used when all dimensions specified

Box(double w, double h, double d)

{

width = w;
height = h;
depth = d;
}

// constructor used when no dimensions specified

Box()

{
   width = height = depth = 0;
}

// constructor used when cube is created
Box(double len)

{
width = height = depth = len;

}
// compute and return volume

double volume(){
   return width * height * depth;
}
}

// Driver code

public class Test{

public static void main(String args[]){

// create boxes using the various
// constructors

Box mybox1 = new Box(10, 20, 15);
Box mybox2 = new Box();
Box mycube = new Box(7);
double vol;

// get volume of first box
vol = mybox1.volume();
System.out.println(" Volume of mybox1 is " + vol);

// get volume of second box

vol = mybox2.volume();
System.out.println(" Volume of mybox2 is " + vol);

// get volume of cube
vol = mycube.volume();
System.out.println(" Volume of mycube is " + vol);

}
}

Output:

Volume of mybox1 is 3000.0
Volume of mybox2 is 0.0
Volume of mycube is 343.0

Using this() in constructor overloading

this() reference can be used during constructor overloading to call default constructor implicitly from parameterized constructor. Please note, this() should be the first statement inside a constructor.

Java OOPs Concept, Constructors, PolyMorphism, Constructor Overloading, Static Keyword was originally published in OOPS oriented Java Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.

You can pass data, known as parameters, into a method.

Methods are used to perform certain actions, and they are also known as functions.

Why use methods? To reuse code: define the code once, and use it many times.

Create a Method

A method must be declared within a class. It is defined with the name of the method, followed by parentheses (). Java provides some pre-defined methods, such as System.out.println(), but you can also create your own methods to perform certain actions:

Creating a method inside MyClass:

public class MyClass {
  static void myMethod() {
    // code to be executed
  }
}

• myMethod() is the name of the method
• static means that the method belongs to the MyClass class and not an object of the MyClass class. You will learn more about objects and how to access methods through objects later in this tutorial.
• void means that this method does not have a return value. You will learn more about return values later in this chapter

Call a Method

To call a method in Java, write the method’s name followed by two parentheses () and a semicolon;

In the following example, myMethod() is used to print a text (the action), when it is called:

Inside main, call the myMethod() method:

public class MyClass {
  static void myMethod() {
    System.out.println("I just got executed!");
  }

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

// Outputs "I just got executed!"

A method can also be called multiple times:

public class MyClass {
  static void myMethod() {
    System.out.println("I just got executed!");
  }

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

// I just got executed!
// I just got executed!
// I just got executed!

Java Method Parameters

Parameters and Arguments

Information can be passed to methods as parameter. Parameters act as variables inside the method.

Parameters are specified after the method name, inside the parentheses. You can add as many parameters as you want, just separate them with a comma.

The following example has a method that takes a String called fname as parameter. When the method is called, we pass along a first name, which is used inside the method to print the full name:

public class MyClass {
  static void myMethod(String fname) {
    System.out.println(fname + " Refsnes");
  }

  public static void main(String[] args) {
    myMethod("Liam");
    myMethod("Jenny");
    myMethod("Anja");
  }
}
// Liam Refsnes
// Jenny Refsnes
// Anja Refsnes

When a parameter is passed to the method, it is called an argument. So, from the example above: fname is a parameter, while Liam, Jenny and Anja are arguments.

Multiple Parameters

You can have as many parameters as you like:

public class MyClass {
  static void myMethod(String fname, int age) {
    System.out.println(fname + " is " + age);
  }

  public static void main(String[] args) {
    myMethod("Liam", 5);
    myMethod("Jenny", 8);
    myMethod("Anja", 31);
  }
}

// Liam is 5
// Jenny is 8
// Anja is 31

Note that when you are working with multiple parameters, the method call must have the same number of arguments as there are parameters, and the arguments must be passed in the same order.

Return Values

The void keyword, used in the examples above, indicates that the method should not return a value. If you want the method to return a value, you can use a primitive data type (such as int, char, etc.) instead of void, and use the return keyword inside the method:

public class MyClass {
  static int myMethod(int x) {
    return 5 + x;
  }

  public static void main(String[] args) {
    System.out.println(myMethod(3));
  }
}
// Outputs 8 (5 + 3)

This example returns the sum of a method’s two parameters:

public class MyClass {
  static int myMethod(int x, int y) {
    return x + y;
  }

  public static void main(String[] args) {
    System.out.println(myMethod(5, 3));
  }
}
// Outputs 8 (5 + 3)

You can also store the result in a variable (recommended, as it is easier to read and maintain):

public class MyClass {
  static int myMethod(int x, int y) {
    return x + y;
  }

  public static void main(String[] args) {
    int z = myMethod(5, 3);
    System.out.println(z);
  }
}
// Outputs 8 (5 + 3)

A Method with If…Else

It is common to use if...else statements inside methods:

public class MyClass {

  // Create a checkAge() method with an integer variable called age
  static void checkAge(int age) {

    // If age is less than 18, print "access denied"
    if (age < 18) {
      System.out.println("Access denied - You are not old enough!");

    // If age is greater than 18, print "access granted"
    } else {
      System.out.println("Access granted - You are old enough!");
    }

  }

  public static void main(String[] args) {
    checkAge(20); // Call the checkAge method and pass along an age of 20
  }
}

// Outputs "Access granted - You are old enough!"

Java Method Overloading

Method Overloading

With method overloading, multiple methods can have the same name with different parameters:

int myMethod(int x)
float myMethod(float x)
double myMethod(double x, double y)

Consider the following example, which have two methods that add numbers of different type:

static int plusMethodInt(int x, int y) {
  return x + y;
}

static double plusMethodDouble(double x, double y) {
  return x + y;
}

public static void main(String[] args) {
  int myNum1 = plusMethodInt(8, 5);
  double myNum2 = plusMethodDouble(4.3, 6.26);
  System.out.println("int: " + myNum1);
  System.out.println("double: " + myNum2);
}

Instead of defining two methods that should do the same thing, it is better to overload one.

In the example below, we overload the plusMethod method to work for both int and double:

static int plusMethod(int x, int y) {
  return x + y;
}

static double plusMethod(double x, double y) {
  return x + y;
}

public static void main(String[] args) {
  int myNum1 = plusMethod(8, 5);
  double myNum2 = plusMethod(4.3, 6.26);
  System.out.println("int: " + myNum1);
  System.out.println("double: " + myNum2);
}

Note: Multiple methods can have the same name as long as the number and/or type of parameters are different.

Java Scope

In Java, variables are only accessible inside the region they are created. This is called scope.

Method Scope

Variables declared directly inside a method are available anywhere in the method following the line of code in which they were declared:

public class MyClass {
  public static void main(String[] args) {

    // Code here CANNOT use x

    int x = 100;

    // Code here can use x
    System.out.println(x);
  }
}

Block Scope

A block of code refers to all of the code between curly braces {}. Variables declared inside blocks of code are only accessible by the code between the curly braces, which follows the line in which the variable was declared:

public class MyClass {
  public static void main(String[] args) {

    // Code here CANNOT use x

    { // This is a block

      // Code here CANNOT use x

      int x = 100;

      // Code here CAN use x
      System.out.println(x);

   } // The block ends here

  // Code here CANNOT use x

  }
}

A block of code may exist on its own or it can belong to an if, while or for statement. In the case of for statements, variables declared in the statement itself are also available inside the block's scope.

Java Recursion

Recursion is the technique of making a function call itself. This technique provides a way to break complicated problems down into simple problems which are easier to solve.

Recursion may be a bit difficult to understand. The best way to figure out how it works is to experiment with it.

Recursion Example

Adding two numbers together is easy to do, but adding a range of numbers is more complicated. In the following example, recursion is used to add a range of numbers together by breaking it down into the simple task of adding two numbers:

Use recursion to add all of the numbers up to 10.

public class MyClass {
  public static void main(String[] args) {
    int result = sum(10);
    System.out.println(result);
  }
  public static int sum(int k) {
    if (k > 0) {
      return k + sum(k - 1);
    } else {
      return 0;
    }
  }
}

When the sum() function is called, it adds parameter k to the sum of all numbers smaller than k and returns the result. When k becomes 0, the function just returns 0. When running, the program follows these steps:

10 + sum(9)
10 + ( 9 + sum(8) )
10 + ( 9 + ( 8 + sum(7) ) )
…
10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + sum(0)
10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + 0

Since the function does not call itself when k is 0, the program stops there and returns the result.

Halting Condition

Just as loops can run into the problem of infinite looping, recursive functions can run into the problem of infinite recursion. Infinite recursion is when the function never stops calling itself. Every recursive function should have a halting condition, which is the condition where the function stops calling itself. In the previous example, the halting condition is when the parameter k becomes 0.

It is helpful to see a variety of different examples to better understand the concept. In this example, the function adds a range of numbers between a start and an end. The halting condition for this recursive function is when end is not greater than start:

Use recursion to add all of the numbers between 5 to 10.

public class MyClass {
  public static void main(String[] args) {
    int result = sum(5, 10);
    System.out.println(result);
  }
  public static int sum(int start, int end) {
    if (end > start) {
      return end + sum(start, end - 1);
    } else {
      return end;
    }
  }
}

Java Methods, Java Parameters, Java Method Overloading, Java Scope, Java Recursion was originally published in OOPS oriented Java Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.

In Java a string is a class rather than a character array. In other words, a character array is different from string in Java.

A string is an object with the set of characters. No null indicator at the end of the string object. A string class provides a set of methods that handles strings.

The following is the set of methods in Strings:

For Example,

public class StringDemo{

     public static void main(String args[]){

          String p=args[0];
          String q=args[1];
          String r = p;
          if(p.equalsIgnoreCase(q))
             System.out.println("Same")
          else
            System.out.println("Different")
         
          if(p==q)
            System.out.println("Same")
          else
            System.out.println("Different")

         if(p==r)
            System.out.println("Same")
          else
            System.out.println("Different")

     }

}

Output:

CSE-A   CSE-A
Same
Different
Same

Note: equals() compares the content of the object where as == compares the object references.

An example of string sort:

import java.util.*;

public class StringSort{

 public static void main(String args[]){

   int n,i,j;
   String k[];
   Scanner sc = new Scanner(System.in);
   System.out.println("Enter Number of strings");
   n=sc.nextInt();
   k=new String[n];
   System.out.println("Enter Names");
   for (i=0;i<n;i++)
    k[i]=sc.next();

   for(i=0;i<n;i++){
    for(j=i+1;j<n;j++){
     if(k[i].compareTo(k[j])>0)
     {
       String temp=k[i];
       k[i]=temp;
       k[j]=k[i];
     }
    }
   }

   System.out.println("After Sorting......");
   for(i=0;i<n;i++)
     System.out.println(k[i]);
  }
}

Output,

Enter Number of strings
5
Enter Names
c cplus java python ruby
After Sorting......
c
cplus
java
python
ruby

Now let us see a program with the string methods to toggle the characters in the given string.

Program to convert the given string into toggle case.

import java.util.*;

public class Toggle{

 public static void main(String[] args) {
  Scanner sc = new Scanner(System.in);
  char ch;
  System.out.println("Enter a String");
  String p = sc.next();

  for(int i=0;i<p.length();i++)
  {
   ch=p.charAt(i);
   if((ch>=65) &&(ch<=90))
    ch=Character.toLowerCase(ch);
   else
    ch=Character.toUpperCase(ch);

   System.out.print(ch);
  }
 }
}

Output, which we can do on the command prompt.

Enter a String
python

PYTHON

Now let us try to print prefixes and suffixes of the string:

import java.util.*;

public class StringsDemo{
 public static void main(String[] args) {
  char ch;
  Scanner sc=new Scanner(System.in);
  
  System.out.println("Enter String");
  String p=sc.next();
  
  System.out.println("Prfixes of the string are");
  for(int i=0;i<p.length();i++)
   System.out.println(p.substring(i));

  System.out.println("Sufixes of the string are");
  for(int i=0;i<p.length();i++)
   System.out.println(p.substring(0,i));

}
}

Output will be,

Enter String
Andhrapradesh

Prfixes of the string are
Andhrapradesh
ndhrapradesh
dhrapradesh
hrapradesh
rapradesh
apradesh
pradesh
radesh
adesh
desh
esh
sh
h

Sufixes of the string are

A
An
And
Andh
Andhr
Andhra
Andhrap
Andhrapr
Andhrapra
Andhraprad
Andhraprade
Andhraprades

Now let us check whether the given string is palindrome or not.

import java.util.*;

public class Palindrome{
 
 public static void main(String[] args) {
  
  char ch;
  Scanner sc=new Scanner(System.in);
  
  System.out.println("Enter String");
  String p=sc.next();

String q = new String(p);
  
  System.out.println("Prfixes of the string are");
  
  StringBuffer sb=new StringBuffer(q);
  sb.reverse();

if(p.equals(sb.toString()))
   System.out.println("Palindrome");
  else
   System.out.println("Not Palindrome");

}
}

Output,

E:\Programs\Java>java Palindrome
Enter String
abcdcba
Prfixes of the string are
Palindrome

E:\Programs\Java>java Palindrome
Enter String
abcdef
Prfixes of the string are
Not Palindrome

String Tokenizer:

It divides or splits a string into token(sub strings) based on the given symbol. The symbol should be mentioned in terms of a string. It is present in java.util package. It consists of three methods:

1. hasMoreTokens()
2. nextToken()
3. countTokens()

Let us see this with an example.

Now let us try to divide a sentence into strings.

import java.util.*;

public class STDemo{
 
 public static void main(String[] args) {
  
  String msg="Today is a holiday";

  StringTokenizer st= new StringTokenizer(msg," ");

  while(st.hasMoreTokens())
   System.out.println(st.nextToken());

}
}

Output will be,

Today
is
a
holiday

Java Strings was originally published in OOPS oriented Java Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.

Java supports the usual logical conditions from mathematics:

• Less than: a < b
• Less than or equal to: a <= b
• Greater than: a > b
• Greater than or equal to: a >= b
• Equal to a == b
• Not Equal to: a != b

Java has the following conditional statements:

• Use if to specify a block of code to be executed, if a specified condition is true
• Use else to specify a block of code to be executed, if the same condition is false
• Use else if to specify a new condition to test, if the first condition is false
• Use switch to specify many alternative blocks of code to be executed

The if Statement

Use the if statement to specify a block of Java code to be executed if a condition is true.

Syntax

if (condition) {
  // block of code to be executed if the condition is true
}

Note that if is in lowercase letters. Uppercase letters (If or IF) will generate an error.

In the example below, we test two values to find out if 20 is greater than 18. If the condition is true, print some text:

if (20 > 18) {
  System.out.println("20 is greater than 18");
}

We can also test variables:

int x = 20;
int y = 18;
if (x > y) {
  System.out.println("x is greater than y");
}

In the example above we use two variables, x and y, to test whether x is greater than y (using the > operator). As x is 20, and y is 18, and we know that 20 is greater than 18, we print to the screen that "x is greater than y".

The else Statement

Use the else statement to specify a block of code to be executed if the condition is false.

if (condition) {
  // block of code to be executed if the condition is true
} else {
  // block of code to be executed if the condition is false
}

For example,

int time = 20;
if (time < 18) {
  System.out.println("Good day.");
} else {
  System.out.println("Good evening.");
}
// Outputs "Good evening."

In the example above, time (20) is greater than 18, so the condition is false. Because of this, we move on to the else condition and print to the screen "Good evening". If the time was less than 18, the program would print "Good day".

The else if Statement

Use the else if statement to specify a new condition if the first condition is false.

Syntax

if (condition1) {
  // block of code to be executed if condition1 is true
} else if (condition2) {
  // block of code to be executed if the condition1 is false and condition2 is true
} else {
  // block of code to be executed if the condition1 is false and condition2 is false
}

For example,

int time = 22;
if (time < 10) {
  System.out.println("Good morning.");
} else if (time < 20) {
  System.out.println("Good day.");
} else {
  System.out.println("Good evening.");
}
// Outputs "Good evening."

In the example above, time (22) is greater than 10, so the first condition is false. The next condition, in the else if statement, is also false, so we move on to the else condition since condition1 and condition2 is both false - and print to the screen "Good evening".

However, if the time was 14, our program would print “Good day.”

If…Else as Ternary Operator:

There is also a short-hand if else, which is known as the ternary operator because it consists of three operands. It can be used to replace multiple lines of code with a single line. It is often used to replace simple if else statements:

variable = (condition) ? expressionTrue :  expressionFalse;

Instead of writing:

int time = 20;
if (time < 18) {
  System.out.println("Good day.");
} else {
  System.out.println("Good evening.");
}

You can simply write:

int time = 20;
String result = (time < 18) ? "Good day." : "Good evening.";
System.out.println(result);

• Print “Hello World” if x is greater than y.

int x = 50;
int y = 10;
 if(x > y) {
  System.out.println("Hello World");
}

Java Switch Statements

Use the switch statement to select one of many code blocks to be executed.

switch(expression) {
  case x:
    // code block
    break;
  case y:
    // code block
    break;
  default:
    // code block
}

This is how it works:

• The switch expression is evaluated once.
• The value of the expression is compared with the values of each case.
• If there is a match, the associated block of code is executed.
• The break and default keywords are optional, and will be described later in this chapter

The example below uses the weekday number to calculate the weekday name:

int day = 4;
switch (day) {
  case 1:
    System.out.println("Monday");
    break;
  case 2:
    System.out.println("Tuesday");
    break;
  case 3:
    System.out.println("Wednesday");
    break;
  case 4:
    System.out.println("Thursday");
    break;
  case 5:
    System.out.println("Friday");
    break;
  case 6:
    System.out.println("Saturday");
    break;
  case 7:
    System.out.println("Sunday");
    break;
}
// Outputs "Thursday" (day 4)

The break Keyword

When Java reaches a break keyword, it breaks out of the switch block.

This will stop the execution of more code and case testing inside the block.

When a match is found, and the job is done, it’s time for a break. There is no need for more testing.

A break can save a lot of execution time because it “ignores” the execution of all the rest of the code in the switch block.

The default Keyword

The default keyword specifies some code to run if there is no case match:

int day = 4;
switch (day) {
  case 6:
    System.out.println("Today is Saturday");
    break;
  case 7:
    System.out.println("Today is Sunday");
    break;
  default:
    System.out.println("Looking forward to the Weekend");
}
// Outputs "Looking forward to the Weekend"

Note that if the default statement is used as the last statement in a switch block, it does not need a break.

• Another example, Check the output

int day = 2;
switch (day) {
  case 1:
    System.out.println("Saturday");
    break;
  case 2:
    System.out.println("Sunday");
    break;
}

Loops

Loops can execute a block of code as long as a specified condition is reached.

Loops are handy because they save time, reduce errors, and they make code more readable.

Java While Loop

The while loop loops through a block of code as long as a specified condition is true:

while (condition) {
  // code block to be executed
}

In the example below, the code in the loop will run, over and over again, as long as a variable (i) is less than 5:

int i = 0;
while (i < 5) {
  System.out.println(i);
  i++;
}

Note: Do not forget to increase the variable used in the condition, otherwise the loop will never end!

The Do/While Loop

The do/while loop is a variant of the while loop. This loop will execute the code block once, before checking if the condition is true, then it will repeat the loop as long as the condition is true.

Syntax

do {
  // code block to be executed
}
while (condition);

The example below uses a do/while loop. The loop will always be executed at least once, even if the condition is false, because the code block is executed before the condition is tested:

int i = 0;
do {
  System.out.println(i);
  i++;
}
while (i < 5);

Do not forget to increase the variable used in the condition, otherwise the loop will never end!

• Print i as long as i is less than 6.

int i = 1;
 while(i < 6) {
  System.out.println(i); 
  i++;
}

For Loop

When you know exactly how many times you want to loop through a block of code, use the for loop instead of a while loop:

Syntax

for (statement 1; statement 2; statement 3) {
  // code block to be executed
 }

Statement 1 is executed (one time) before the execution of the code block.

Statement 2 defines the condition for executing the code block.

Statement 3 is executed (every time) after the code block has been executed.

The example below will print the numbers 0 to 4:

for (int i = 0; i < 5; i++) {
  System.out.println(i);
}

Statement 1 sets a variable before the loop starts (int i = 0).

Statement 2 defines the condition for the loop to run (i must be less than 5). If the condition is true, the loop will start over again, if it is false, the loop will end.

Statement 3 increases a value (i++) each time the code block in the loop has been executed.

Another Example,

for (int i = 0; i <= 10; i = i + 2) {
  System.out.println(i);
}

For-Each Loop

There is also a “for-each” loop, which is used exclusively to loop through elements in an array:

Syntax

for (type variableName : arrayName) {
  // code block to be executed
}

The following example outputs all elements in the cars array, using a “for-each” loop:

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
for (String i : cars) {
  System.out.println(i);
}

• Use a for loop to print "Yes" 5 times.

for(int i = 0; i < 5; ) {
  System.out.println();
}

Java Break

You have already seen the break statement used in an earlier chapter of this tutorial. It was used to "jump out" of a switch statement.

The break statement can also be used to jump out of a loop.

This example jumps out of the loop when i is equal to 4:

for (int i = 0; i < 10; i++) {
  if (i == 4) {
    break;
  }
  System.out.println(i);
}

Java Continue

The continue statement breaks one iteration (in the loop), if a specified condition occurs, and continues with the next iteration in the loop.

This example skips the value of 4:

for (int i = 0; i < 10; i++) {
  if (i == 4) {
    continue;
  }
  System.out.println(i);
}

Break and Continue in While Loop

You can also use break and continue in while loops:

Break Example

int i = 0;
while (i < 10) {
  System.out.println(i);
  i++;
  if (i == 4) {
    break;
  }
}

Continue Example

int i = 0;
while (i < 10) {
  if (i == 4) {
    i++;
    continue;
  }
  System.out.println(i);
  i++;
}

• To Stop the loop if i is 5.

for (int i = 0; i < 10; i++) {
  if (i == 5) {   
    break;
  }
  System.out.println(i);
}

Java Arrays

An array is a group of identical data items that are referred by a common name.

Arrays are used to store multiple values in a single variable, instead of declaring separate variables for each value.

In Java, array is dynamic in nature. To declare an array, define the variable type with square brackets:

String[] cars;

We have now declared a variable that holds an array of strings. To insert values to it, we can use an array literal — place the values in a comma-separated list, inside curly braces:

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

To create an array of integers:

int[] myNum = {10, 20, 30, 40};

Access the Elements of an Array

You access an array element by referring to the index number. This statement accesses the value of the first element in cars:

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
System.out.println(cars[0]);
// Outputs Volvo

Note: Array indexes start with 0: [0] is the first element. [1] is the second element, etc.

Change an Array Element

To change the value of a specific element, refer to the index number:

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
cars[0] = "Open";
System.out.println(cars[0]);
// Now outputs Open instead of Volvo

Properties of an array:

• Array size is fixed, size can not be increased or decreasd on demand.
• Index always begins at 0 and increments by 1.
• No negative indexing.
• Size must be atleast 1.

2D Arrays:

An array with two subscripts which represents rows nd columns is a 2D array.

Syntax:

datatype arrayname[][];
arrayname = new datatype[rows][columns];

For Example,

int a[][];//Array reference
a = new int[3][4];//Memory Allocation

Applications of 2D Arrays:

1. Matrices
2. Image Processing

Java Conditions and Java Loops, Break Statement, Continue Statement, Java Arrays was originally published in OOPS oriented Java Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.

Java is a programming language introduced by Sun micro systems.

Java is used to develop mobile apps, web apps, desktop apps, games and much more.

What is Java?

Java is a popular programming language, created in 1995.

It is owned by Oracle, and more than 3 billion devices run Java.

Initial name of Java is Oak.

The main success is platform independency is respective operating system, a Java program will be executed without trivial modifications.

It is used for:

• Mobile applications (specially Android apps)
• Desktop applications
• Web applications
• Web servers and application servers
• Games
• Database connection
• And much, much more!

Java Install

Some PCs might have Java already installed.

To check if you have Java installed on a Windows PC, search in the start bar for Java or type the following in Command Prompt (cmd.exe):

C:\Users\Your Name>java -version

If Java is installed, you will see something like this (depending on version):

java version "1.8.0_261"
Java(TM) SE Runtime Environment (build 1.8.0_261-b12)
Java HotSpot(TM) 64-Bit Server VM (build 25.261-b12, mixed mode)

If you do not have Java installed on your computer, you can download it for free at oracle.com.

Setup for Windows

To install Java on Windows:

1. Go to “System Properties” (Can be found on Control Panel > System and Security > System > Advanced System Settings)
2. Click on the “Environment variables” button under the “Advanced” tab
3. Then, select the “Path” variable in System variables and click on the “Edit” button
4. Click on the “New” button and add the path where Java is installed, followed by \bin. By default, Java is installed in C:\Program Files\Java\jdk-11.0.1 (If nothing else was specified when you installed it). In that case, You will have to add a new path with: C:\Program Files\Java\jdk-11.0.1\bin
   Then, click “OK”, and save the settings
5. At last, open Command Prompt (cmd.exe) and type java -version to see if Java is running on your machine

Show how to install Java step-by-step with images »Step 2 »Step 3 »Step 4 »Step 5 »

Structure of Java Program

[Package Section]
<import section>
public class <Classname>{
    public static void main(string[] args){
        Local variable
        //body of main
    }
    [other method definations]
}
[other class definations]

Usage of Java:

In Java, every application begins with a class name, and that class must match the filename.

Let’s create our first Java file, called MyClass.java, which can be done in any text editor (like Notepad).

The file should contain a “Hello World” message, which is written with the following code:

MyClass.java

public class MyClass {
  public static void main(String[] args) {
    System.out.println("Hello World");
  }
}

Save the code in Notepad as “MyClass.java”. Open Command Prompt (cmd.exe), navigate to the directory where you saved your file, and type

C:\Users\Your Name>javac MyClass.java

This will compile your code. If there are no errors in the code, the command prompt will take you to the next line. Now, type “java MyClass” to run the file:

C:\Users\Your Name>java MyClass

The output should read:

Hello World

Java Syntax

Explanation of Myclass.java

Every line of code that runs in Java must be inside a class. In our example, we named the class MyClass. A class should always start with an uppercase first letter.

Note: Java is case-sensitive: “MyClass” and “myclass” has different meaning.

The name of the java file must match the class name. When saving the file, save it using the class name and add “.java” to the end of the filename. To run the example above on your computer, make sure that Java is properly installed.

The main Method

The main() method is required and you will see it in every Java program:

public static void main(String[] args)

Any code inside the main() method will be executed.

System.out.println()

Inside the main() method, we can use the println() method to print a line of text to the screen.

Java Comments

Comments can be used to explain Java code, and to make it more readable. It can also be used to prevent execution when testing alternative code.

Single-line comments start with two forward slashes (//).

Any text between // and the end of the line is ignored by Java (will not be executed).

This example uses a single-line comment before a line of code:

// This is a comment
System.out.println("Hello World");

This example uses a single-line comment at the end of a line of code:

System.out.println("Hello World"); // This is a comment

Java Multi-line Comments

Multi-line comments start with /* and ends with */.

Any text between /* and */ will be ignored by Java.

This example uses a multi-line comment (a comment block) to explain the code:

/* The code below will print the words Hello World
to the screen, and it is amazing */
System.out.println("Hello World");

Java 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

Declaring (Creating) Variables

To create a variable, you must specify the type and assign it a value:

Where type is one of Java’s types (such as int or String), and variable is the name of the variable (such as x or name). The equal sign is used to assign values to the variable.

To create a variable that should store text, look at the following example:

//Create a variable called name of type String and assign it the //value "John":

String name = "John";
System.out.println(name);

//To create a variable that should store a number

int myNum = 15;
System.out.println(myNum);

//Change the value of myNum from 15 to 20:
int myNum = 15;

myNum = 20;  // myNum is now 20
System.out.println(myNum);

Final Variables

However, you can add the final keyword if you don't want others (or yourself) to overwrite existing values (this will declare the variable as "final" or "constant", which means unchangeable and read-only):

final int myNum = 15;
myNum = 20;//Generates an error: cannot assign a value to a final variable

Display Variables

The println() method is often used to display variables.

To combine both text and a variable, use the + character:

String name = "John";
System.out.println("Hello " + name);
//can also use the + character to add a variable to another //variable:
String firstName = "John ";
String lastName = "Doe";
String fullName = firstName + lastName;
System.out.println(fullName);

//For numeric values, the + character works as a mathematical operator
int x = 5;
int y = 6;
System.out.println(x + y); // Print the value of x + y

Java Identifiers

All Java variables must be identified with unique names.

These unique names are called identifiers.

Identifiers can be short names (like x and y) or more descriptive names (age, sum, totalVolume).

// Good
int minutesPerHour = 60;

// OK, but not so easy to understand what m actually is
int m = 60;

The general rules for constructing names for variables (unique identifiers) are:

• Names can contain letters, digits, underscores, and dollar signs
• Names must begin with a letter
• Names should start with a lowercase letter and it cannot contain whitespace
• Names can also begin with $ and _ (but we will not use it in this tutorial)
• Names are case sensitive (“myVar” and “myvar” are different variables)
• Reserved words (like Java keywords, such as int or boolean) cannot be used as names

Java Data Types

As already discussed, we need to define a variable using data type.

int myNum = 5;               // Integer (whole number)
float myFloatNum = 5.99f;    // Floating point number
char myLetter = 'D';         // Character
boolean myBool = true;       // Boolean
String myText = "Hello";     // String

Data types are divided into two groups:

• Primitive data types — includes byte, short, int, long, float, double, boolean and char
• Non-primitive data types — such as strings,arrays,classes.

Java Type Casting

Type cating can be both

• Automatic
• Manual

Automatically can be done as shown below,

public class MyClass {
  public static void main(String[] args) {
    int myInt = 9;
    double myDouble = myInt; // Automatic casting: int to double

    System.out.println(myInt);      // Outputs 9
    System.out.println(myDouble);   // Outputs 9.0
  }
}

Manually is done as shown below,

public class MyClass {
  public static void main(String[] args) {
    double myDouble = 9.78;
    int myInt = (int) myDouble; // Manual casting: double to int

System.out.println(myDouble);   // Outputs 9.78
    System.out.println(myInt);      // Outputs 9
  }
}

Java Buzzwords

1. Simple and Secured.
2. Robust is about regarding errors.
3. Architecture is neutral.
4. Strongly typed.
5. Interpreted — There is no executable file for java. Java consists both compiler and interpreter.
6. Dynamic
7. Average Multithreaded — Belongs to OS.
8. Object Oriented
9. High Performance
10. Distributed.

Java Operators

Operators are used to perform operations on variables and values. Java divides the operators into the following groups:

• Arithmetic operators
• Assignment operators
• Comparison operators
• Logical operators
• Bitwise operators

Arithmetic operators:

Assignment Operators:

Comparison Operators:

Logical Operators:

Bitwise Operators:

Java Strings

Strings are used for storing text. A string variable contains a collection of characters surrounded by double quotes:

Create a variable of type String and assign it a value:

String greeting = "Hello";

String Length

A String in Java is actually an object, which contain methods that can perform certain operations on strings. For example, the length of a string can be found with the length() method:

String txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
System.out.println("The length of the txt string is: " + txt.length());

String Methods

There are many string methods available, for example toUpperCase() and toLowerCase():

String txt = "Hello World";
System.out.println(txt.toUpperCase());   // Outputs "HELLO WORLD"
System.out.println(txt.toLowerCase());   // Outputs "hello world"

Finding a Character in a String

The indexOf() method returns the index (the position) of the first occurrence of a specified text in a string (including whitespace):

String txt = "Please locate where 'locate' occurs!";
System.out.println(txt.indexOf("locate")); // Outputs 7

Java counts positions from zero.
0 is the first position in a string, 1 is the second, 2 is the third …

String Concatenation

The + operator can be used between strings to combine them. This is called concatenation:

String firstName = "John";
String lastName = "Doe";
System.out.println(firstName + " " + lastName);

Note that we have added an empty text (“ “) to create a space between firstName and lastName on print. You can also use the concat() method to concatenate two strings:

String firstName = "John ";
String lastName = "Doe";
System.out.println(firstName.concat(lastName));

Special Characters

Because strings must be written within quotes, Java will misunderstand this string, and generate an error:

String txt = "We are the so-called "Vikings" from the north.";

The solution to avoid this problem, is to use the backslash escape character.

The backslash (\) escape character turns special characters into string characters:

The sequence \" inserts a double quote in a string:

String txt = "We are the so-called \"Vikings\" from the north.";

The sequence \' inserts a single quote in a string:

String txt = "It\'s alright.";

The sequence \\ inserts a single backslash in a string:

String txt = "The character \\ is called backslash.";

Adding Numbers and Strings

WARNING!

Java uses the + operator for both addition and concatenation.

Numbers are added. Strings are concatenated.

If you add two numbers, the result will be a number:

int x = 10;
int y = 20;
int z = x + y;      // z will be 30 (an integer/number)

If you add two strings, the result will be a string concatenation:

String x = "10";
String y = "20";
String z = x + y;   // z will be 1020 (a String)

If you add a number and a string, the result will be a string concatenation:

String x = "10";
int y = 20;
String z = x + y;   // z will be 1020 (a String)

Java was originally published in OOPS oriented Java Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.