JAVA AND J2EE10CS753 Notes unit 1
The Eduladder is a community of students, teachers, and programmers just interested to make you pass any exams. So we solve previous year question papers for you.
See Our team
Wondering how we keep quality?
Got unsolved questions?

Ask Questions
Hey! Want to work with us? Our youtube channel See our Jd Want to apply? Do it today

Use Me  ?

New searches

You are here:Open notes-->VTU-->JAVA-AND-J2EE10CS753-Notes-unit-1

JAVA AND J2EE[10CS753] Notes unit-1

UNIT-1 INTRODUCTION TO JAVA

1. Introduction to Java
• Java is an object-oriented programming language developed by Sun Microsystems, a company best known for its high-end Unix workstations.
• Java is modeled after C++
• Java language was designed to be small, simple, and portable across platforms and operating systems, both at the source and at the binary level (more about this later).
• Java also provides for portable programming with applets. Applets appear in a Web page much in the same way as images do, but unlike images, applets are dynamic and interactive. 
• Applets can be used to create animations, figures, or areas that can respond to input from the reader, games, or other interactive effects on the same Web pages among the text and graphics.

1.1 Java Is Platform-Independent
Platform-independence is a program's capability of moving easily from one computer system to another.
• Platform independence is one of the most significant advantages that Java has over other programming languages, particularly for systems that need to work on many different platforms. 
• Java is platform-independent at both the source and the binary level.

1.2 Java Development Kit (JDK)- Byte code


• Bytecodes are a set of instructions that look a lot like machine code, but are not specific to any one processor
• Platform-independence doesn't stop at the source level, however. Java binary files are also platform-independent and can run on multiple platforms without the need to recompile the source. Java binary files are actually in a form called byte codes.
You can download open JDK from here HERE

1.3 Object-Oriented Programming
• Many of Java's object-oriented concepts are inherited from C++, the language on which it is based, but it borrows many concepts from other object-oriented languages as well. 
• Java includes a set of class libraries that provide basic data types, system input and output capabilities, and other utility functions. 
• These basic classes are part of the Java development kit, which also has classes to support networking, common Internet protocols, and user interface toolkit functions.
• Because these class libraries are written in Java, they are portable across platforms as all Java applications are.
1.4 Creating a simple Java Program 

Hello World example :
class HelloWorld {
public static void main (String args[]) {
System.out.println("Hello World! ");
}
}
This program has two main parts:

• All the program is enclosed in a class definition—here, a class called
Hello World.
• The body of the program (here, just the one line) is contained in a method
(function) called main(). In Java applications, as in a C or C++ program, main() is
the first method (function) that is run when the program is executed.

1.5 Compiling the above program : 
• In Sun's JDK, the Java compiler is called javac. javac HelloWorld.java
• When the program compiles without errors, a file called HelloWorld.class is created, in the same directory as the source file. This is the Java bytecode file.
• Then run that bytecode file using the Java interpreter. In the JDK, the Java interpreter is called simply java.
java HelloWorld
If the program was typed and compiled correctly, the output will
be : "Hello World!"

2. Variables and Data Types
• Variables are locations in memory in which values can be stored. They have a name, a type, and a value.
• Java has three kinds of variables: instance variables, class variables, and local variables.
• Instance variables, are used to define attributes or the state for a particular object. Class variables are similar to instance variables, except their values apply to all that class's instances (and to the class itself) rather than having different values for each object.
• Local variables are declared and used inside method definitions, for example, for index counters in loops, as temporary variables, or to hold values that you need only inside the method definition itself Variable declarations consist of a type and a variable name:
Examples :
int myAge;
String myName;
boolean isTired; 

2.1 Integer types.

T y pe Si z e R a ng e
byte 8 bits —128 to 127
short 16 bits —32,768 to 32,767
int 32 bits —2,147,483,648 to 2,147,483,647
—9223372036854775808 to 9223372036854775807 long 64 bits.

2.2 Floating-point
This is used for numbers with a decimal part. Java floating-point numbers are compliant with IEEE 754 (an international standard for defining floating-point numbers and arithmetic).
There are two floating-point types: float (32 bits, single-precision) and double (64 bits, double-precision).

2.3 Char
The char type is used for individual characters. Because Java uses the Unicode character set, the char type has 16 bits of precision, unsigned.

2.4 Boolean
The boolean type can have one of two values, true or false. Note that unlike in other C-like languages, boolean is not a number, nor can it be treated as one. All tests of Boolean variables should test for true or false.

2.5 Literals
Literals are used to indicate simple values in your Java programs. Number Literals
• There are several integer literals. 4, for example, is a decimal integer literal of
type int
•A decimal integer literal larger than an int is automatically of type long.
• Floating-point literals usually have two parts: the integer part and the decimal part—for example, 5.677777.

Boolean Literals

Boolean literals consist of the keywords true and false. These keywords can be used anywhere needed a test or as the only possible values for boolean variables.

2.6 Character Literals
Character literals are expressed by a single character surrounded by single quotes: 'a', '#', '3', and so on. Characters are stored as 16-bit Unicode characters.

3. Expressions and Operators
• Expressions are the simplest form of statement in Java that actually accomplishes something. Expressions are statements that return a value.
•Operators are special symbols that are commonly used in expressions.

Arithmetic and tests for equality and magnitude are common examples of expressions. Because they return a valuethe value can be assigned to a variable or test that value in other Java statements. Operators in Java include arithmetic, various forms of assignment, increment and decrement, and logical operations.

3.1 Arithmetic
Java has five operators for basic arithmetic
Arithmetic operators.
Operator Exam
Meaning ple
+ y is
System.out.println("x + y = " ( + y));
- y));
System.out.println("a is " + a + ", b is "
System.out.println("a / b = " + (a / b));
Assignment operators.
Expression Meaning
x += y x = x + y
Dept. of CSE, SJBIT Page 5
+ Addition 3 + 4 
— Subtraction 5 —
* Multiplication 5 * 5
/ Division 14 / 7 
% Modulus 20 % 7

Example program :
class ArithmeticTest {
public static void main (String args[]) {
short x = 6;
int y = 4;
float a = 12.5f; + y is
float b = 7f;
System.out.println("a is " + a + ", b is "
System.out.println("a / b = " + (a / b));
} }
Assignment operators.
Expression Meaning
x += y x = x + y
x —= y x = x — y
x *= y x = x * y
x = x / y x /= y

Incrementing and Decrementing

x++ increments the value of x by 1 just as if you had used the expression x = x + 1.
Similarly x-- decrements the value of x by 1.
Exercise : write the difference between :
y = x++;
y = ++x;

Comparison operators.
Operator Meaning Example
== Equal x == 3
!= Not equal x
< Less than x <
> Greater than x >
<= Less than or x
>= Greater than or equal to x >= 3

Logical Operators
• Expressions that result in boolean values (for example, the comparison operators) can be combined by using logical operators that represent the logical combinations
• AND, OR, XOR, and logical NOT.
• For AND combinations, use either the & or &&. The expression will be true only if both expressions are also true
• For OR expressions, use either | or ||. OR expressions result in true if either or both of the operands is also true
• In addition, there is the XOR operator ^, which returns true only if its operands are different (one true and one false, or vice versa) and false otherwise (even if both are true).
• In general, only the && and || are commonly used as actual logical
combinations. &, |, and ^ are more commonly used for bitwise logical
operations.

• For NOT, use the ! operator with a single expression argument. The value of the
NOT expression is the negation of the expression; if x is true, !x is false.

Bitwise Operators
These are used to perform operations on individual bits in integers.
Operator Meaning
& Bitwise AND
| Bitwise OR
^ Bitwise XOR
<< Left shift
>> Right shift
>>> Zero fill right shift
~ Bitwise complement
<<= Left shift assignment (x = x << y)
>>= Right shift assignment (x = x >> y)
>>>= Zero fill right shift assignment (x = x >>> y)
x&=y AND assignment (x = x & y)
x|=y OR assignment (x + x | y)
x^=y XOR assignment (x = x ^ y)

Operator Precedence
Operator precedence determines the order in which expressions are evaluated. This, in some cases, can determine the overall value of the expression. For example, take the following expression:
y = 6 + 4 / 2
Depending on whether the 6 + 4 expression or the 4 / 2 expression is evaluated first, the value of y can end up being 5 or 8. In general, increment and decrements are evaluated before arithmetic, arithmetic expressions are evaluated before comparisons, and comparisons are evaluated before logical expressions. Assignment expressions are evaluated last.

4 Arrays
Arrays in Java are actual objects that can be passed around and treated just like other objects.
Arrays are a way to store a list of items. Each slot of the array holds an individual element, and you can place elements into or change the contents or those slots as you need to.
Three steps to create an array:
1. Declare a variable to hold the array.
2. Create a new array object and assign it to the array variable.
3. Store things in that array.
E.g.
String[] names;
names = new String[10];
names [1] = “n1”;
names[2] = ‘n2’;
. . .

4.1 Multidimensional Arrays
Java does not support multidimensional arrays. However, you can declare and create an array of arrays (and those arrays can contain arrays, and so on, for however many dimensions you need), and access them as you would C-style
multidimensional arrays:
int coords[] [] = new int[12] [12];
coords[0] [0] = 1; coords[0] [1] = 2;

5 Control Statement
5.1 if Conditionals
• The if conditional, which enables you to execute different bits of code based
on a simple test in Java, is nearly identical to if statements in C.
• if conditionals contain the keyword if, followed by a boolean test,
followed by a statement (often a block statement) to execute if the test is true:
• if (x < y)
System.out.println("x is smaller than y");
An optional else keyword provides the statement to execute if the test is false:
if (x < y)
System.out.println("x is smaller than y"); else
System.out.println("y is bigger");

5.2 The Conditional Operator

An alternative to using the if and else keywords in a conditional statement is to use the conditional operator, sometimes called the ternary operator. The conditional operator is a ternary operator because it has three terms.
Syntax : test ? trueresult : falseresult
The test is an expression that returns true or false, just like the test in the if statement. If the test is true, the conditional operator returns the value of true result; if it's false, it returns the value of falseresult. For example, the following conditional tests the values of x and y, returns the smaller of the two, and assigns that value to the variable smaller:
int smaller = x < y ? x : y;
The conditional operator has a very low precedence; that is, it's usually evaluated only after all its sub expressions are evaluated. The only operators lower in precedence are the assignment operators..
5.3 switch Conditionals
This is the switch or case statement; in Java it's switch and behaves as it does in C:
switch (test) { case
valueOne:
resultOne;
break;
case valueTwo:
resultTwo;
break;
case valueThree:
resultThree;
break; ...
default: defaultresult;
}
In the switch statement, the test (a primitive type of byte, char, short, or int) is compared with each of the case values in turn. If a match is found, the statement, or statements after the test is executed. If no match is found, the default statement is executed. The default is optional, so if there isn't a match in any of the cases and default doesn't exist, the switch statement completes without doing anything.

5.4 for Loops

The for loop, as in C, repeats a statement or block of statements some number of times until a condition is matched. for loops are frequently used for simple iteration in which you repeat a block of statements a certain number of times and then stop, but you can use for loops for just about any kind of loop. The for loop in Java looks roughly like this:

for (initialization; test; increment) { statements;
}
The start of the for loop has three parts:
• Initialization is an expression that initializes the start of the loop. If you have a loop index, this expression might declare and initialize it, for example, int i = 0. Variables that you declare in this part of the for loop are local to the loop itself; they cease existing after the loop is finished executing. Test is the test that occurs after each pass of the loop. The test must be a boolean expression or function that returns a boolean value, for example, i < 10. If the test is true, the loop executes. Once the test is false, the loop stops executing

• Increment is any expression or function call. Commonly, the increment is used
to change the value of the loop index to bring the state of the loop closer to
returning false and completing.
The statement part of the for loop is the statements that are executed each time
the loop iterates. Just as with if, you can include either a single statement here
or a block; the previous example used a block because that is more common.
Here's an example of a for loop that initializes all the values of a String array to
null strings:
String strArray[] = new String[10];
int i; // loop index
for (i = 0; i < strArray.length; i++)
strArray[i] = "";

5.5 while and do Loops
Finally, there are while and do loops. while and do loops, like for loops, enable a
block of Java code to be executed repeatedly until a specific condition is met.
Whether you use a for loop, a while, or a do is mostly a matter of your pro
gramming style. while and do loop, are exactly the same as in C and C++ except
their test condition must be a boolean.

5.6 while Loops
The while loop is used to repeat a statement or block of statements as long as a
particular condition is true. while loops look like this:
while (condition) {
bodyOfLoop; }
The condition is a boolean expression. If it returns true, the while loop
executes the statements in bodyOfLoop and then tests the condition again,
repeating until the condition is false:
int count = 0;
while ( count < array 1 .length && array 1 [count] !=0)
{ array2[count] = (float) array1[count++];
}


5.7 do...while Loops
The do loop is just like a while loop, except that do executes a given statement
or block until the condition is false. The main difference is that while loops test
the condition
before looping, making it possible that the body of the loop will never execute if
the condition is false the first time it's tested. do loops run the body of the loop at
least once before testing the condition. do loops look like this:
do {
bodyOfLoop;
} while (condition);
Here, the bodyOfLoop part is the statements that are executed with each
int x = 1;
do {
System.out.println("Looping, round " + x); x++;
} while (x <= 10);
Here's the output of these statements:
Looping, round 1 Looping, round 2 Looping, round 3 Looping, round 4 Looping,
round 5 Looping, round 6
Looping, round Looping, round Looping, round Looping, round































 


Editors




Join eduladder!