UNIT 2

Structuring the Data, Computations and Program

2.1 Elementary Data Types

2.1.1 Primitive data Types

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

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 variables must be declared before its use. That is why we need to declare variable's type and name.

There are 8 types of primitive data types:

Fig 1 – Data type

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

Byte Data Type

The byte data type is an example of primitive data type. It isan 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

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

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,648and 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

Long Data Type

The long data type is a 64-bit two's complement integer. Its value-range lies between -9,223,372,036,854,775,808(-2^63) to 9,223,372,036,854,775,807(2^63 -1) (inclusive). Its minimum value is - 9,223,372,036,854,775,808and maximum value is 9,223,372,036,854,775,807. Its default value is 0. The long data type is used when you need a range of values more than those provided by int.

Example: long a = 100000L, long b = -200000L

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

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

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'

Key takeaway

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

2.1.2 Character String types

In Java, string is basically an object that represents sequence of char values. An array of characters works same as Java string. For example:

is same as:

Java String class provides a lot of methods to perform operations on strings such as compare(), concat(), equals(), split(), length(), replace(), compareTo(), intern(), substring() etc.

The java.lang.String class implements Serializable, Comparable and CharSequence interfaces.

Fig 2 - String

CharSequence Interface

The CharSequence interface is used to represent the sequence of characters. String, StringBuffer and StringBuilder classes implement it. It means, we can create strings in java by using these three classes.

Fig 3 - CharSequence

The Java String is immutable which means it cannot be changed. Whenever we change any string, a new instance is created. For mutable strings, you can use StringBuffer and StringBuilder classes.

We will discuss immutable string later. Let's first understand what is String in Java and how to create the String object.

What is String in java

Generally, String is a sequence of characters. But in Java, string is an object that represents a sequence of characters. The java.lang.String class is used to create a string object.

How to create a string object?

There are two ways to create String object:

1) String Literal

Java String literal is created by using double quotes. For Example:

Each time you create a string literal, the JVM checks the "string constant pool" first. If the string already exists in the pool, a reference to the pooled instance is returned. If the string doesn't exist in the pool, a new string instance is created and placed in the pool. For example:

Fig 4 - Example

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

Why Java uses the concept of String literal?

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

2) By new keyword

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

Java String Example

Java String class methods

The java.lang.String class provides many useful methods to perform operations on sequence of char values.

Key takeaway

In Java, string is basically an object that represents sequence of char values. An array of characters works same as Java string. For example:

3.     char[] ch={'j','a','v','a','t','p','o','i','n','t'};  

4.     String s=new String(ch);  

is same as:

2.     String s="javatpoint";  

Java String class provides a lot of methods to perform operations on strings such as compare(), concat(), equals(), split(), length(), replace(), compareTo(), intern(), substring() etc.

2.1.3 User Defined Ordinal Types

 User-Defined Ordinal Types

An ordinal type is one in which the range of possible values can be easily associated with a set of positive        integers. In pascal the built-in ordinal types are integers, char, boolean. User can define two types of ordinal types: enumeration and subrange.

       a) Enumeration types

       An enumeration type is one in which the user enumerates all of the possible values, which are symbolic        constants. In Ada a typical enumeration type is shown as: type DAYS is (M, T, W, R, F, Sa, S);

       b) Subrange types

       A subrange type is an ordered contiguous subsequence of an ordinal type. These types were introduced        by Pascal. For example: 12 . . . 16 is a subrange of the integer type.

Key takeaway

 User-Defined Ordinal Types

An ordinal type is one in which the range of possible values can be easily associated with a set of positive        integers. In pascal the builtin ordinal types are inetgers, char, boolean. User can define two types of ordinal types: enumeration and subrange.

2.1.4 Array types, Associative Arrays

Normally, an array is a collection of similar type of elements which has contiguous memory location.

Java array is an object which contains elements of a similar data type. Additionally, the elements of an array are stored in a contiguous memory location. It is a data structure where we store similar elements. We can store only a fixed set of elements in a Java array.

Array in Java is index-based, the first element of the array is stored at the 0th index, 2nd element is stored on 1st index and so on.

Unlike C/C++, we can get the length of the array using the length member. In C/C++, we need to use the sizeof operator.

In Java, array is an object of a dynamically generated class. Java array inherits the Object class, and implements the Serializable as well as Cloneable interfaces. We can store primitive values or objects in an array in Java. Like C/C++, we can also create single dimensional or multidimensional arrays in Java.

Moreover, Java provides the feature of anonymous arrays which is not available in C/C++.

Fig 5 – Example

Advantages

Disadvantages

Types of Array in java

There are two types of array.

Single Dimensional Array in Java

Syntax to Declare an Array in Java

Instantiation of an Array in Java

Example of Java Array

Let's see the simple example of java array, where we are going to declare, instantiate, initialize and traverse an array.

Output:

10

20

70

40

50

Declaration, Instantiation and Initialization of Java Array

We can declare, instantiate and initialize the java array together by:

Let's see the simple example to print this array.

Output:

33

3

4

5

For-each Loop for Java Array

We can also print the Java array using for-each loop. The Java for-each loop prints the array elements one by one. It holds an array element in a variable, then executes the body of the loop.

The syntax of the for-each loop is given below:

Let us see the example of print the elements of Java array using the for-each loop.

Output:

33

3

4

5

Passing Array to a Method in Java

We can pass the java array to method so that we can reuse the same logic on any array.

Let's see the simple example to get the minimum number of an array using a method.

Output:

3

Anonymous Array in Java

Java supports the feature of an anonymous array, so you don't need to declare the array while passing an array to the method.

Output:

10

22

44

66

Returning Array from the Method

We can also return an array from the method in Java.

Output:

10

30

50

90

60

ArrayIndexOutOfBoundsException

The Java Virtual Machine (JVM) throws an ArrayIndexOutOfBoundsException if length of the array in negative, equal to the array size or greater than the array size while traversing the array.

Output:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4

 at TestArrayException.main(TestArrayException.java:5)

50

60

70

80

Multidimensional Array in Java

In such case, data is stored in row and column based index (also known as matrix form).

Syntax to Declare Multidimensional Array in Java

Example to instantiate Multidimensional Array in Java

Example to initialize Multidimensional Array in Java

Example of Multidimensional Java Array

Let's see the simple example to declare, instantiate, initialize and print the 2Dimensional array.

Output:

1 2 3

2 4 5

4 4 5

Jagged Array in Java

If we are creating odd number of columns in a 2D array, it is known as a jagged array. In other words, it is an array of arrays with different number of columns.

Output:

0 1 2

3 4 5 6

7 8

What is the class name of Java array?

In Java, an array is an object. For array object, a proxy class is created whose name can be obtained by getClass (). getName () method on the object.

Output: I

Copying a Java Array

We can copy an array to another by the arraycopy() method of System class.

Syntax of arraycopy method

Example of Copying an Array in Java

Output:

caffein

Cloning an Array in Java

Since, Java array implements the Cloneable interface, we can create the clone of the Java array. If we create the clone of a single-dimensional array, it creates the deep copy of the Java array. It means, it will copy the actual value. But, if we create the clone of a multidimensional array, it creates the shallow copy of the Java array which means it copies the references.

Output:

Printing original array:

33

3

4

5

Printing clone of the array:

33

3

4

5

Are both equal?

false

Addition of 2 Matrices in Java

Let's see a simple example that adds two matrices.

Output:

2 6 8

6 8 10

Multiplication of 2 Matrices in Java

In the case of matrix multiplication, a one-row element of the first matrix is multiplied by all the columns of the second matrix which can be understood by the image given below.

Fig 6 – Matrix example

Let's see a simple example to multiply two matrices of 3 rows and 3 columns.

Output:

6 6 6

12 12 12

18 18 18

Associative Arrays

Associative arrays are used to represent collections of data elements that can be retrieved by specifying a name called a key. D associative array keys are formed by a list of scalar expression values called a tuple. You can think of the array tuple itself as an imaginary parameter list to a function that is called to retrieve the corresponding array value when you reference the array. Each D associative array has a fixed key signature consisting of a fixed number of tuple elements where each element has a given, fixed type. You can define different key signatures for each array in your D program.

Associative arrays differ from normal, fixed-size arrays in that they have no predefined limit on the number of elements, the elements can be indexed by any tuple as opposed to just using integers as keys, and the elements are not stored in preallocated consecutive storage locations. Associative arrays are useful in situations where you would use a hash table or other simple dictionary data structure in a C, C++, or JavaTM language program. Associative arrays give you the ability to create a dynamic history of events and state captured in your D program that you can use to create more complex control flows.

To define an associative array, you write an assignment expression of the form:

name [ key] = expression;

where name is any valid D identifier and key is a comma-separated list of one or more expressions. For example, the following statement defines an associative array a with key signature [ int, string] and stores the integer value 456 in a location named by the tuple [ 123, "hello”]:

a [123, "hello"] = 456;

The type of each object contained in the array is also fixed for all elements in a given array. Because a was first assigned using the integer 456, every subsequent value stored in the array will also be of type int. You can use any of the assignment operators defined in Chapter 2 to modify associative array elements, subject to the operand rules defined for each operator. The D compiler will produce an appropriate error message if you attempt an incompatible assignment. You can use any type with an associative array key or value that you can use with a scalar variable. You cannot nest an associative array within another associative array as a key or value.

You can reference an associative array using any tuple that is compatible with the array key signature. The rules for tuple compatibility are similar to those for function calls and variable assignments: the tuple must be of the same length and each type in the list of actual parameters must be compatible with the corresponding type in the formal key signature. For example, if an associative array x is defined as follows:

x[123ull] = 0;

then the key signature is of type unsigned long long and the values are of type int. This array can also be referenced using the expression x['a'] because the tuple consisting of the character constant 'a' of type int and length one is compatible with the key signature unsigned long long according to the arithmetic conversion rules described in Type Conversions.

If you need to explicitly declare a D associative array before using it, you can create a declaration of the array name and key signature outside of the probe clauses in your program source code:

int x[unsigned long long, char];

BEGIN

{

 x[123ull, 'a'] = 456;

}

Once an associative array is defined, references to any tuple of a compatible key signature are permitted, even if the tuple in question has not been previously assigned. Accessing an unassigned associative array element is defined to return a zero-filled object. A consequence of this definition is that underlying storage is not allocated for an associative array element until a non-zero value is assigned to that element. Conversely, assigning an associative array element to zero causes DTrace to deallocate the underlying storage. This behaviour is important because the dynamic variable space out of which associative array elements are allocated is finite; if it is exhausted when an allocation is attempted, the allocation will fail and an error message will be generated indicating a dynamic variable drop. Always assign zero to associative array elements that are no longer in use.

Key takeaway

Normally, an array is a collection of similar type of elements which has contiguous memory location.

Java array is an object which contains elements of a similar data type. Additionally, the elements of an array are stored in a contiguous memory location. It is a data structure where we store similar elements. We can store only a fixed set of elements in a Java array.

Array in Java is index-based, the first element of the array is stored at the 0th index, 2nd element is stored on 1st index and so on.

Unlike C/C++, we can get the length of the array using the length member. In C/C++, we need to use the sizeof operator.

In Java, array is an object of a dynamically generated class. Java array inherits the Object class, and implements the Serializable as well as Cloneable interfaces. We can store primitive values or objects in an array in Java. Like C/C++, we can also create single dimensional or multidimensional arrays in Java.

2.1.5 Record Types, Union Types

Often we encounter data that can take one of several forms. There are some things that are common to all forms, while others are unique in each form. This is a union data type. We encountered a union type in the form of various kinds of publications. There are many examples of union types: chess pieces, geometric shapes, types of employees in a company, etc.

Much like the publications example, the design of union types typically takes one of two forms.

Non-OO: Create several data types, one for each unique form. Write operations as external functions that operate on union-type data. The functions may query the type of data passed to it, and operate accordingly. This is a common design in functional languages, but is sometimes useful in procedural languages as well.

We are building an application that allows an interior designer to draw 2D floor plans of houses. This application allows a user to draw various kinds of 2D shapes on the screen. Common shapes are circles, rectangles, squares, etc. Being on the screen, each shape has a reference point (e.g. the center of the circle, the lower-left corner of a rectangle, etc.). It is useful to be able to compute various properties of a shape, such as its area, perimeter, distance from a global reference point, etc. Shapes are commonly resized as part of the drawing. Shapes also need to be compared to each other based on area.

We begin by distilling from the above description a list of operations that all shapes ought to offer. They are:

Most of the above operations seem "observational," i.e. they compute and return a value based on the attributes of the shape. The last operation "changes" a shape. We can characterize this operation in two ways: "change this shape" or "create a new, changed version of this shape". We adopt the latter definition, as it does not mutate the object.

Whenever there is a choice between immutable and mutable objects, choose the former. It avoids many pitfalls and errors. There are situations where the benefits of mutation exceed its pitfalls. We will see such cases in future lectures.

The notion of not allowing any side effects is sometimes referred to as "purity" or "pure programming." Functional programming languages embrace this concept by default, but it can be deliberately adopted in many other languages.

A mutation is when an attribute of an existing object is changed after it has been created. This change is done most often through one of the methods of that object. Such methods record the effect of their operation within the state of the object, rather than or in addition to returning it to their caller. Often a method is written that mutates the state in a way that is not obvious to its caller. This causes side effects (intended or unintended) on the object, and has the potential to cause hard-to-find bugs in code. Making an object immutable is a reliable way to avoid this problem. In fact, one of the hallmarks of most functional languages is that they do not allow mutation. Every function can be thought of as producing an output from some input data that does not change.

‘record’ type

Like Enum, record is also a special class type in Java. It is intended to be used in places where a class is created only to act as plain data carrier.

The important difference between class and record is that a record aims to eliminate all the boilerplate code needed to set and get the data from instance. Records transfer this responsibility to java compiler which generates the constructor, field getters, hashCode() and equals() as well toString() methods.

We can override any of default provided above methods in record definition to implement custom behaviour.

Use the keyword record to create such record class in Java. Just like we do in constructors, we need to mention the attributes and theirs types in record.

In given example, EmployeeRecord is used to hold a employee information i.e.

To create a record, call its constructor and pass all the field information in it. We can then get the record information using JVM generated getter methods and call any of generated methods.

Program output:

When we create EmployeeRecord record, the compiler creates bytes code and include following things in generated class file:

If we run the javap tool on generated class file, we will see the class file.

2. When we should use records

3. Technical deep dive

If we see the bytecode generated by Java compiler to check the method implementations of toString () (as well as equals () and hashCode ()), they are implemented using an invokedynamic based mechanism.

invokedynamic is a bytecode instruction that facilitates the implementation of dynamic languages (for the JVM) through dynamic method invocation.

Though all records extend java.lang.Record class, still we cannot create a subclass of java.lang.Record explicitly. The compiler will not pass through.

This means that the only way to get a record is to explicitly declare one and have javac create the class file.

we can add annotation to the components of a record, which are applicable to them. For example, we can apply @Transient annotation to the id field.

Java serialization of records is different than it is for regular classes. The serialized form of a record object is a sequence of values derived from the final instance fields of the object. The stream format of a record object is the same as that of an ordinary object in the stream.

During deserialization, if the local class equivalent of the specified stream class descriptor is a record class, then first the stream fields are read and reconstructed to serve as the record’s component values; and second, a record object is created by invoking the record’s canonical constructor with the component values as arguments (or the default value for component’s type if a component value is absent from the stream).

The serialVersionUID of a record class is 0L unless it is explicitly declared. The requirement for matching serialVersionUID values is also waived for record classes.

The process by which record objects are serialized cannot be customized; any class-specific <code>writeObject, read object, readObjectNoData, readResolve, writeExternal, and readExternal methods defined by record classes are ignored during serialization and deserialization. However, the writeReplace method may be used to return a substitute object to be serialized.

Before performing any serialization or deserialization, we must ensure that record must be either serializable or externalizable.

Program output:

Adding a new field and method is possible, but not recommended.

A new field added to record (not added in component list) must be static. Adding a method is also possible which can access the internal state of record fields.

The added fields and methods are not used in implicitly generated byte code by compiler so they are not part of any method implementation such as equals(), hashCode() or toString(). We must use them explicitly as required.

We can add constructor specific code for data validation in compact constructors. It helps in building a record which is valid in given business context.

A compact constructor does not cause a separate constructor to be generated by the compiler. Instead, the code that you specify in the compact constructor appears as extra code at the start of the canonical constructor.

We do not need to specify the assignment of constructor parameters to fields as it happen in canonical constructor in usual manner.

API Changes

The Class class has two methods – isRecord() and getRecordComponents(). The getRecordComponents() method returns an array of RecordComponent objects.

RecordComponent is a new class in the java.lang.reflect package with eleven methods for retrieving things such as the details of annotations and the generic type.

The ElementType enumeration has a new constant for records, RECORD_COMPONENT.

The ElementKind enumeration has three new constants for the records and pattern matching for instanceof features, namely BINDING_VARIABLE, RECORD and RECORD_COMPONENT.

Conclusion

Java records are an extremely useful feature and great addition to Java type system. It helps in cutting down boilerplate code written for simple data carrier classes almost completely.

But we should use it carefully and do not try to customize it behavior. It is best used in default shape.

If you ever start looking at ways to customize the record type in your application, first consider o convert it to the simple class type.

Key takeaway

Often we encounter data that can take one of several forms. There are some things that are common to all forms, while others are unique in each form. This is a union data type. We encountered a union type in the form of various kinds of publications. There are many examples of union types: chess pieces, geometric shapes, types of employees in a company, etc.

Much like the publications example, the design of union types typically takes one of two forms.

Non-OO: Create several data types, one for each unique form. Write operations as external functions that operate on union-type data. The functions may query the type of data passed to it, and operate accordingly. This is a common design in functional languages, but is sometimes useful in procedural languages as well.

2.1.6 Pointer and reference Type

C and C++ support pointers which are different from most of the other programming languages. Other languages including C++, Java, Python, Ruby, Perl and PHP support references.

On the surface, both references and pointers are very similar, both are used to have one variable provide access to another. With both providing lots of the same capabilities, it’s often unclear what is different between these different mechanisms. In this article, I will try to illustrate the differences between pointers and references.

Pointers: A pointer is a variable that holds memory address of another variable. A pointer needs to be dereferenced with * operator to access the memory location it points to.

References: A reference variable is an alias, that is, another name for an already existing variable. A reference, like a pointer, is also implemented by storing the address of an object.
A reference can be thought of as a constant pointer (not to be confused with a pointer to a constant value!) with automatic indirection, i.e the compiler will apply the * operator for you.

int i = 3;

// A pointer to variable i (or stores

// address of i)

int *ptr = &i;

// A reference (or alias) for i.

int &ref = i;

Differences:

While in references,

int a=10;

int &p=a; //it is correct

   but

int &p;

 p=a;    // it is incorrect as we should declare and initialize references at single step.

NOTE: This difference may vary from compiler to compiler. Above differences is with respect to turbo IDE.

8.     Reassignment: A pointer can be re-assigned. This property is useful for implementation of data structures like linked list, tree, etc. See the following examples:

9.     int a = 5;

10. int b = 6;

11. int *p;

12. p =  &a;

13. p = &b;

On the other hand, a reference cannot be re-assigned, and must be assigned at initialization.

int a = 5;

int b = 6;

int &p = a;

int &p = b; //At this line it will show error as "multiple declaration is not allowed".

However it is valid statement,

int &q=p;

14. Memory Address: A pointer has its own memory address and size on the stack whereas a reference shares the same memory address (with the original variable) but also takes up some space on the stack.
NOTE However if we want the true address of reference, then it can be found out in turbo IDE by writing the following statement,

15.    int &p = a;

16.    cout << &(&p);

17. NULL value: Pointer can be assigned NULL directly, whereas reference cannot. The constraints associated with references (no NULL, no reassignment) ensure that the underlying operations do not run into exception situation.

18. Indirection: You can have pointers to pointers offering extra levels of indirection. Whereas references only offer one level of indirection,

19. In Pointers,

20. int a = 10;

21. int *p;

22. int **q; //it is valid.

23. p = &a;

24. q = &p;

25.  

26. Whereas in references,

27.  

28. int &p = a;

29. int &&q = p; //it is reference to reference, so it is an error.

30. Arithmetic operations: Various arithmetic operations can be performed on pointers whereas there is no such thing called Reference Arithmetic. (but you can take the address of an object pointed by a reference and do pointer arithmetic’s on it as in &obj + 5).)

When to use What

The performances are exactly the same, as references are implemented internally as pointers. But still, you can keep some points in your mind to decide when to use what:

For Example,
In Pointers

int arr [] = {10,20,30};

int *p, i;

p = arr;

for (i = 0; i<3; i++)

{

cout << *p << endl;

p++;

}

Output:

10

20

30

NOTE: Here pointer will be ahead of base address

Now take same code in Reference

int arr [] = {10,20,30};

int &p = arr [0];

int i;

for (i = 0; i<3; i++)

{

cout << p << endl;

p++; //here it will increment arr [0] ++

}

Output:

10

11

12

NOTE: Here pointer will be at base address only.

Use references when you can, and pointers when you have to. References are usually preferred over pointers whenever you don’t need “reseating”. This usually means that references are most useful in a class’s public interface. References typically appear on the skin of an object, and pointers on the inside.

The exception to the above is where a function’s parameter or return value needs a “sentinel” reference — a reference that does not refer to an object. This is usually best done by returning/taking a pointer, and giving the NULL pointer this special significance (references must always alias objects, not a dereferenced null pointer).

Key takeaway

C and C++ support pointers which are different from most of the other programming languages. Other languages including C++, Java, Python, Ruby, Perl and PHP support references.

On the surface, both references and pointers are very similar, both are used to have one variable provide access to another. With both providing lots of the same capabilities, it’s often unclear what is different between these different mechanisms. In this article, I will try to illustrate the differences between pointers and references.

Pointers: A pointer is a variable that holds memory address of another variable. A pointer needs to be dereferenced with * operator to access the memory location it points to.

References: A reference variable is an alias, that is, another name for an already existing variable. A reference, like a pointer, is also implemented by storing the address of an object.
A reference can be thought of as a constant pointer (not to be confused with a pointer to a constant value!) with automatic indirection, i.e the compiler will apply the * operator for you.

2.2 Expression and Assignment Statements

2.2.1 Arithmetic expression

Java Variables are used to store data. Variables have type, name, and value. Variable names begin with a character, such as x, D, Y, z. Other examples are xy1, abc2, Count, N, sum, Sum, product etc. These are all variable names.

Different variable types are int, char, double. A variable type tells you what kind of data can be stored in that variable.

The syntax of assignment statements is easy. Assignment statements look like this:

variableName = expression;

For example:

int x; // This means variable x can store numbers such as 2, 10, -5.

char y; // This means variable y can store single characters 'a', 'A'.

double z; // This means variable z can store real numbers such as
10.45, 3.13411.

The above are declarations for variables x, y and z.

Important points:

1. Note that a variable has to be declared before being used.

2. The values assigned to a variable correspond to its type. Statements below represent assignment of values to a variable.

x = 100; // x is an integer variable.
y = 'A'; // y is a character variable.
abc = 10.45; // abc is of type double (real numbers).

3. Both variable declaration and assignment of values can be done in same statement. For example,

int x;
x = 100; is same as int x = 100;

4. A variable is declared only once.

int x; // Declaration for x.
x = 100; // Initialization.
x = x + 12; // Using x in an assignment statement.

Often in a program you want to give a variable, a constant value. This can be done:

class ConstDemo
{
public static void main (String [] arg)
{
      final double PI = 3.14;
      final double CONSTANT2 = 100;
. . . . . .
}
}

The reserved word final tells the compiler that the value will not change. The names of constants follow the same rules as the names for variables. (Programmers sometimes use all capital letters for constants; but that is a matter of personal style, not part of the language.)

2. Arithmetic Expressions
--------------------------
An assignment statement or expression changes the value that is held in a variable. Here is a program that uses an assignment statement:

class example
{
        public static void main ( String[] args )
{
        long x ; //a declaration without an initial value

        x = 123; //an assignment statement
        System.out.println("The variable x contains: " + x );
}
}

Java Arithmetic expressions use arithmetic operators such as +, -, /, *, and %. The % operator is the remainder or modulo operator. Arithmetic expressions are used to assign arithmetic values to variables. An expression is a combination of literals, operators, variables, and parentheses used to calculate a value.

The following code describes the use of different arithmetic expressions.

int x, y, z; // Three integer variables declared at the same time.

x = 10;
y = 12;
z = y / x; // z is assigned the value of y divided by x.
// Here z will have value 1.

z = x + y; // z is assigned the value of x+y                                     // Here z will have value 22.

z = y % x // z is assigned the value of remainder when y         // is divided by x. Here z will have value 2.

Java Boolean expressions are expressions which are either true or false. The different Boolean operators are < (less than), > (greater than),
== (equal to), >= (greater or equal to), <= (less or equal), != (not equal to).

Example:

int x = 10;
int y = 4;
int z = 5;

(x < 10) // This expression checks if x is less than 10.

(y > 1) // This expression checks if y is greater than 1.

((x - y) == (z + 1)); // This expression checks
// if (x - y) equals (z + 1).

A Boolean expression can also be a combination of other Boolean expressions. Two or more Boolean expressions can be connected using &&
(logical AND) and || (logical OR) operators.

The && operator represents logical AND. The expression is true only if both Boolean expressions are true. The || operator represents logical
OR. This expression would be true if any one of the associated expressions is true.

Example:

int x = 10; int y = 4; int z = 5;

(x <= 10) && (y > 1) // This expression checks if x is less
// than 10 AND y is greater than 1.
// This expression is TRUE.

(x*y == 41) || (z == 5) // This expression checks if x*y is equal
// to 40 OR if z is equal to 5.
// This expression is FALSE

Key takeaway

Java Variables are used to store data. Variables have type, name, and value. Variable names begin with a character, such as x, D, Y, z. Other examples are xy1, abc2, Count, N, sum, Sum, product etc. These are all variable names.

Different variable types are int, char, double. A variable type tells you what kind of data can be stored in that variable.

The syntax of assignment statements is easy. Assignment statements look like this:

variableName = expression;

For example:

int x; // This means variable x can store numbers such as 2, 10, -5.

char y; // This means variable y can store single characters 'a', 'A'.

double z; // This means variable z can store real numbers such as
10.45, 3.13411.

The above are declarations for variables x, y and z.

2.2.2 Overloaded Operators

When a class has two or more methods by the same name but different parameters, at the time of calling based on the parameters passed respective method is called (or respective method body will be bonded with the calling line dynamically). This mechanism is known as method overloading.

Operator overloading

Operator overloading is the ability to redefine the functionality of the operators. Programming languages like c++ supports operator overloading.

you can redefine or overload most of the built-in operators available in C++. Thus, a programmer can use operators with user-defined types as well.

Overloaded operators are functions with special names: the keyword "operator" followed by the symbol for the operator being defined. Like any other function, an overloaded operator has a return type and a parameter list.

Java does not support operator overloading due to the following reasons −

Key takeaway

Operator overloading is the ability to redefine the functionality of the operators. Programming languages like c++ supports operator overloading.

you can redefine or overload most of the built-in operators available in C++. Thus, a programmer can use operators with user-defined types as well.

Overloaded operators are functions with special names: the keyword "operator" followed by the symbol for the operator being defined. Like any other function, an overloaded operator has a return type and a parameter list.

2.2.3 Type conversions

In Java, type casting is a method or process that converts a data type into another data type in both ways manually and automatically. The automatic conversion is done by the compiler and manual conversion performed by the programmer. In this section, we will discuss type casting and its types with proper examples.

Fig 7 - Type casting

Type casting

Convert a value from one data type to another data type is known as type casting.

Types of Type Casting

There are two types of type casting:

Widening Type Casting

Converting a lower data type into a higher one is called widening type casting. It is also known as implicit conversion or casting down. It is done automatically. It is safe because there is no chance to lose data. It takes place when:

For example, the conversion between numeric data type to char or Boolean is not done automatically. Also, the char and Boolean data types are not compatible with each other. Let's see an example.

WideningTypeCastingExample.java

Output

Before conversion, the value is: 7

After conversion, the long value is: 7

After conversion, the float value is: 7.0

In the above example, we have taken a variable x and converted it into a long type. After that, the long type is converted into the float type.

Narrowing Type Casting

Converting a higher data type into a lower one is called narrowing type casting. It is also known as explicit conversion or casting up. It is done manually by the programmer. If we do not perform casting then the compiler reports a compile-time error.

Let's see an example of narrowing type casting.

In the following example, we have performed the narrowing type casting two times. First, we have converted the double type into long data type after that long data type is converted into int type.

NarrowingTypeCastingExample.java

Output

Before conversion: 166.66

After conversion into long type: 166

After conversion into int type: 166

Key takeaway

In Java, type casting is a method or process that converts a data type into another data type in both ways manually and automatically. The automatic conversion is done by the compiler and manual conversion performed by the programmer.

2.2.4 Relational and Boolean Expressions

The Equality and Relational Operators

The equality and relational operators determine if one operand is greater than, less than, equal to, or not equal to another operand. The majority of these operators will probably look familiar to you as well. Keep in mind that you must use "==", not "=", when testing if two primitive values are equal.

==      equal to

!=      not equal to

>       greater than

>=      greater than or equal to

<       less than

<=      less than or equal to

The following program, Comparison demo, tests the comparison operators:

class ComparisonDemo {

    public static void main (String [] args) {

        int value1 = 1;

        int value2 = 2;

        if(value1 == value2)

            System.out.println("value1 == value2");

        if(value1 != value2)

            System.out.println("value1 != value2");

        if(value1 > value2)

            System.out.println("value1 > value2");

        if(value1 < value2)

            System.out.println("value1 < value2");

        if(value1 <= value2)

            System.out.println("value1 <= value2");

    }

}

Output:

value1! = value2

value1 < value2

value1 <= value2

The Conditional Operators

The && and || operators perform Conditional-AND and Conditional-OR operations on two Boolean expressions. These operators exhibit "short-circuiting" behaviour, which means that the second operand is evaluated only if needed.

&& Conditional-AND

|| Conditional-OR

The following program, Conditionaldemo1, tests these operators:

class ConditionalDemo1 {

    public static void main (String [] args) {

        int value1 = 1;

        int value2 = 2;

        if((value1 == 1) && (value2 == 2))

            System.out.println("value1 is 1 AND value2 is 2");

        if ((value1 == 1) || (value2 == 1))

            System.out.println("value1 is 1 OR value2 is 1");

    }

}

Another conditional operator is? which can be thought of as shorthand for an if-then-else statement. This operator is also known as the ternary operator because it uses three operands. In the following example, this operator should be read as: "If someCondition is true, assign the value of value1 to result. Otherwise, assign the value of value2 to result."

The following program, ConditionalDemo2, tests the? operator:

class ConditionalDemo2 {

    public static void main (String [] args) {

        int value1 = 1;

        int value2 = 2;

        int result;

        Boolean someCondition = true;

        result = someCondition? value1: value2;

        System.out.println(result);

    }

}

Because someCondition is true, this program prints "1" to the screen. Use the ?: operator instead of an if-then-else statement if it makes your code more readable; for example, when the expressions are compact and without side-effects (such as assignments).

The Type Comparison Operator instanceof

The instanceof operator compares an object to a specified type. You can use it to test if an object is an instance of a class, an instance of a subclass, or an instance of a class that implements a particular interface.

The following program, Instanceofdemo, defines a parent class (named Parent), a simple interface (named MyInterface), and a child class (named Child) that inherits from the parent and implements the interface.

class InstanceofDemo {

    public static void main(String[] args) {

        Parent obj1 = new Parent();

        Parent obj2 = new Child();

        System.out.println("obj1 instanceof Parent: "

            + (obj1 instanceof Parent));

        System.out.println("obj1 instanceof Child: "

            + (obj1 instanceof Child));

        System.out.println("obj1 instanceof MyInterface: "

            + (obj1 instanceof MyInterface));

        System.out.println("obj2 instanceof Parent: "

            + (obj2 instanceof Parent));

        System.out.println("obj2 instanceof Child: "

            + (obj2 instanceof Child));

        System.out.println("obj2 instanceof MyInterface: "

            + (obj2 instanceof MyInterface));

    }

}

class Parent {}

class Child extends Parent implements MyInterface {}

interface MyInterface {}

Output:

obj1 instanceof Parent: true

obj1 instanceof Child: false

obj1 instanceof MyInterface: false

obj2 instanceof Parent: true

obj2 instanceof Child: true

obj2 instanceof MyInterface: true

When using the instanceof operator, keep in mind that null is not an instance of anything.

Key Take away

The equality and relational operators determine if one operand is greater than, less than, equal to, or not equal to another operand. The majority of these operators will probably look familiar to you as well. Keep in mind that you must use "==", not "=", when testing if two primitive values are equal.

==      equal to

!=      not equal to

>       greater than

>=      greater than or equal to

<       less than

<=      less than or equal to

2.2.5 Short Circuit Evaluation

In Java logical operators, if the evaluation of a logical expression exit in between before complete evaluation, then it is known as Short-circuit. A short circuit happens because the result is clear even before the complete evaluation of the expression, and the result is returned. Short circuit evaluation avoids unnecessary work and leads to efficient processing.
Below are the various types of Short circuit that occur in Java: