Java Stories

2019-10-31T23:01:00.000-07:00

Nested if statement in Java

When there is an if statement inside another if statement then it is called the nested if statement.
The structure of nested if looks like this:

if(condition_1){

statement 1(s);

if(condition_2){

statement 2(s);

}

Statement1 would execute if the condition_1 is true. Statement2 would only execute if both the conditions( condition_1 and condition_2) are true.

Example of Nested if statement:

public class NestedIfExample{

public static void main(String args[]){

if(num<100){

system.out.println("number is less than 100");

if(num>50){

system.out.println("number is greater than 50");

}

Output:

number is less than 100

number is greater than 50

If else statement in Java

This is how an if-else statement looks:

if(condition){

statement(s);

}

else {

statement(s);

}

The statements inside “if” would execute if the condition is true, and the statements inside “else” would execute if the condition is false.

Example of if-else statement:

public class IfElseExample {

public static void main(string args[]){

int num =120;

if(num<50){

system.out,println("number is less than 50");

}

else {

system.out.println("number is greater than equal 50");

}

Output:

number is greater than or equal 50.

if-else-if Statement

if-else-if statement is used when we need to check multiple conditions. In this statement we have only one “if” and one “else”, however we can have multiple “else if”. It is also known as if else if ladder. This is how it looks:

if(condition_1){
/*if Condition_1 is true execute this

statement(s);

}

else if(condition_2){

/*execute this if condition _1 is not met and

/*Condition_2 is met.

statement(s);

}//

else {

/*if none of the condition is true

/*then these statements gets executed.

statement(s);

}

Note: The most important point to note here is that in if-else-if statement, as soon as the condition is met, the corresponding set of statements get executed, rest gets ignored. If none of the condition is met then the statements inside “else” gets executed.

Example of if-else-if

public class IfElseExample{

public static void main(string args[]){

int num =1234;

if(num<100&& num>=1){

system.out.println("Its a two digit number");

}

else if(num<1000&& num>=100){

system.out.println("Its a three digit number");

}

else if(num<10000&& num>=1000){

system.out.println("Its a four digit number");

}

else {

system.out.println("number is not between 1 to 99999");

}

Output:

Its a four digits number

2019-10-31T21:38:00.001-07:00

If, If..else Statement in Java with Examples

When we need to execute a set of statements based on a condition then we need to use control flow statements. For example, if a number is greater than zero then we want to print “Positive Number” but if it is less than zero then we want to print “Negative Number”. In this case we have two print statements in the program, but only one print statement executes at a time based on the input value. We will see how to write such type of conditions in the java program using control statements.

In this tutorial, we will see four types of control statements that you can use in java programs based on the requirement: In this tutorial we will cover following conditional statements:

a) if statement
b) nested if statement
c) if-else statement
d) if-else-if statement

If statement

If statement consists a condition, followed by statement or a set of statements as shown below:

if(condition){

statement(s);

}

The statements gets executed only when the given condition is true. If the condition is false then the statements inside if statement body are completely ignored.

Example of if statement

public class IfStatementExample

{

public static void main(string args[])

{

int num=70;

if(num<100)

{

/* This println Statement will only execute.

/*If the above condition is true.

}

Output: Number is less than 100.

2019-10-31T13:26:00.006-07:00

Abstract Classes

An abstract class is a class that is incomplete, in that it describes a set of operations, but is missing the actual implementation of these operations. Abstract classes:

Cannot be instantiated.
So, can only be used through inheritance.

For example: In the Vehicle class example previously the draw() method may be defined as abstract as it is not really possible to draw a generic vehicle. By doing this we are forcing all derived classes to write a draw() method if they are to be instantiated.

As discussed previously, a class is like a set of plans from which you can create objects. In relation to this analogy, an abstract class is like a set of plans with some part of the plans missing. E.g. it could be a car with no engine - you would not be able to make complete car objects without the missing parts of the plan.

Figure 1.11. The abstract draw() method in the Vehicle class.

Figure 1.11 illustrates this example. The draw() has been written in all of the classes and has some functionality. The draw() in the Vehicle has been tagged as abstract and so this class cannot be instantiated - i.e. we cannot create an object of the Vehicle class, as it is incomplete. In Figure 1.11 the SaloonCar has no draw() method, but it does inherit a draw() method from the parent Car class. Therefore, it is possible to create objects of SaloonCar.

If we required we could also tag the draw() method as abstract in a derived class, for example we could also have tagged the draw() as abstract in the Car class. This would mean that you could not create an object of the Car class and would pass on responsibility for implementing the draw() method to its children - see Figure 1.12.

Figure 1.12. The abstract draw() method in the Vehicle and Car classes.

Abstract class in Java Important Points

Abstract keyword is used to create an abstract class in java.
Abstract class in java can’t be instantiated.
We can use Abstract keyword to create an abstract method, an abstract method doesn’t have body.
If a class have abstract methods, then the class should also be abstract using abstract keyword, else it will not compile.
It’s not necessary for an abstract class to have abstract method. We can mark a class as abstract even if it doesn’t declare any abstract methods.
If abstract class doesn’t have any method implementation, its better to use interface because java doesn’t support multiple class inheritance.
The subclass of abstract class in java must implement all the abstract methods unless the subclass is also an abstract class.
All the methods in an interface are implicitly abstract unless the interface methods are static or default. Static methods and default methods in interfaces are added in Java 8, for more details read Java 8 interface changes.
Java Abstract class can implement interfaces without even providing the implementation of interface methods.
Java Abstract class is used to provide common method implementation to all the subclasses or to provide default implementation.
We can run abstract class in java like any other class if it has main() method.

That’s all for an abstract class in Java. If I missed anything important, please let us know through comments.

Example of abstract:

// An abstract class with constructor

abstract class Base {

Base() { System.out.println("Base Constructor Called"); }

abstract void fun();

}

class Derived extends Base {

Derived() { System.out.println("Derived Constructor Called"); }

void fun() { System.out.println("Derived fun() called"); }

}

class Main {

public static void main(String args[]) {

Derived d = new Derived();

}

Output : Base Constructor called

Derived Constructor called

2019-10-31T11:44:00.001-07:00

Polymorphism in Java

Polymorphism in Java is a concept by which we can perform a single action in different ways. Polymorphism is derived from 2 Greek words: poly and morphs. The word "poly" means many and "morphs" means forms. So polymorphism means many forms.
There are two types of polymorphism in Java: compile-time polymorphism and runtime polymorphism. We can perform polymorphism in java by method overloading and method overriding.
If you overload a static method in Java, it is the example of compile time polymorphism. Here, we will focus on runtime polymorphism in java.

Runtime Polymorphism in Java

Runtime polymorphism or Dynamic Method Dispatch is a process in which a call to an overridden method is resolved at runtime rather than compile-time.
In this process, an overridden method is called through the reference variable of a superclass. The determination of the method to be called is based on the object being referred to by the reference variable.

Example of Java Runtime Polymorphism

In this example, we are creating two classes Bike and Splendor. Splendor class extends Bike class and overrides its run() method. We are calling the run method by the reference variable of Parent class. Since it refers to the subclass object and subclass method overrides the Parent class method, the subclass method is invoked at runtime.
Since method invocation is determined by the JVM not compiler, it is known as runtime polymorphism.

class Bike {

void run()system.out.println("running");}
}
class Hayabusha extends Bike {
void run()
{
system.out.println("running safely with 60km");
}
public static void main(string args[])
{
Bike b = new Hayabusha();
b.run();
}
}

Output : running safely with 60km

2019-10-31T10:33:00.000-07:00

Object Oriented Programming in JAVA

Object-Oriented Programming (OOP) is the term used to describe a programming approach based on objects and classes. The object-oriented example allows us to organised software as a collection of objects that consist of both data and behaviour. This is in contrast to conventional functional programming practice that only loosely connects data and behaviour.

Since the 1980's the word 'object' has appeared in relation to programming languages, with almost all languages developed since 1990 having object-oriented features. Some languages have even had object-oriented features retro-fitted. It is widely accepted that object-oriented programming is the most important and powerful way of creating software.

Notes :

Modularisation : where the application can be decomposed into modules.
Software re-use: where an application can be composed from existing and new modules.

An object-oriented programming language generally supports five main features:

Classes

Objects

Classification

Polymorphism

Inheritance

An Object-Oriented Class

If we think of a real-world object, such as a television as in figure 1.1 , it will have several features and properties:

We do not have to open the case to use it.
We have some controls to use it (buttons on the box, or a remote control).
We can still understand the concept of a television, even if it is connected to a DVD player.
It is complete when we purchase it, with any external requirements well documented.
The TV will not crash!

Television Figure 1.1

A class should:

Provide a well-defined interface - such as the remote control of the television.
Represent a clear concept - such as the concept of a television.
Be complete and well-documented - the television should have a plug and should have a manual that documents all features.
The code should be robust - it should not crash, like the television.

With a functional programming language (like C) we would have the component parts of the television scattered everywhere and we would be responsible for making them work correctly - there would be no case surrounding the electronic components.

Humans use class based descriptions all the time - what is a duck? (Think about this, we will discuss it soon.)

Classes allow us a way to represent complex structures within a programming language. They have two components:

States - (or data) are the values that the object has.
Methods - (or behaviour) are the ways in which the object can interact with its data, the actions.

An Object

An object is an instance of a class. You could think of a class as the description of a concept, and an object as the realisation of this description to create an independent distinguishable entity. For example, in the case of the Television, the class is the set of plans (or blueprints) for a generic television, whereas a television object is the realisation of these plans into a real-world physical television. So there would be one set of plans (the class), but there could be thousands of real-world televisions (objects).

class example showing encapsulation.

Objects can be concrete (a real-world object, a file on a computer) or could be conceptual (such as a database structure) each with its own individual identity.Figure 1.2 shows an example where the Television class description is realised into several television objects. These objects should have their own identity and are independent from each other. For example, if the channel is changed on one television it will not change on the other televisions.

Figure 1.2

Encapsulation:

The object-oriented paradigm encourages encapsulation. Encapsulation is used to hide the mechanics of the object, allowing the actual implementation of the object to be hidden, so that we don't need to understand how the object works. All we need to understand is the interface that is provided for us.

You can think of this in the case of the Television class, where the functionality of the television is hidden from us, but we are provided with a remote control, or set of controls for interacting with the television, providing a high level of abstraction. So, as in Figure 1.3 there is no requirement to understand how the signal is decoded from the aerial and converted into a picture to be displayed on the screen before you can use the television.

There is a sub-set of functionality that the user is allowed to call, termed the interface. In the case of the television, this would be the functionality that we could use through the remote control or buttons on the front of the television.

The full implemenation of a class is the sum of the public interface plus the private implementation.

Figure 1.3. The Television interface example.

Encapsulation is the term used to describe the way that the interface is separated from the implementation. You can think of encapsulation as "data-hiding", allowing certain parts of an object to be visible, while other parts remain hidden. This has advantages for both the user and the programmer.

For the user (who could be another programmer):

The user need only understand the interface.
The user need not understand how the implementation works or was created.

For the programmer:

The programmer can change the implementation, but need not notify the user.

So, providing the programmer does not change the interface in any way, the user will be unaware of any changes, except maybe a minor change in the actual functionality of the application.

We can identify a level of 'hiding' of particular methods or states within a class using the public, private and protected keywords:

public methods - describe the interface.
private methods - describe the implementation.

Figure 1.4 shows encapsulation as it relates to the Television class. According to UML notation private methods are denoted with a minus sign and public methods are denoted with a plus sign. The private methods would be methods written that are part of the inner workings of the television, but need not be understood by the user. For example, the user would need to call the powerOn() method but the private displayPicture() method would also be called, but internally as required, not directly by the user. This method is therefore not added to the interface, but hidden internally in the implementation by using the private keyword.

Television class example showing encapsulation.

Figure 1.4

Inheritance

If we have several descriptions with some commonality between these descriptions, we can group the descriptions and their commonality using inheritance to provide a compact representation of these descriptions. The object-oriented programming approach allows us to group the commonalities and create classes that can describe their differences from other classes.

Humans use this concept in categorised objects and descriptions. For example you may have answered the question - "What is a duck?", with "a bird that swims", or even more accurately, "a bird that swims, with webbed feet, and a bill instead of a beak". So we could say that a Duck is a Bird that swims, so we could describe this as in Figure 1.5. This figure illustrates the inheritance relationship between a Duck and a Bird. In effect we can say that a Duck is a special type of Bird.

Figure 1.5. The Duck class showing inheritance.

For example: if were to be given an unstructured group of descriptions such as Car, Saloon, Estate, Van, Vehicle, Motorbike and Scooter, and asked to organise these descriptions by their differences. You might say that a Saloon car is a Car but has a long boot, whereas an Estate car is a car with a very large boot. Figure 1.6 shows an example of how we may organise these descriptions using inheritance.

Figure 1.6. The grouped set of classes.

So we can describe this relationship as a child/parent relationship, where Figure 1.7 illustrates the relationship between a base class and a derived class. A derived class inherits from a base class, so in Figure 1.6 the Car class is a child of the Vehicle class, so Car inherits from Vehicle.

Figure 1.7. The Base class and Derived class.

One way to determine that you have organised your classes correctly is to check them using the "IS-A" and "IS-A-PART-OF" relationship checks. It is easy to confuse objects within a class and children of classes when you first begin programming with an OOP methodology. So, to check the previous relationship between Car and Vehicle, we can see this in Figure 1.8.

Figure 1.8. The IS-A/IS-A-PART-OF relationships and the Vehicle class.

The IS-A relationship describes the inheritance in the figure, where we can say, "A Car IS-A Vehicle" and "A SaloonCar IS-A Car", so all relationships are correct. The IS-A-PART-OF relationship describes the composition (or aggregation) of a class. So in the same figure (Figure 1.9) we can say "An Engine IS-A-PART-OF a Vehicle", or "An Engine, Colour and Wheels IS-A-PART-OF a Vehicle". This is the case even though an Engine is also a class! where there could be many different descriptions of an Engine - petrol, diesel, 1.4, 2.0, 16 valve etc.

So, using inheritance the programmer can:

Inherit a behaviour and add further specialised behaviour - for example a Car IS A Vehicle with the addition of four Wheel objects, Seats etc.
Inherit a behaviour and replace it - for example the SaloonCar class will inherit from Car and provide a new "boot" implementation.
Cut down on the amount of code that needs to be written and debugged - for example in this case only the differences are detailed, a SaloonCar is essentially identical to the Car, with only the differences requiring description.

2019-10-31T09:12:00.007-07:00

Data Types in Java

Data types specify the different sizes and values that can be stored in the variable. There are two types of data types in Java:
Primitive data types: The primitive data types include boolean, char, byte, short, int, long, float and double.
Non-primitive data types: The non-primitive data types include Classes, Interfaces, and Arrays.

Java Primitive Data Types

In Java language, primitive data types are the building blocks of data manipulation. These are the most basic data types available in Java language.

Java is a statically-typed programming language . It means,all variable must be declared before its use. That is why we need to declare variables type and name

There are 8 types of primitive data types:
Boolean data type
byte data type
char data type
short data type
int data type
long data type
float data type
double data type
Data Type Default Value Default size
boolean false 1 bit
char '\u0000' 2 byte
byte 0 1 byte
short 0 2 byte
int 0 4 byte
long 0L 8 byte
float 0.0f 4 byte
double 0.0d 8 byte

Data Type	Default Value	Default size
boolean	false	1 bit
char	'\u0000'	2 byte
byte	0	1 byte
short	0	2 byte
int	0	4 byte
long	0L	8 byte
float	0.0f	4 byte
double	0.0d	8 byte

1.Boolean Data Type

The Boolean data type is used to store only two possible values: true and false. This data type is used for simple flags that track true/false conditions.
The Boolean data type specifies one bit of information, but its "size" can't be defined precisely.
Example: Boolean one = false

2.Byte Data Type

The byte data type is an example of primitive data type. It is an 8-bit signed two's complement integer. Its value-range lies between -128 to 127 (inclusive). Its minimum value is -128 and maximum value is 127. Its default value is 0.
The byte data type is used to save memory in large arrays where the memory savings is most required. It saves space because a byte is 4 times smaller than an integer. It can also be used in place of "int" data type.
Example: byte a = 10, byte b = -20

3.Short Data Type

The short data type is a 16-bit signed two's complement integer. Its value-range lies between -32,768 to 32,767 (inclusive). Its minimum value is -32,768 and maximum value is 32,767. Its default value is 0.
The short data type can also be used to save memory just like byte data type. A short data type is 2 times smaller than an integer.
Example: short s = 10000, short r = -5000

4.Int Data Type

The int data type is a 32-bit signed two's complement integer. Its value-range lies between - 2,147,483,648 (-2^31) to 2,147,483,647 (2^31 -1) (inclusive). Its minimum value is - 2,147,483,648 and maximum value is 2,147,483,647. Its default value is 0.
The int data type is generally used as a default data type for integral values unless if there is no problem about memory.
Example: int a = 100000, int b = -200000

5.Long Data Type

The long data type is a 64-bit two's complement integer. Its value-range lies between -9,223,372.
Example: long a = 100000L, long b = -200000L

6.Float Data Type

The float data type is a single-precision 32-bit IEEE 754 floating point.Its value range is unlimited. It is recommended to use a float (instead of double) if you need to save memory in large arrays of floating point numbers. The float data type should never be used for precise values, such as currency. Its default value is 0.0F.
Example: float f1 = 234.5f

7.Double Data Type

The double data type is a double-precision 64-bit IEEE 754 floating point. Its value range is unlimited. The double data type is generally used for decimal values just like float. The double data type also should never be used for precise values, such as currency. Its default value is 0.0d.
Example: double d1 = 12.3

8.Char Data Type

The char data type is a single 16-bit Unicode character. Its value-range lies between '\u0000' (or 0) to '\uffff' (or 65,535 inclusive).The char data type is used to store characters.
Example: char letterA = 'A'.

2019-10-31T02:51:00.002-07:00

Java programming with Hello World Example.

The process of Java programming can be simplified in three steps:

Create the program by typing it into a text editor and saving it to a file – HelloWorld.java.
Compile it by typing “javac HelloWorld.java” in the terminal window.
Execute (or run) it by typing “java HelloWorld” in the terminal window.

Below given program is the simplest program of Java printing “Hello World” to the screen. Let us try to understand every bit of code step by step.

/*This is a Simple Java Program.

FileName:"HelloWorld.java".*/

Class HelloWorld

{

// Your program starts with a call main()

// Print "Hello,World" to the terminal Window.

public static void main (string args[])

{

system.out.println("Hello,World);

}

Output : Hello, World

"The “Hello World!” program consists of three primary components: the HelloWorld class definition, the main method and source code comments. Following explanation will provide you with a basic understanding of the code:".

1. Class definition:This line uses the keyword class to declare that a new class is being defined.

class HelloWorld

HelloWorld is an identifier that is the name of the class. The entire class definition, including all of its members, will be between the opening curly brace { and the closing curly brace } .

2. main method: In Java programming language, every application must contain a main method whose signature is:

public static void main(string[] args) :-

public : So that JVM can execute the method from anywhere.

static : Main method is to be called without object.

The modifiers public and static can be written in either order.

void : The main method doesn't return anything.

main() : Name configured in the JVM.

String[] : The main method accepts a single argument ( an array of elements of type string)

Like in C/C++, main method is the entry point for your application and will subsequently invoke all the other methods required by your program.

3. The next line of code is shown here. Notice that it occurs inside main()

system.out.println("Hello,World");

This line outputs the string “Hello, World” followed by a new line on the screen. Output is actually accomplished by the built-in println( ) method. System is a predefined class that provides access to the system, and out is the variable of type output stream that is connected to the console.

# Points :

The name of the class defined by the program is HelloWorld, which is same as name of file(HelloWorld.java). This is not a coincidence. In Java, all codes must reside inside a class and there is at most one public class which contain main() method.
By convention, the name of the main class(class which contain main method) should match the name of the file that holds the program.

Compiling the program :

After successfully setting up the environment, we can open terminal in both Windows/Unix and can go to directory where the file – HelloWorld.java is present.
Now, to compile the HelloWorld program, execute the compiler – javac , specifying the name of the source file on the command line, as shown.

javac HelloWorld.java

The compiler creates a file called HelloWorld.class (in present working directory) that contains the bytecode version of the program. Now, to execute our program, JVM(Java Virtual Machine) needs to be called using java, specifying the name of the class file on the command line, as shown.

java HelloWorld

This will print “Hello World” to the terminal screen.

Basics

2019-10-31T02:24:00.001-07:00

Java Programming Basics

Java is one of the most popular and widely used programming language and platform. A platform is an environment that helps to develop and run programs written in any programming language.
Java is fast, reliable and secure. From desktop to web applications, scientific supercomputers to gaming consoles, cell phones to the Internet, Java is used in every nook.

How to become experienced in Java programming language, you needs to understand the basics of language.

Java Environment : The programming environment of Java consists of three components mainly:
- JDK : (Java Development Kit)
- JRE : (Java Run time Environment)
- JVM : (Java Virtual Machine)
Java Basic Syntax : Every programming language has its own set of rules to declare, define and work on its components. Reading and learning about all of them together is difficult. Therefore here is a simple task of printing "HELLO WORLD" in java. During this process, major components and their syntax are explained clearly.
Comments in Java : In a program, comments take part in making the program become more human-readable by placing the detail of code involved and proper use of comments makes maintenance easier and finding bugs easily. Comments are ignored by the compiler while compiling the code.
Data Types in Java : Each variable in Java has an associated data type. Each data type requires different amounts of memory and has some specific operations which can be performed over it.
Variables in Java: A variable is the name given to a memory location. It is the basic unit of storage in a program.
Keywords in Java : Keywords or Reserved words are the words in a language that are used for some internal process or represent some predefined actions. These words are therefore not allowed to use as variable names or objects. Doing this will result in a compile-time error.
Operators in Java : Operators are the foundation of any programming language. Thus the functionality of Java programming language is incomplete without the use of operators. We can define operators as symbols that help us to perform specific mathematical and logical computations on operands. In other words, we can say that an operator operates the operands.
Decision Making (Control Statement) in Java : Decision Making in programming is similar to decision making in real life. In programming also we face some situations where we want a certain block of code to be executed when some condition is fulfilled.
A programming language uses control statements to control the flow of execution of the program based on certain conditions. These are used to cause the flow of execution to advance and branch based on changes to the state of a program.
Loops in Java: Looping in programming languages is a feature which facilitates the execution of a set of instructions/functions repeatedly while some condition evaluates to true.
Java provides three ways for executing the loops. While all the ways provide similar basic functionality, they differ in their syntax and condition checking time.

Java Stories

Nested if statement in Java

Example of Nested if statement:

Output:

If else statement in Java

Example of if-else statement:

Example of if-else-if

If statement

Example of if statement

Abstract Classes

Abstract class in Java Important Points

Example of abstract:

Polymorphism in Java

Runtime Polymorphism in Java

Example of Java Runtime Polymorphism

Object Oriented Programming in JAVA

Inheritance

An Object-Oriented Class

An Object

Encapsulation:

Inheritance

Data Types in Java

Java Primitive Data Types

1.Boolean Data Type

The Boolean data type is used to store only two possible values: true and false. This data type is used for simple flags that track true/false conditions.The Boolean data type specifies one bit of information, but its "size" can't be defined precisely.Example: Boolean one = false

2.Byte Data Type

3.Short Data Type

4.Int Data Type

5.Long Data Type

The long data type is a 64-bit two's complement integer. Its value-range lies between -9,223,372.Example: long a = 100000L, long b = -200000L

6.Float Data Type

7.Double Data Type

8.Char Data Type

The char data type is a single 16-bit Unicode character. Its value-range lies between '\u0000' (or 0) to '\uffff' (or 65,535 inclusive).The char data type is used to store characters.Example: char letterA = 'A'.

Java programming with Hello World Example.

Basics

Java Programming Basics

The Boolean data type is used to store only two possible values: true and false. This data type is used for simple flags that track true/false conditions.
The Boolean data type specifies one bit of information, but its "size" can't be defined precisely.
Example: Boolean one = false

The long data type is a 64-bit two's complement integer. Its value-range lies between -9,223,372.
Example: long a = 100000L, long b = -200000L

The char data type is a single 16-bit Unicode character. Its value-range lies between '\u0000' (or 0) to '\uffff' (or 65,535 inclusive).The char data type is used to store characters.
Example: char letterA = 'A'.