DECLARATIONS & OPERATORS
AGENDA
Declaring Primitives, Reference Variables & data type casting - Practical Session Arrays -Practical Session Using Operators -Practical Session

Declaring Primitives & Reference Variables
Java Identifiers All the Java components - classes, variables, and methods need names. In Java these names are called Identifiers – Identifiers are representing the names of variables, methods, classes, etc. – Examples of identifiers are: employee_id, main, System, out. – Java identifiers are case-sensitive. This means that the identifier ‘employee_id’ is not the same as Emplyoee_ID. – Identifiers must begin with either a letter, an underscore “_”, or a dollar sign “$”. Letters may be lower or upper case. Subsequent characters may use numbers 0 to 9. – Identifiers cannot use Java keywords like class, public, void, etc. Examples of legal identifiers: int _id; double $c; long employee_id;

Java Identifiers Coding Guidelines for Classes, Methods & Variables
1. For names (identifiers) of classes, capitalize the first letter of each word of the class name. For example, MyFirstJavaClass 2. For names (identifiers) of methods and variables, the first letter of the word should start with a small letter. For example, myFirstMethod Variable A variable is an item of data used to store the state of objects. A variable has a: – data type The data type indicates the type of value that the variable can hold. – name The variable name must follow rules for identifiers.

Java Keywords
Keywords are predefined identifiers reserved by Java for a specific purpose.You cannot use kywords as names for your variables, classes, methods ... etc. Page 1

List of Java Keywords abstract char double for int private strictfp throws assert boolean class else goto interface protected super transient enum break const extends if long public switch try byte continue final implements native return synchronized void case default finally import new short this volatile catch do float instanceof package static throw while

Declaring and Initializing Variables Declare a variable as follows: [=initial value]; Note: Values enclosed in are required values, while those values in [] are optional. There are two types of variable declarations in Java: Primitive Variables - A primitive variable can be one of eight types: char, boolean, byte, short, int, long, double, or float. Once a primitive has been declared, its primitive type can never change, although in most cases its value can change. Reference variables - A reference variable is used to refer to (or access) an object of a class type. A reference variable can be used to refer to any object of the declared type, or a subtype of the declared type (when polymorphism is involved).

Primitive variable Declaration
Primitive variables can be declared as class variables (static variables), instance variables, method parameters or local variables. byte b; // declare one byte primitive variable boolean flagPrimitive; // declare one boolean primitive variable int a, b, c; // declare three int primitive variables Integer types, the sequence from small to big is byte, short, int, long and that doubles are bigger than floats (floating-point types). All six number types (byte, short, int, long, double & float) in Java are made up of a certain number of 8-bit bytes, and are signed, meaning they can be negative or positive. ( 1 byte = 8 bits) Declaring Reference Variables ‘Reference variables’ can be declared as static variables (class variables), instance variables, method parameters, or local variables. Object o; // declare one reference variable for class type ‘Object’ - here reference variable ‘o’ is used to refer to (or access) an object of class type ‘Object’ Book myBookReferenceVariable; // declare one reference variable for class type ‘Book’ Page 2

- here reference variable ‘myBookReferenceVariable’ is used to refer to (or access) an object of class type ‘Book’ String s1, s2, s3; // declare three reference variables for String class.

Instance Variables
• • Instance variables are defined inside the class. Instance variables are the fields that belong to each unique object.

class Employee { // define fields (instance variables) for ‘Employee’ instances or objects private String name; private String title, private String manager; // other code goes here including access methods for private fields }

•

Each instance or object of the preceding Employee class can have its own unique values for those three “fields” or "instance variables“ or "properties”.

It can be marked final, transient & with any of the three access modifiers (public, private & protected – will be discussed later).

Local (Automatic/Method) Variables
• • • Local variables are variables declared within a method. Local variable starts its life inside the method, it's also destroyed when the method has completed. Local variable declarations can't use most of the modifiers that can be applied to instance variables, such as public, private & protected Before a local variable can be used, it must be initialized with a value. Typically, you'll initialize a local variable in the same line in which you declare it. A local variable can't be referenced in any code outside the method in which it's declared. (Refer the following example) class Test { public void logIn() { int count = 10; // local variable declaration } public void doSomething(int i) { count = i; // Won't compile! Can't access local variable count // outside the method login() } } Local & Instance Variable Declarations • It is possible to declare a local variable with the same name as an instance variable. It's known as shadowing, as the following code demonstrates:

• • •

Page 3

class TestServer { int count = 9; // Declare an instance variable named count public void logIn() { // method login… int count = 10; // Declare a local variable named count System.out.println("local variable count is " + count); } public void count() { // method count… System.out.println("instance variable count is " + count); } public static void main(String[] args) { new TestServer().logIn(); new TestServer().count(); } } The preceding code produces the following output: local variable count is 10 // It specifies the local variable ‘count’ instance variable count is 9 // It specifies the instance variable ‘count’

‘static’ Variables (class variable) Declarations
• • A ‘static’ variable, is also referred as a class variable, which exists across instances of a class. static means one per class, not one for each object of a class. This means that you can use them without creating an instance (object) of a class.

(Refer the given example in your ‘Declarations&Operators’ application.) Note: • The opposite of a static variable is an instance variable, which is a variable related to a single instance of a class. Each time an instance of a class is created, the system creates one copy of the instance variables related to that class. • By default, all variables are created as instance variables. To make a class variable, you must explicitly declare the variable static.

Page 4

Comparison of modifiers on variables vs. methods
The figure compares the way in which modifiers can be applied to methods vs. variables.

‘final’ Variables & its various applications

final modifier can be applied to classes &

Page 5

•

Declaring a variable with the final keyword makes it impossible to reinitialize that variable once it has been initialized with an explicit value If a reference variable marked final can't ever be reassigned to refer to a different object.

•

‘final’ modifier can be applied to variables

Java Data Type Casting (Type Conversion) In java, you can force one data type to another, by a operation called “casting”. A variable of one type can receive

the value of another type.
Java supports two types of castings – primitive data type casting and reference type casting. Reference type casting is nothing but assigning one Java object to another object. It comes with very strict rules and is explained clearly in Object Casting. Now let us go for data type casting.

The cast operator (type) is used to convert numeric values from one numeric type to another or to change an object reference to a compatible type

Java data type casting comes with 3 flavors. 1. Implicit casting 2. Explicit casting 3. Boolean casting. 1. Implicit casting (widening conversion) A data type of lower size (occupying less memory) is assigned to a data type of higher size. This is done implicitly by the JVM. The lower size is widened to higher size. This is also named as automatic type conversion. Examples: int x = 10; // occupies 4 bytes double y = x; // occupies 8 bytes System.out.println(y); // prints 10.0 In the above code 4 bytes integer value is assigned to 8 bytes double value.

Page 6

2. Explicit casting (narrowing conversion) A data type of higher size (occupying more memory) cannot be assigned to a data type of lower size. This is not done implicitly by the JVM and requires explicit casting; a casting operation to be performed by the programmer. The higher size is narrowed to lower size. double x = 10.5; int y = x; // 8 bytes // 4 bytes ; raises compilation error

In the above code, 8 bytes double value is narrowed to 4 bytes int value. It raises error. Let us explicitly type cast it. double x = 10.5; int y = (int) x; The double x is explicitly converted to int y. The thumb rule is, on both sides, the same data type should exist.

3. Boolean casting A boolean value cannot be assigned to any other data type. Except boolean, all the remaining 7 data types can be assigned to one another either implicitly or explicitly; but boolean cannot. We say, boolean is incompatible for conversion. Maximum we can assign a boolean value to another boolean. Following raises error. boolean x = true; int y = x; boolean x = true; int y = (int) x;

// error // error

byte –> short –> int –> long –> float –> double In the above statement, left to right can be assigned implicitly and right to left requires explicit casting. That is, byte can be assigned to short implicitly but short to byte requires explicit casting.

Following char operations are possible. public class Demo { public static void main(String args[]) { char ch1 = 'A'; double d1 = ch1; System.out.println(d1); // prints 65.0 System.out.println(ch1 * ch1); // prints 4225 , 65 * 65 double d2 = 66.0; char ch2 = (char) d2; System.out.println(ch2); } }

// prints B

Practical Session
Define Primitive variables, References variables, Declare Instance variables, local variables & method parameters Demonstration of final variables Demonstration of static variables Demonstrate Java Data Type Casting Page 7

First, unzip your given ‘Declarations & Operators’ Java Application and open it in the IDE as shown in the following slides. Opening Java Application in IDE • • • Start your NetBeans 6.7.1 IDE – (start – Programs – NetBeans – NetBeans IDE 6.7.1 Select ‘Open Project’ from the ‘File’ menu & give Enter ‘Open Project’ dialog box will appear. Browse your project (Declarations&Operators) location, select and open your project.

Opening Java Class in IDE’s Editor • • • Your project ‘Declarations&Operators’ is opened in your IDE. Expand the variables folder under Source Packages as shown below. And, double click the ‘Variables.java’, now IDE editor shows the code of Variables.java

Page 8

Run your Java Program • • Right click over ‘Variables.java’ and click ‘Run File’ Your program outputs are shown in the output window.

Note: ‘Declarations&Operators’ Application has been built. Need not build it again. You can do build operation, if you do any modifications in any of the class of your application (For build operations refer presentation ‘Java_Basics’ – slide 26 & 27)

Page 9

Running Example Programs for Variables To run the remaining examples of ‘variables’ package of your application, repeat the same procedure mentioned in the page.

Arrays
Array Declarations we can use ‘one variable’ to store a list of data and manipulate them more efficiently. This type of variable is called an array. In Java, arrays are objects that store multiple variables of the same type. Arrays can hold either primitives variables or object references variables Declaring an Array of Primitives int [ ] id; // Square brackets before name (recommended) int id [ ]; // Square brackets after name (legal but less readable) Declaring an Array of Object References Book [ ] books; // Recommended Book books [ ]; // Legal but less readable // here ‘Book’ specifies a class and the array holds the object reference variables of class type Book

Array Instantiation To instantiate (in java, this means creation) an array, write the new keyword, followed by the square brackets containing the number of elements you want the array to have. For example, // Primitive array declaration int items[]; // instantiate array object items = new int[100]; or, can also be written as a single statement. //declare and instantiate object int items[] = new int[100]; Note: array index starts from 0. Above diagram shows the array indexes

You can also instantiate an array by directly initializing it with data. For example, int arr[] = {1, 2, 3, 4, 5}; This statement declares and instantiates an array of integers with five elements (initialized to the values 1, 2, 3, 4, and 5).

Page 10

Accessing an Array Element The following code shows how to access/print all the elements in the array. ‘ ’ loop can be used to access ‘for’ the array elements. (next chapter discusses about ‘for’ loop in control statements) To access an array element, we can use a number called an index, which can be used to access an element , in an array. public class ArraySample { public static void main( String[] args ){ int[] ages = new int[100]; // int array declaration… for( int i=0; i) operator returns ‘true’ to boolean primitive ‘b’ System.out.println("The value of b is " + b); // This statement will print ‘true’ } }

‘Equality’ Operators == equals (also known as "equal to") != not equals (also known as "not equal to")

Page 12

Each individual comparisons, for example two numbers (including char), two boolean values, or two object reference variables can be compared by using Equality operators. (See the following examples…). Example: Equality for Primitives class EqualityForPrimitives { public static void main(String[] args) { System.out.println("char 'a' == 'a'? " + ('a' == 'a')); System.out.println("char 'a' == 'b'? " + ('a' == 'b')); System.out.println("5 != 6? " + (5 != 6)); System.out.println("5.0 == 5L? " + (5.0 == 5L)); System.out.println("true == false? " + (true == false)); } } This program produces the following output: character 'a' == 'a'? true character 'a' == 'b'? false 5 != 6? true 5.0 == 5L? true true == false? false Equality for Reference Variables Two reference variables can refer to the same object. import javax.swing.JButton; class CompareReference { public static void main(String[] args) { JButton a = new JButton("Exit"); // here ‘a’ is an object reference variable JButton b = new JButton("Exit"); // here ‘b’ is an object reference variable JButton c = a; System.out.println("Is reference a == b? " + (a == b)); // a & b refer different objects System.out.println("Is reference a == c? " + (a == c)); // a & c refer the same object } } This code creates three reference variables. The first two, a and b, are separate JButton objects that happen to have the same label. The third reference variable, c is initialized to refer to the same object that ‘a’ refers. Output : Is reference a == b? false Is reference a == c? true Arithmetic Operators You're familiar with the basic arithmetic operators. + addition, – subtraction, * multiplication, / division The Remainder (%) Operator The remainder operator divides the left operand by the right operand, and the result is the remainder. class MathTest { public static void main (String [] args) { Page 13

int x = 15; int y = x % 4; // % operator divides ‘x’ by the 4 and the remainder is assigned to y System.out.println("The remainder of x % 4 is " + y); } } Running class MathTest prints the following: The remainder of x % 4 is 3 Increment & Decrement Operators Java has two operators that will increment or decrement a variable by exactly one. ++ increment (prefix and postfix) -- decrement (prefix and postfix) The operator is placed either before (prefix) or after (postfix) a variable to change it value. class MathTest { static int players = 0; public static void main (String [] args) { System.out.println("players online: " + players++); System.out.println("The value of players is “ + players); System.out.println("The value of players is now “ + ++players); } } Output: players online: 0 The value of players is 1 The value of players is now 2 Increment & Decrement Operators with other Operators int x = 2; int y = 3; if ((y == x++) | (x < ++y)) { System.out.println("x = " + x + " y = " + y); } The preceding code prints: x = 3 y = 4 The first expression compares x and y, and the result is false, because the increment on x doesn't happen until after the == test is made. Next, we increment x, so now x is 3. Then we check to see if x is less than y, but we increment y before comparing it with x! So the second logical test is (3 < 4). The result is true. Compound Assignment Operators The compound assignment operators let lazy typists save a few keystrokes off their workload. (+=, -=, *=, and /=) Here are several example assignments, first without using a compound operator, y = y - 6; x = x + 2 * 5; Now, with compound operators: y -= 6; // ‘-=‘ operator subtract 6 from ‘y’ and again assign it to variable ‘y’ x += 2 * 5; The last two assignments give the same result as the first two. Page 14

Note: (such as: * and / are higher precedence than + and -). The expression on the right side of the = will always be evaluated first. String Concatenation Operator The plus sign can also be used to concatenate two strings together ex: String animal = "Grey " + "elephant"; You can combine numbers with Strings. ex: String a = "String"; int b = 3; int c = 7; System.out.println(a + b + c); The int values were simply treated as characters and glued on to the right side of the String, giving the result: String37 However, if you put parentheses around the two int variables, as follows, System.out.println(a + (b + c)); you'll get this: String10 Using parentheses causes the (b + c) to evaluate first Conditional or Ternary Operator The conditional operator is a ternary operator (it has three operands) and is used to evaluate boolean expressions, much like an if statement. syntax: x = (boolean expression) ? value to assign if true : value to assign if false class Salary { public static void main(String [] args) { String grade = “A”; String status = (grade.equals(“A”) ? “Distinction“ : “First Class"; System.out.println(“Grade is " + status); } } A conditional operator starts with a boolean operation, followed by two possible values for the variable to the left of the assignment (=) operator. The first value (the one to the left of the colon) is assigned if the conditional (boolean) test is true, and the second value is assigned if the conditional test is false. Nested Conditional or Ternary Operator You can even nest conditional operators into one statement: class AssignmentOps { public static void main(String [] args) { int sizeOfYard = 10; int numOfPets = 3; String status = (numOfPets= 5 i >= 5 Refer the following slide for coding explanation

Example Explanation: Logical Operators (short-circuit) 1.) When we hit line 3, the first operand in the || expression (in other words, the left side of the || operation) is evaluated.

Page 16

2. )The isItSmall(3) method is invoked, prints "i < 5", and returns true. 3. ) Because the first operand in the || expression on line 3 is true, the || operator doesn't bother evaluating the second operand. 4.) Line 6 is evaluated, beginning with the first operand in the || expression. 5. ) The isItSmall(6) method is called, prints "i >= 5", and returns false. 6. ) Because the first operand in the || expression on line 6 is false, the || operator can't skip the second operand; there's still a chance the expression can be true, if the second operand evaluates to true. 7. ) Then, isItSmall(9) method is invoked and prints "i >= 5". 8. ) The isItSmall(9) method returns false, so the expression on line 6 is false, and thus line 7 never executes. Logical Operators (non-short-circuit) Logical Operators (non-short-circuit) - There are two non-short-circuit logical operators. & non-short-circuit AND | non-short-circuit OR These operators are used in logical expressions just like the && and || operators are used, but because they aren't the short-circuit operators, they evaluate both sides of the expression, always! They're inefficient. Even if the first operand (left side) in an & expression is false, the second operand will still be evaluated even though it's now impossible for the result to be true! And the | is just as inefficient: even if the first operand is true, the JVM will evaluate the second operand Logical Operators (short-circuit) vs. (non-short-circuit) You'll have to know exactly which operands are evaluated and which are not, since the result will vary depending on whether the second operand in the expression is evaluated: int z = 5; if(++z > 5 || ++z > 6) z++; // z = 7 after this code If the first operand in an OR operation is true, the result will be true, so the short-circuit || doesn't waste time looking at the right side of the equation. So, the right hand operand won’t be executed. versus: int z = 5; if(++z > 5 | ++z > 6) z++; // z = 8 after this code And the | is just as inefficient: even if the first operand is true, the JVM will also evaluate the second operand. Logical Operators (^ exclusive-OR (XOR)) ^ exclusive-OR (XOR) The ^ operator is related to the non-short-circuit operators and it always evaluates both the left and right operands in an expression. For an exclusive -OR (^) expression to be true, EXACTLY one operand must be true - for example, System.out.println("xor " + ((23))); produces the output: xor false Note: The preceding expression evaluates to false because BOTH operand one (2 < 3) and operand two (4 > 3) evaluate to true.

Page 17

Logical Operators (! boolean invert) ! boolean invert The ! (boolean invert) operator returns the opposite of a boolean's current value: boolean t = true; boolean f = false; System.out.println("! " + (t & !f)); produces the output: ! true Bitwise Operators Of the six logical operators listed previously, three of them (&, |, and ^) can also be used as "bitwise" operators. byte b1 = 6 & 8; byte b2 = 7 | 9; byte b3 = 5 ^ 4; System.out.println(b1 + " " + b2 + " " + b3); Bitwise operators compare two variables bit by bit, and return a variable whose bits have been set based on whether the two variables being compared had respective bits that were either both "on" (&), one or the other "on" (|), or exactly one "on" (^). Practical Session Relational Operators Arithmetic Operators Conditional or Ternary Operator Logical Operators Open your ‘Declarations&Operators’ Java Application in the IDE and run example programs.

Page 18