Unit 1 - Java Basics

Select the Unit Unit 1 - Java Basics Unit 2 - Inheritance, Interfaces & Packages Unit 3 - Data Structures Unit 4 - Exception Handling & Multithreading Unit 5 - GUI Programming with Java
UNIT 1 - Basics of Java

History of Java Java Buzzwords Data Types Variables Constants Scope & Lifetime of Variables

Java Buzzwords Simple: Java was designed to be easy for the professional programmer to learn and use effectively. If you understand the basic concepts of object-oriented programming, learning Java will be even easier. Object Oriented: The object model in Java is simple and easy to extend, while simple types, such as integers are kept as high-performance non objects. Secure: When use a Java-compatible Web browser, it can safely download Java applets without fear of viral infection. Java achieves this protection by confining a Java program to the Java execution environment and not allowing it access to other parts of the computer. Portable: Java programs to be dynamically downloaded to all the various types of platforms connected to the Internet, some means of generating portable executable code is needed. The same mechanism that helps ensure security also helps create portability. Java’s solution to these two problems is both elegant and efficient. Robust: To better understand how Java is robust, consider two of the main reasons for program failure, memory management mistakes and mishandled exceptional conditions. Memory management is handled by JVM & using Exception handling Java can deal with exceptions. Multithreaded: Java supports multithreaded programming, which allows to write programs that do many things simultaneously. Java’s easy-to-use approach to multithreading allows you to think about the specific behaviour of your program. Architecture-Neutral: The Java designers made several hard decisions in the Java language and the Java Virtual Machine in an attempt to alter this situation. Their goal was “write once, run anywhere, anytime, forever.” To a great extent, this goal was accomplished. Interpreted and High Performance: Java enables the creation of cross-platform programs by compiling into an intermediate representation called Java byte code. This code can be interpreted on any system that provides a Java Virtual Machine. Distributed: Java is designed for the distributed environment of the Internet, because it handles TCP/IP protocols. In fact, accessing a resource using a URL is not much different from accessing a file. This allowed objects on two different computers to execute procedures remotely. Java revived these interfaces in a package called Remote Method Invocation (RMI). This feature brings abstraction to client/server programming. Dynamic: Java programs carry with them substantial amounts of run-time type information that is used to verify and resolve accesses to objects at run time. This makes it possible to dynamically link code in a safe and expedient manner. This is crucial to the robustness of the applet environment, in which small fragments of byte code may be dynamically updated on a running system. Data Types: Data types in Java are classified into two types: 1. Primitive: Integer, Character, Boolean, and Floating Point. 2. Non-primitive: Classes, Interfaces and Arrays. Primitive Data Types 1. Integer Integer types can hold whole numbers. The size of the values that can be stored depends on the integer type that we choose. byte 1byte, short 2bytes, int 4bytes & long 8bytes 2. Floating Point Floating point data types are used to represent numbers with a fractional part. Single precision floating point numbers occupy 4 bytes and Double precision floating point numbers occupy 8 bytes. There are two subtypes: float 4bytes & double 8bytes. 3. Character It stores character constants in the memory. It assumes a size of 2 bytes, but basically it can hold only a single character because char stores unicode character sets. 4. Boolean Boolean data types are used to store values with two states: true or false. Variables: There are different types of variables in Java. 1. Instance Variables (Non-Static Fields) Objects store their individual states in “non-static fields”, that is, fields declared without the static keyword. Non-static fields are also known as instance variables because their values are unique to each instance of a class. For example, the currentSpeed of one bicycle is independent from the currentSpeed of another. 2. Class Variables (Static Fields) A class variable is any field declared with the static modifier; this tells the compiler that there is exactly one copy of this variable in existence, regardless of how many times the class has been instantiated. A field defining the number of gears for a particular kind of bicycle could be marked as static since, the number of gears will be same to all instances. The code static int numGears = 6; would create such a static field. 3. Local Variables A method stores its temporary state in local variables. The syntax for declaring a local variable is similar to declaring a field (for example, int count = 0;). Local variables are only visible to the methods in which they are declared; they are not accessible from the rest of the class. 4. Parameters They are the variables that are passed to the methods of a class. Variable Declaration Identifiers are the names of variables. They must be composed of only letters, numbers, the underscore, and the dollar sign ($). They cannot contain white spaces. Identifiers may only begin with a letter, the underscore, or the dollar sign. A variable cannot begin with a number. All variable names are case sensitive. Syntax: datatype1 variable1, datatype2 variable2, … etc; Constants: Constants can be defined in Java by creating public static final variables. class Constant_Ex{ public static final int MY_BDATE = 10; public static void main(String a[]){ System.out.println("My Birth day: "+MY_BDATE); } } Scope & Life time of Variables: Variables declared inside a scope are not accessible to code outside. Scopes can be nested. The outer scope encloses the inner scope. Variables declared in the outer scope are visible to the inner scope. In the following code, y is defined inside if statement and it is accessible inside of if statement. public class Scope_Ex{ public static void main(String args[]){ int x; x = 10; if (x == 10){ int y = 20; System.out.println("x and y: " + x + " " + y); x = y + 2; } System.out.println("x is " + x); } } A variable in the inner scope cannot have the same name as one variable in an outer scope. class Main { public static void main(String args[]) { int i = 1; { // creates a new scope int i = 2; // Compile-time error } } }

Operators & Operator hierarchy Expressions Type conversion & Casting Enumerated Types Conditional statements - If Else & Switch Statements Loops - For, While & do While statements

Operators & Operator hierarchy: Operators are special symbols that perform specific operations on one or more operands, and then return a result. The operators in the following table are listed according to precedence order. Operators with higher precedence are evaluated before operators with relatively lower precedence. Operators on the same line have equal precedence. When operators of equal precedence appear in the same expression, a rule must govern which is evaluated first. All binary operators except for the assignment operators are evaluated from left to right. The assignment operators are evaluated right to left. Operators Precedence postfix expr++, expr-- Unary ~, ! multiplicative *, /, % additive +, - Shift <<, >> Relational <, >, <=, >= Equality ==, != Bitwise AND & Logical Operators &&, || Assignment Operators =, +=, -=, *=, %=, /= In general-purpose programming, certain operators appear more frequently than others. Eg: the assignment operator "=" is far more common than the unsigned right shift operator ">>". Expressions An expression is a construct made up of variables, operators, and method invocations, which are constructed according to the syntax of the language, that evaluates to a single value. int i = 0; int result = 1 + 2; // result is now 3 if (value1 == value2) System.out.println("Equal"); The data type of the value returned by an expression depends on the elements used in the expression. The expression i = 0 returns an int because the assignment operator returns a value of the same data type as its left-hand operand; in this case, i is an int. As you can see from the other expressions, an expression can return other types of values as well, such as boolean or String. The Java programming language allows you to construct compound expressions from various smaller expressions as long as the data type required by one part of the expression matches the data type of the other. Here's an example of a compound expression: 1 * 2 * 3 The following expression gives different results, depending on whether you perform the addition or the division operation first: x + y / 100 // ambiguous You can specify exactly how an expression will be evaluated using parenthesis ( and ). For example, to make the previous expression unambiguous, you could write the following: (x + y) / 100 // unambiguous, recommended If you don't explicitly indicate the order for the operations to be performed, the order is determined by the precedence assigned to the operators in use within the expression. Operators that have a higher precedence get evaluated first. For example, the division operator has a higher precedence than does the addition operator. Therefore, the following two statements are equivalent: x + y / 100 x + (y / 100) // unambiguous, recommended Type conversion & Casting: If the two types are compatible, then Java will perform the conversion automatically. For example, assign an int value to a long variable. For incompatible types we must use a cast. Casting is an explicit conversion between incompatible types. Java's Automatic Conversions: An automatic type conversion will be used if the following two conditions are met: The two types are compatible. The destination type is larger than the source type. Ex: public class Type_Conversion{ public static void main(String a[]){ byte b=12; int i=0; i=b; System.out.println("b = "+b); System.out.println("i = "+i); } } Casting Incompatible Types: A narrowing conversion is to explicitly make the value narrower. A cast is an explicit type conversion. It has this general form: (target-type)value. target-type specifies the desired type. The following code casts double value to int & byte type value. public class Type_Cast { public static void main(String args[]) { byte b; int i = 1; double d = 1.123; System.out.println("Conversion of double to int."); i = (int) d; System.out.println("d: " + d + " i: " + i); System.out.println("Conversion of double to byte."); b = (byte) d; System.out.println("d: " + d + " b: " + b); } } Enumerated Types: An enum type is a type whose fields consist of a fixed set of constants. Common examples include compass directions (values of NORTH, SOUTH, EAST, and WEST) and the days of the week. Because they are constants, the names of an enum type's fields are in uppercase letters. In the Java programming language, you define an enum type by using the enum keyword. For example, you would specify a days-of-the-week enum type as: public enum Day { SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY } Ex: enum Months { JAN(1), FEB(2), MAR(3), APR(4), MAY(5), JUN(6), JUL(7), AUG(8), SEP(9), OCT(10), NOV(11), DEC(12); int Code; Months(int v){ this.Code = v; } } public class Enum_Ex { static Months myMonth; public static void main(String args[]){ System.out.println(myMonth.FEB.Code); } } Conditional statements: - If Else & Switch Statements The if-then statement is the most basic of all the control flow statements. It tells your program to execute a certain section of code only if a particular test evaluates to true. The if-then-else statement provides a secondary path of execution when an "if" clause evaluates to false. class If_Else_Ex{ public static void main(String a[]){ int Total = 340; char Grade; if (Total>=360) Grade = 'A'; else if (Total>=300) Grade = 'B'; else Grade = 'F'; System.out.println("Grade = "+Grade); } } Switch statement: Unlike if-then and if-then-else statements, the switch statement can have a number of possible execution paths. A switch works with the byte, short,char, and int primitive data types. It also works with enumerated types (discussed in Enum Types), the String class and a few special classes that wrap certain primitive types: Character, Byte, Short, and Integer The following example declares an int named option whose value represents a direction. The code displays the name of the direction, based on the value of option, using the switch statement. public class Switch_Ex { public static void main(String[] args) { int option = 2; String direction; switch (option) { case 1: direction = "NORTH"; break; case 2: direction = "EAST"; break; case 3: direction = "WEST"; break; case 4: direction = "SOUTH"; break; default: direction = "Invalid..."; break; } System.out.println(direction); } } Loops - For, While & do While statements: The for statement provides a compact way to iterate over a range of values. Programmers often refer to it as the "for loop" because of the way in which it repeatedly loops until a particula>r condition is satisfied. The general form of the for statement can be expressed as follows: for (initialization; termination; increment){ statements } class For_Ex{ public static void main(String[] args){ for(int i=1; i<11; i++){ System.out.println("Count is: "+ i); } } } in While loop, expressions with in the loop executed as long as particular condition is True. class While_Ex { public static void main(String[] args){ int count = 1; while (count < 11) { System.out.println("Count is: " + count); count++; } } } in do_While loop, expressions in loop executed first, then condition is tested. class do_while_Ex { public static void main(String[] args){ int count = 1; do { System.out.println("Count is: " + count); count++; } while (count < 11); } }

Break & Continue statements Arrays Input & Output Formatting Output OOP concepts – Encapsulation Inheritance

Break & Continue statements: When a break statement is encountered inside a loop, the loop is terminated and program control resumes at the next statement following the loop. Here is a simple example: class Break_Ex{ public static void main(String args[]){ for (int i = 0; i < 100; i++) { if (i == 10) break; // terminate loop if i is 10 System.out.println("i: " + i); } System.out.println("Loop complete."); } } The break statement can be used with while loops & infinite loops as well. Using continue: continue statement forces an early iteration of a loop. In while and do-while loops, a continue statement causes control to be transferred to the conditional expression that controls the loop. In a for loop, control goes first to the iteration portion of the for statement and then to the conditional expression. The following code shows how to use a continue statement. public class Continue_Ex{ public static void main(String a[]){ for (int i = 0; i < 10; i++) { System.out.print(i + " "); if (i % 2 == 0) continue; System.out.println(""); } } } Output: 0 1 2 3 4 5 6 7 8 9 Arrays: An array is a group of variables that share the same data type, and are referred to by a common name. Arrays of any type can be created and may have one or more dimensions. A specific element in an array is accessed by its index. The array index ranges from 0 to n−1; therefore, in an array of size 10, the first element is stored at index 0 and the last or the 10th element at index 9. class Arrays_Ex{ public static void main(String a[]){ int[] arr = new int[5]; arr[0]=12; arr[1]=15; arr[2]=18; arr[3]=23; arr[4]=27; for(int listItem: arr) System.out.println(listItem); } } Input & Output: Input is any information that is needed by your program to complete its execution. Output is any information that the program must convey to the user. The information you see on your computer screen is being output by one or more programs that are currently running on your computer. Console Input: Console input is any input that is entered in the console window instead of typing it into a field or dialog box that pops up in a window. For example, when the readLine() method is called, the program waits for the user to enter information. Whatever the user types is returned to the program in the form of a String object. The java.io package contains most of the classes you will need to use. Java.io.InputStream stores information about the connection between an input device and the computer or program. if you want to get an integer as input, we need to convert the string object into integer using parseInt() method. import java.io.*; class input_Ex{ public static void main(String a[]){ System.out.println("Enter Number for Multiplication Table: "); try{ InputStreamReader isr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(isr); int v = Integer.parseInt(br.readLine()); for (int i=1;i<=10;i++) System.out.println(v+" X "+i+" = "+(v*i)); }catch(Exception e){} } } Formatting Output: Instead of using System.out.println, use System.out.printf to print to console. In the example given below %20 specifies that the length of the string to be printed is 20 characters. “\t” specifies that a tab must be added after printing the string. “\n” specifies that a newline character must be added at the end. public class FormattingOutput { public static void main(String[] args){ System.out.printf("%20s\t%d\n","a",1); System.out.printf("%20s\t%d\n","is",2); System.out.printf("%20s\t%d\n","the",3); System.out.printf("%20s\t%d\n","word",4); System.out.printf("%20s\t%d\n","wordlong",5); System.out.printf("%20s\t%d\n","wordlonger",6); System.out.printf("%20s\t%d\n","wordlongest",7); System.out.printf("%20s\t%d\n","wordlongesthsgfsgdf",8); } }; a 1 is 2 the 3 word 4 wordlong 5 wordlonger 6 wordlongest 7 wordlongesthsgfsgdf 8 OOP concepts – Encapsulation Encapsulation is the technique of making the fields in a class private and providing access to the fields via public methods. If a field is declared private, it cannot be accessed by anyone outside the class, thereby hiding the fields within the class. For this reason, Encapsulation is also referred to as data hiding. The main benefit of encapsulation is the ability to modify our implemented code without breaking the code of others who use our code. With this feature Encapsulation gives maintainability, flexibility and extensibility to our code. Ex: class Encap_Test{ private String ename; private int eno; public void setEname(String s){ ename=s; } public void setEno(int i){ eno=i; } public String getEName(){ return ename; } public int getEno(){ return eno; } } class Encapsulation_Ex{ public static void main(String a[]){ Encap_Test obj = new Encap_Test(); obj.setEname("sudheer"); obj.setEno(1234); System.out.println("Employee Name: "+obj.getEName()); System.out.println("Employee Numb: "+obj.getEno()); } } In the above example ename & eno are private members of class Encap_Test. So these members cant be accessed from the outside objects. Inheritance: Inheritance can be defined as the process where one object acquires the properties of another. By using keywords extends & implements we can make one object acquire the properties of another object. Ex: class A{ public static void display_parent(){ System.out.println("in Parent class."); } } class inheritance_Ex extends A{ public static void main(String a[]){ display_parent(); } } In the example given above, A is superclass(parent class) and inheritance_Ex is subclass(base class) of A. We can call methods of parent class from base class directly without creating objects for parent class because base class inherits properties of parent class. There are different types of inheritance. Single inheritance: A single super class is inherited by single sub class. class A{..} class B extends A{..} Multilevel inheritance: A super class is inherited by sub class, and this sub class is inherited by another sub class. class A{..} class B extends A{..} class C extends B{..} Multiple inheritance: Multiple super classes inherited by single sub class. Java does not support multiple inheritance of classes, it support multiple inheritance of interfaces. interface A{..} interface B{..} class C implements A, B{..} Hierarchical inheritance: Single super class is inherited by Multiple sub class. class A{..} class B extends A{..} class C extends A{..}

Polymorphism Classes & Objects Constructors & Methods Parameter Passing Static fields & methods Access control, this reference

Polymorphism: Polymorphism means one name, many forms. There are 2 types of Java Polymorphism. Method overloading(compile time polymorphism): In java, method Overloading means creating more than one method with same name with different number of parameters. Java identifies the methods by comparing their number of parameters. Ex: class Overload_Ex{ static void sum(int x, int y){ int sum=x+y; System.out.println("sum = "+sum); } static void sum(int x, int y, int z){ int sum=x+y+z; System.out.println("sum = "+sum); } public static void main(String a[]){ sum(4,3); sum(2,4,6); } } Method overriding (run time polymorphism): In java, method Overloading means creating a method in subclass with the same name and type signature as a method in its superclass. Ex: class A{ void calculate(int x, int y){ int res=x+y; System.out.println("Result: "+res); } } class Override_Ex extends A{ void calculate(int x, int y){ int res=x*y; System.out.println("Result: "+res); } public static void main(String a[]){ Override_Ex obj = new Override_Ex(); obj.calculate(2,3); } } Classes & Objects: Class: - A class is collection of similar objects. - A class specifies the common behavior for all its objects. - By creating a class we are creating a user-defined data type. - A class is a logical construct. It does not occupy any memory. Example: People is a class. Sudheer, Kishore, Mallik etc are objects of the class “People”. Declaring a Class: In Java a class is declared using the keyword “class”. Syntax for declaring a class is as follows: class ClassName{ members } Class Members: A class can contain variables, methods and other things. Variables declared within a class and outside the methods and which are non-static are called “instance variables”, and which are declared as static are called “class variables”. Objects: - An object is defined as a self defined entity. - An object has two things, state and behavior. - State represents the characteristics of the object where as behavior represents “what we can do to the object or what the object does for us”. - In programming state is represented as a set of variables and behavior is represented as a set of methods. - Object occupies memory in the RAM. Ex: class A{ int i; void display(){ System.out.println("Hello..."); } } class B{ public static void main(String a[]){ A obj=new A(); obj.display(); } } In above program, obj is object of the class A, i and display() are properties of class A. Constructors & Methods: The purpose of constructor is to create an instance of a class. This can also be called creating an object. The purpose of methods is to execute java code. Constructors & methods differ in 3 aspects. modifiers, return type and name. Unlike methods, constructors can take only access modifiers(public, private & protected). Therefore, constructors cannot be abstract, final, native, static, or synchronized. Methods can have any valid return type, or no return type, in which case the return type is given as void. Constructors have no return type, not even void. Constructors have the same name as their class; by convention, methods use names other than the class name. Parameter Passing: In Java Parameter passing is of 2 types: -- Passing object reference variables. Ex: class Sample_Class{ int a; int b; Sample_Class(int p1, int p2){ a=p1; b=p2; } void update_values(Sample_Class ob){ a=a+10; b=b+10; } } class Parameter_Passing{ public static void main(String args[]){ Sample_Class obj = new Sample_Class(20,30); System.out.println("Before Updating: "+"a= "+obj.a+" b="+obj.b); obj.update_values(obj); System.out.println("After Updating: "+"a= "+obj.a+" b="+obj.b); } } In above example obj is object of Sample_Class, obj sent as object reference variables to update_values method. -- Passing primitive variables. Ex: class Sample_Class{ int a; int b; Sample_Class(int p1, int p2){ a=p1; b=p2; } void update_values(int a1, int a2){ a=a1+10; b=a2+10; } } class Parameter_Passing{ public static void main(String[] args){ Sample_Class obj = new Sample_Class(20,30); System.out.println("Before Updating: "+"a= "+obj.a+" b="+obj.b); obj.update_values(obj.a, obj.b); System.out.println("After Updating: "+"a= "+obj.a+" b="+obj.b); } } In above example a and b are integers(i.e primitive variables). Static fields: Static fields are simply fields that have the static modifier in their declarations. A static field is associated with the class rather than an object. public class Item{ private static int uniqueId = 1; private int itemId; private String itemName; public Item(String itemName) { this.itemName = itemName; itemId = uniqueId; uniqueId++; } } The fields itemId and itemName are non-static fields. When an instance of an Item class is created these fields will have values that are held in that object. If another Item object is created then it too will have itemId and itemName fields for storing values. The uniqueId static field holds a value which will be the same across all Item objects. If there are a hundred Item objects, there will be a hundred instances of the itemId and itemName fields but only ever one uniqueId static field. Static methods: It is a method which belongs to the class and not to the object(instance). A static method can access only static data. A static method can call only other static methods and can not call a non-static method from it. A static method can be accessed directly by the class name and does not need any object Syntax : . public class Static_Method_Ex{ public static void staticMethod(){ System.out.println(" Printed in staticMethod..."); } public static void main(String[] args){ staticMethod(); } } As shown above, static method can be called directly without an object. Access control: Access control in Java is based on 4 Access modifiers. Those are : public, private, protected & default. Access Modifier How to Access public class that declared the member, any subclasses, any class that is in the same package, any class private class that declared the member protected class that declared the member, any subclasses, any class that is in the same package can access it default class that declared the member, any subclasses this reference: The this keyword is a reference to the current object. class Foo { private int bar; public Foo(int bar) { this.bar = bar; } }

Overload Methods & Constructors Recursion Garbage Collection Building Strings - Exploring string class Enumerations Autoboxing & UnBoxing, Generics

Overload Methods & Constructors: Constructors are used to assign initial values to instance variables of the class. A default constructor with no arguments will be called automatically by the Java Virtual Machine (JVM). Constructor is always called by new operator. Constructor don't have any return type. Constructor can be overloaded provided they should have different arguments because JVM differentiates constructors on the basis of arguments passed in the constructor. Ex: public class ConstructorOverloading{ public static void main(String args[]){ Rectangle obj1=new Rectangle(2,4); int area1=obj1..first(); System.out.println(" The area of a rectangle in first constructor is : " + area1); Rectangle obj2=new Rectangle(5); int area2=obj2.second(); System.out.println(" The area of a rectangle in } } class Rectangle{ int l, b; public Rectangle(int x, int y){ l = x; b = y; } public int first(){ return(l * b); } public Rectangle(int x){ l = x; b = x; } public int second(){ return(l * b); } } Recursion: Recursion is when a method calls itself. It is sometimes used because some problems are easier to solve using a recursive solution than an iterative solution. Ex: using recursion to generate a fibonacci sequence: class Recursion_Ex{ public static void main(String a[]){ System.out.println(" facorial = "+fact(5)); } public static int fact(int n){ if ((n==0)||(n==1)) return 1; else return (n*fact(n-1)); } } Garbage Collection: In Java objects are dynamically allocated by using the new operator. In some languages, such as C++, dynamically allocated objects must be manually released by use of a delete operator. Java handles deallocation automatically. The technique that accomplishes this is called garbage collection. When no references to an object exist, that object is assumed to be no longer needed, and the memory occupied by the object can be reclaimed. The finalize( ) Method: Sometimes an object will need to perform some action when it is destroyed. Java provides a mechanism called finalization. By using finalization, you can define specific actions that will occur when an object is just about to be reclaimed by the garbage collector. Building Strings - Exploring string class: In Java strings are objects. Java provides the String class to create and manipulate strings. The most direct way to create a string is to write: String greeting = "Hello world!"; As with any other object, you can create String objects by using the new keyword and a constructor. String length: length() method is used to find the number of characters contained in the string object. public class StringDemo{ public static void main(String args[]){ String str = "sudheer kumar"; int len = str.length(); System.out.println( "String Length is : " + len ); } } Output: String Length is : 13 Concatenating Strings: The String class includes a method for concatenating two strings: string1.concat(string2); Strings are more commonly concatenated with the + operator, as in: "Hello," + " world" + "!" Some more string functions: char charAt(int index) Returns the character at the specified index. int compareTo(String anotherString) Compares two strings boolean equals(Object anObject) Compares this string to the specified object. String toLowerCase() Converts all of the characters in this String to lower case. String trim() Returns a copy of the string, with leading and trailing white space omitted. Enumerations public interface Enumeration An object that implements the Enumeration interface generates a series of elements, one at a time. Successive calls to the nextElement method return successive elements of the series. For example, to print all elements of a vector v: for (Enumeration e = v.elements() ; e.hasMoreElements() ;) { System.out.println(e.nextElement()); } Methods are provided to enumerate through the elements of a vector, the keys of a hashtable, and the values in a hashtable. Enumerations are also used to specify the input streams to a SequenceInputStream. Autoboxing & UnBoxing, Generics: When Java automatically converts a primitive type like int into corresponding wrapper class object e.g. Integer, its called autoboxing because primitive is boxed into wrapper class while in opposite case is called unboxing where an Integer object is converted into primitive int. All primitive types (byte, short, char, int, long, float, double and boolean) has corresponding wrapper class (Byte,Short, Integer, Character etc) and participate in autoboxing and unboxing. Since whole process happens automatically without writing any code for conversion its called autoboxing and auto unboxing. class AutoBoxing_Unboxing{ public static void main(String a[]){ Integer i = 5; // AutoBoxing - Primitive to Wrapper Conversion int j = i; // UnBoxing - Object to Primitive Conversion System.out.println("i="+i+" and j="+j); } } Generic Methods: Java Generic methods and generic classes enable programmers to specify, with a single method declaration, a set of related methods or, with a single class declaration, a set of related types, respectively. Generics also provide compile-time type safety that allows programmers to catch invalid types at compile time. Using Java Generic concept we might write a generic method for sorting an array of objects, then invoke the generic method with Integer arrays, Double arrays, String arrays and so on to sort the array elements. You can write a single generic method declaration that can be called with arguments of different types. Based on the types of the arguments passed to the generic method, the compiler handles each method call appropriately. Following are the rules to define Generic Methods: • All generic method declarations have a type parameter section delimited by angle brackets (< and >) that precedes the method's return type ( < T > in the next example). • Each type parameter section contains one or more type parameters separated by commas. A type parameter, also known as a type variable, is an identifier that specifies a generic type name. • The type parameters can be used to declare the return type and act as placeholders for the types of the arguments passed to the generic method, which are known as actual type arguments. • A generic method's body is declared like that of any other method. Note that type parameters can represent only reference types not primitive types (like int, double and char). Example: public class Generic_Ex{ public static void main(String a[]){ String[] arr1 = new String[] {"sudheer", "kumar", "kumar", "kumar"}; Integer[] arr2 = new Integer[]{12,13,24,24,24,24}; int cnt1 = count(arr1, "kumar"); System.out.println("count = "+ cnt1); int cnt2 = count(arr2, 24); System.out.println("count = "+ cnt2); } public static int count(T[] list, T item){ int count = 0; for ( T listItem : list ) if (item.equals(listItem)) count++; return count; } }