Your SlideShare is downloading. ×
Core java 5 days workshop stuff
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Core java 5 days workshop stuff

1,171
views

Published on

Published in: Education

0 Comments
9 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
1,171
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
0
Comments
0
Likes
9
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Core Java Rajeev Gupta MTech CS1 Rajeev Gupta
  • 2. Contents at a glance Java An Introduction Basic Java Constructs and Data Types and array OO Introduction Class object and related topics Inheritance Final ,Abstract Classes and interface String class, immutability, inner classes Exceptions Handling, assertions Streams and Input/output Files, serialization Java Thread Java Collections 2 Rajeev Gupta
  • 3. Day-1Session-1------------- Session-2 Introduction to Java ------------- What is Java,Why Java?  Object Oriented JDK,JRE and JVM discussion  Object, class, Encapsulation, Installing JDK, editPlus, eclipse 3.6  Abstraction, Hello World application  Inheritence, Procedural Programming  Polymorphism,message passing  If..else,switch, looping ( concepts only, implementation on day 2)  Array  Examples 3 Rajeev Gupta
  • 4. Day-2 Session-1 Session-2 ------------- ------------- InheritanceClass and objects Type of inheritance, diamond problem InstanceOf operatorCreating Classes FinalImplementing Methods Final variable, final method , final classObject: state, identity and behaviour Acess control: public, private,protected and defaultConstructors: default, parameterized and copy PackagesInstance variable, static variable and local variable Abstract class InterfaceInitialization block PolymorphismStatic method and applications OverloadingPackages and visibility modifier: public, Overriding protected, private and default Type of relationship bw objects IS-A, HAS-A, USE-A Rajeev Gupta 4
  • 5. Day-3Session-1------------- Session-2String class: Immutability and usages, ------------- stringbuilder and stringbuffer Exception handlingWrapper classes and usages Try, catch, throw, throws, Java 5 Language Features (I): finally Checked andAutoBoxing and Unboxing, Enhanced For loop, Varargs, Static Import, Unchecked exception Enums User defind exceptions design by contract- assertionsInner classesRegular inner class, method local inner class, annonymous inner class 5 Rajeev Gupta
  • 6. Day-4Session-1 Session-2------------- ------------- IO Multi-ThreadingChar and byte oriented streams Creating threads: using Thread class and Runnable interfaceBufferedReader and BufferedWriter Thread life cycleFile handling Using sleep(), join(), thread prioritiesObject Serialization and IO Synchronization [ObjectInputStream / ObjectOutputStream] Solving producer and consumer problem using wait() and notify() Deadlock introduction Concurrency Utilities Overview Executor Framework, Semaphore, Latches 6 Rajeev Gupta
  • 7. Day-5Session-1 Session-2------------- -------------Collections Framework Java 5 Language Features IIList, Map, Set usages introduction GenericsUsages ArrayList, LinkedList, HashMap, Annotations TreeMap, HashSetComparable, Comparator interface implementation Case study using collection, FileUser define key in HashMap MCQ Exam  7 Rajeev Gupta
  • 8. DAY-18 Rajeev Gupta
  • 9. Session-1 Introduction to Java  What is Java,Why Java?  JDK,JRE and JVM discussion  Installing JDK, editPlus, eclipse 3.6 Hello World application Procedural Programming  If..else,switch, looping  Array Examples 9 Rajeev Gupta
  • 10. What is Java? Java is not only an oo programming language It can be best described as OOPS+JVM+API 10 Rajeev Gupta
  • 11. How Sun define Java? Simple and Powerful Object Oriented Portable Architecture Neutral Distributed Multi-threaded Robust, Secure/Safe Interpreted High Performance Dynamic programming language/platform. 11 Rajeev Gupta
  • 12. Versions JDK 1.0 (1995) JDK 1.1 (1997) J2SE 1.2 (1998) ) Playground J2SE 1.3 (2000)  Kestrel Called Java2 J2SE 1.4 (2002)  Merlin J2SE 5.0 (2004)  Tiger Java SE 6 ( 2006)  Mustang Version for the session Java SE 7 (2011) Dolphin 12 Java 6 Rajeev Gupta
  • 13. Java 1.0 Java 1.1 Java 1.2 Java 1.3 Java 1.4 Java 1.58 packages 23 packages 59 packages 77 packages 103 packages 131 packages212 classes 504 classes 1520 classes 1595 classes 2175 classes 2656 classes New Events JFC/Swing JNDI Regular Exp javax.activity, Logging javax. Inner class Drag and Java Sound Assertions management Drop NIO Object Timer Serialization Java2D java.nio, javax.imageio, Jar Files CORBA javax.net, javax.print, javax.security, org.w3c International Reflection javax.naming, javax.sound, javax.transaction JDBC RMI javax.accessibility, javax.swing, org.omg java.math, java.rmi, java.security, java.sql, java.text, java.beansjava.applet, java.awt, java.io, java.lang, java.net, java.util
  • 14. Some common buzzwords JDK  Java development kit, developer need it Byte Code  Highly optimize instruction set, designed to run on JVM  Platform independent JRE  Java Runtime environment, Create an instance JVM, must be there on deployment machine.  Platform dependent JVM  Java Virtual Machine JVM  Pick byte code and execute on client machine  Platform dependent… 14 Rajeev Gupta
  • 15. Understanding JVM15 Rajeev Gupta
  • 16. Installing JDK, editPlus, eclipse 3.6 Follow me for configuration and running Java hello world!!! 16 Rajeev Gupta
  • 17. Analysis of Hello World !!!17 Rajeev Gupta
  • 18. Java Program Structure Documentation Section Package Statement Import Statements Interface Statements Class Declarations Main Method Class { }18 Rajeev Gupta
  • 19. Java Data Type 2 type  Primitive data type  Reference data type (latter) 19 Rajeev Gupta
  • 20. Primitive data type: boolean either true of false char 16 bit Unicode 1.1 byte 8-bit integer (signed) short 16-bit integer (signed) int 32-bit integer (signed) long 64-bit integer (singed) float 32-bit floating point (IEEE 754-1985) double 64-bit floating point (IEEE 754-1985)Java uses Unicode to represent characters internally 20 Rajeev Gupta
  • 21. Procedural Programming if..else switch Looping; for, while, do..while as usual in Java as in C/C++ Don’t mug the program/logic Follow dry run approach  Try some programms:  Create  Factorial program  Prime No check  Date calculation 21 Rajeev Gupta
  • 22. Array One Dimensional array  int x[]=new int[5] 22 Rajeev Gupta
  • 23. Session-2 Object Oriented ( concepts only) Object, class Basic principles of OO  Encapsulation  Abstraction  modularity  Inheritance/ Hierarchy  Polymorphism, message passing 23 Rajeev Gupta
  • 24. So what is object orientation?24 Rajeev Gupta
  • 25. What is an Object?25 Rajeev Gupta
  • 26. What is an class?26 Rajeev Gupta
  • 27. What is the relationship bw class andobjects?27 Rajeev Gupta
  • 28. Basic principles of OO28 Rajeev Gupta
  • 29. What is abstraction?29 Rajeev Gupta
  • 30. What is encapsulation?30 Rajeev Gupta
  • 31. What is modularity?31 Rajeev Gupta
  • 32. What is Hierarchy?32 Rajeev Gupta
  • 33. A bit about UML diagram… UML 2.0 aka modeling language has 12 type of diagrams Most important once are class diagram, use case diagram and sequence diagram. You should know how to read it correctly This is not UML session…  33 Rajeev Gupta
  • 34. DAY-234 Rajeev Gupta
  • 35. Session-1 Class and objects  Creating Classes and object  Object: state, identity and behaviour  Constructors: default, parameterized and copy  Need of “this” , Constructor chaining  Instance variable, static variable and local variable  Initialization block  Scanner and printf  Parameter passing in Java  Call by value / call by reference… 35 Rajeev Gupta
  • 36. What can goes inside an class?36 Rajeev Gupta
  • 37. Creating Classes and object37 Rajeev Gupta
  • 38. Correct way?38 Rajeev Gupta
  • 39. Constructors: default, parameterizedand copy Initialize state of the object Special method have same name as that of class Can’t return anything Can only be called once for an object Can be private Can’t be static* Can overloaded but cant overridden* Can be  Default, parameterized and copy constructor 39 Rajeev Gupta
  • 40. Need of this?  Which id assigned to which id?  “this” is an reference to the current object required to differentiate local variables with instance variables  Refer next slide…40 Rajeev Gupta
  • 41. 41 Rajeev Gupta
  • 42. this : Constructor chaining? Calling one constructor from another ? 42 Rajeev Gupta
  • 43. Static method/variable Instance variable –per object while static variable are per class Initialize and define before any objects Most suitable for counter for object Static method can only access static data of the class For calling static method we don’t need an object of that classNow guess why main was static? 43 Rajeev Gupta
  • 44. Using static data..44 Rajeev Gupta
  • 45. Initialization block We can put repeated constructor code in an Initialization block… Static Initialization block runs before any constructor and runs only once… 45 Rajeev Gupta
  • 46. Initialization block46 Rajeev Gupta
  • 47. Packages Packages are Java’s way of grouping a number of related classes and/or interfaces together into a single unit. That means, packages act as “containers” for classes. The benefits of organising classes into packages are:  The classes contained in the packages of other programs/applications can be reused.  In packages classes can be unique compared with classes in other packages. That two classes in two different packages can have the same name. If there is a naming clash, then classes can be accessed with their fully qualified name.  Classes in packages can be hidden if we don’t want other packages to access them.  Packages also provide a way for separating “design” from coding. 47 Rajeev Gupta
  • 48. Java Foundation Packages Java provides a large number of classes groped into different packages based on their functionality. The six foundation Java packages are:  java.lang  Contains classes for primitive types, strings, math functions, threads, and exception  java.util  Contains classes such as vectors, hash tables, date etc.  java.io  Stream classes for I/O  java.awt  Classes for implementing GUI – windows, buttons, menus etc.  java.net  Classes for networking  java.applet  Classes for creating and implementing applets 48 Rajeev Gupta
  • 49. Accessing Classes from Packages There are two ways of accessing the classes stored in packages:  Using fully qualified class name  java.lang.Math.sqrt(x);  Import package and use class name directly.  import java.lang.Math  Math.sqrt(x); Selected or all classes in packages can be imported: import package.class; import package.*; Implicit in all programs: import java.lang.*; package statement(s) must appear first 49 Rajeev Gupta
  • 50. Visibility Modifiers For instance variable and methods  Public  Protected  Default (package level)  Private For classes  Public and default 50 Rajeev Gupta
  • 51. Visibility Modifiers class A has default visibility hence can access in the same package only. Make class A public, then access it. Protected data can access in the same package and all the subclasses in other packages provide class itsef is public 51 Rajeev Gupta
  • 52. Visibility Modifiers Accessible to: public protected Package private (default) Same Class Yes Yes Yes Yes Class in package Yes Yes Yes No Subclass in Yes Yes No No different package Non-subclass Yes No No No different package52 Rajeev Gupta
  • 53. Packages and Name Clashing When packages are developed by different organizations, it is possible that multiple packages will have classes with the same name, leading to name classing. package pack1; package pack2; class Teacher class Student class Student class Courses We can import and use these packages like:  import pack1.*;  import pack2.*;  Student student1; // Generates compilation error 53 Rajeev Gupta
  • 54. Want to accept parameter from user?java.util.Scanner (Java 1.5)Scanner stdin = Scanner.create(System.in);int n = stdin.nextInt();String s = stdin.next();boolean b = stdin.hasNextInt()
  • 55. Missing powerful printf of C programming? System.out.printf( “format-string” [, arg1, arg2, … ] );
  • 56. Call by value & call by reference Java don’t support call by reference. When you pass an object in an method copy of reference is passed so that we can mutate the state of the object but can’t delete original object itself 56 Rajeev Gupta
  • 57. Session-2 Inheritance Type of inheritance, diamond problem InstanceOf operator Final Final variable, final method , final class Acess control: public, private,protected and default Packages Abstract class Interface Polymorphism Overloading Overriding 57 Rajeev Gupta
  • 58. Inheritance Inheritance is the inclusion of behaviour (i.e. methods) and state (i.e. variables) of a base class in a derived class so that they are accessible in that derived class. code reusability. Subclass and Super class concept 58 Rajeev Gupta
  • 59. Diamond Problem? Hierarchy inheritance can leds to poor design..Java don’t support it directly…( Possible using interface ) 59 Rajeev Gupta
  • 60. Inheritance example Use extends keyword Use super to pass values to base class constructor. 60 Rajeev Gupta
  • 61. Overloading Overloading deals with multiple methods in the same class with the same name but different method signatures. Both the above methods have the same method names but different method signatures, which mean the methods are overloaded. Overloading lets you define the same operation in different ways for different data. Constructor can be overloadedBe careful of overloading ambiguity*Overloading in case of var-arg and Wrapper objects… 61 Rajeev Gupta
  • 62. Overriding… Overriding deals with two methods, one in the parent class and the other one in the child class and has the same name and signatures. Both the above methods have the same method names and the signatures but the method in the subclass MyClass overrides the method in the superclass BaseClass Overriding lets you define the same operation in different ways for different object types. 62 Rajeev Gupta
  • 63. Polymorphism Polymorphism=many forms of one things Substitutability Overriding Polymorphism means the ability of a single variable of a given type to be used to reference objects of different types, and automatically call the method that is specific to the type of object the variable references. 63 Rajeev Gupta
  • 64. Polymorphism Every animal sound but differently… We want to have Pointer of Animal class assigned by object of derived class 64 Rajeev Gupta
  • 65. Example…65 Rajeev Gupta
  • 66. Need of abstract class? Sound( ) method of Animal class don’t make any sense …i.e. it don’t have semantically valid definition Method sound( ) in Animal class should be abstract means incomplete Using abstract method Derivatives of Animal class forced to provide meaningful sound() method 66 Rajeev Gupta
  • 67. Abstract class If an class have at least one abstract method it should be declare abstract class. Some time if we want to stop a programmer to create object of some class… Class has some default functionality that can be used as it is. Can implement only one abstract class  67 Rajeev Gupta
  • 68. Abstract class use cases… Want to have some default functionality from base class and class have some abstract functionality that cant be define at that moment. Don’t want to allow a programmer to create object of an class as it is too generic Interface vs. abstract class 68 Rajeev Gupta
  • 69. More example…69 Rajeev Gupta
  • 70. Final Its final: i.e. cant be change!!! final  Final method arguments  Cant be change inside the method  Final variable  Become constant, once assigned then cant be changed  Final method  Cant overridden  Final class  Cant inherited  Can be reuse Some examples…. 70 Rajeev Gupta
  • 71. Final class Final class cant be subclass ie cant be extended No method of this class can be overridden Ex: String class in Java… Real question is in what situation somebody should declare a class final 71 Rajeev Gupta
  • 72. Final Method Final Method Can’t overridden Class containing final method can be extended Killing substitutability 72 Rajeev Gupta
  • 73. Interface? Interface : contract bw two parties Interface method  Only declaration, no method definition  No method implementation please ! Interface variable  Public static and final constant  Its how java support global constant Break the hierarchy Solve diamond problem Callback in Java*Some Example …. 73 Rajeev Gupta
  • 74. Interface? Rules  All interface methods are always public and abstract, whether we say it or not.  Variable declared inside interface are always public static and final  Interface method can’t be static or final  Interface cant have constructor  An interface can extends other interface  Can be used polymorphically  An class implementing an interface must implement all of its method otherwise it need to declare abstract class… 74 Rajeev Gupta
  • 75. Implementing an interface…75 Rajeev Gupta
  • 76. Note Following interface constant declaration are identical  int i=90;  public static int i=90;  public int i=90;  Public static int i=90;  Public static final int i=90; Following interface method declaration don’t compile  final void bounce();  static void bounce();  private void bounce();  protected void bounce(); 76 Rajeev Gupta
  • 77. You must be clear up to this…77 Rajeev Gupta
  • 78. Type of relationship bw objects USE-A HAS-A IS-A (Most costly ? )ALWAYS GO FOR LOOSE COUPLING AND HIGH COHESION…But HOW? 78 Rajeev Gupta
  • 79. IS-A VS HAS-A79 Rajeev Gupta
  • 80. Self Reading ..will discuss latter.. Implementation inheritance (Already done) Interface inheritance with composition(Google it) 80 Rajeev Gupta
  • 81. Just for fun!!!81 Rajeev Gupta
  • 82. DAY-382 Rajeev Gupta
  • 83. Session-1 String class  Immutability and usages,  stringbuilder and stringbuffer Wrapper classes and usages Java 5 Language Features (I):  AutoBoxing and Unboxing  Enhanced For loop  Varargs  Static Import  Enums Inner classes  Regular inner class  method local inner class  anonymous inner class 83 Rajeev Gupta
  • 84. String Immutable i.e. once assigned then cant be changed Only class in java for which object can be created with or without using new operator Ex: String s=“india”; String s1=new String(“india”); What is the difference?  String concatenation can be in two ways:  String s1=s+”paki”; Operator overloading  String s3=s1.concat(“paki”); 84 Rajeev Gupta
  • 85. Some common string methods… charAt()  Returns the character located at the specified index concat()  Appends one String to the end of another ( "+" also works) equalsIgnoreCase()  Determines the equality of two Strings, ignoring case length()  Returns the number of characters in a String replace()  Replaces occurrences of a character with a new character substring()  Returns a part of a String toLowerCase()  Returns a String with uppercase characters converted toString()  Returns the value of a String toUpperCase()  Returns a String with lowercase characters converted trim()  Removes whitespace from the ends of a String 85 Rajeev Gupta
  • 86. String comparison Two string should never be checked for equality using == operator WHY? Always use equals( ) method….String s1=“india”;String s2=“paki”; if(s1.equals(s2)) ….. ….. 86 Rajeev Gupta
  • 87. Immutability Immutability means something that cannot be changed. Strings are immutable in Java. What does this mean?  String literals are very heavily used in applications and they also occupy a lot of memory.  Therefore for efficient memory management, all the strings are created and kept by the JVM in a place called string pool (which is part of Method Area).  Garbage collector does not come into string pool.  How does this save memory? 87 Rajeev Gupta
  • 88. Wrapper classes Helps treating primitive data as an object But why we should convert primitive to objects?  We can’t store primitive in java collections  Object have properties and methods  Have different behavior when passing as method argument  Eight wrapper for eight primitive  Integer, Float, Double, Character, Boolean etc… Integer it=new Integer(33); int temp=it.intValue(); …. 88 Rajeev Gupta
  • 89. Boxing / Unboxing Java 1.5 Boxing----------- Integer iWrapper = 10; Prior to J2SE 5.0, we use Integer a = new Integer(10); Unboxing------------- int iPrimitive = iWrapper; Prior to J2SE 5.0, we use int b = iWrapper.intValue(); 89 Rajeev Gupta
  • 90. Java 5 Language Features (I) AutoBoxing and Unboxing Enhanced For loop Varargs Static Import Enums 90 Rajeev Gupta
  • 91. Enhanced For loop Provide easy looping construct to loop through array and collections 91 Rajeev Gupta
  • 92. Varargs Java start supporting variable argument method in Java 1.5 Discuss function overloading in case of Varargs and wrapper classes 92 Rajeev Gupta
  • 93. Static Import Handy feature in Java 1.5 that allow something like this: import static java.lang.Math.PI; import static java.lang.Math.cos; Now rather then using  double r = Math.cos(Math.PI * theta); We can use something like  double r = cos(PI * theta); – looks more readable ….  Avoid abusing static import like  import static java.lang.Math.*;General guidelines to use static java import:  1) Use it to declare local copies of java constants  2) When you require frequent access to static members from one or two java classes 93 Rajeev Gupta
  • 94. Enums Enum is a special type of classes. enum type used to put restriction on the instance values 94 Rajeev Gupta
  • 95. Inner classes A class define inside another  Why to define it? 95 Rajeev Gupta
  • 96. top level inner class96 Rajeev Gupta
  • 97. Method local inner class Class define inside an method Can not access local data define inside method Declare local data static to access it 97 Rajeev Gupta
  • 98. Anonymous Inner classinterface Cookable{ void cook();}class Food{ Cookable c=new Cookable() { @Override public void cook() { System.out.print("cooked ..."); } };} 98 Rajeev Gupta
  • 99. Session-2 Exception handling  Try, catch, throw, throws, finally  Checked and Unchecked exception  User defined exceptions assertions 99 Rajeev Gupta
  • 100. What is Exception?An exception is an abnormal condition that arises while runninga program.Examples: Attempt to divide an integer by zero causes an exception to be thrown at run time. Attempt to call a method using a reference that is null. Attempting to open a nonexistent file for reading. JVM running out of memory. Exception handling do not correct abnormal condition rather it make our program robust i.e. make us enable to take remedial action when exception occurs…Help in recovering… 100 Rajeev Gupta
  • 101. Type of exceptions RuntimeEx: Unchecked Exception CompiletimeEx: Checked Error: Should not to be handled by programmer..like JVM crash all problem happens at run time in programming and also in real life..... for checked ex, we need to tell java we know about those problems for example readLine() throws IOException 101 Rajeev Gupta
  • 102. Exception Hierarchy java.lang.Throwable Our focus! java.lang.Exception java.lang.Errorchecked java.lang.VirtualMachineError unchecked Throwable class is super class for all exceptions in Java. When an exception occurs in a method, an object of Throwable type is thrown. The 2 subclasses –Error and Exception 102 Rajeev Gupta
  • 103. java.lang.Error java.lang.Exception unchecked exceptionunchecked exceptionjava.lang.RuntimeException java.io.IOException java.sql.SQLException java.lang.ArithmeticException checked exception java.lang.NullPointerException many more classes … many more classes… Rajeev Gupta 103
  • 104. Without Error Handling – Example 1 class NoErrorHandling{ public static void main(String[] args){ int a,b; a = 7; b = 0;Program does not reach here System.out.println(“Result is “ + a/b); System.out.println(“Program reached this line”); } } No compilation errors. While running it reports an error and stops without executing further statements: 104 java.lang.ArithmeticException: / by zero at Error2.main(Error2.java:10) Rajeev Gupta
  • 105. Without Error Handling – Example 2 class WithErrorHandling{ public static void main(String[] args){ int a,b; a = 7; b = 0; if (b != 0){ System.out.println(“Result is “ + a/b); }Program reaches here else{ System.out.println(“ B is zero); } System.out.println(“Program is complete”); } } 105 Rajeev Gupta
  • 106. Exceptions and their Handling When the JVM encounters an error such as divide by zero, it creates an exception object and throws it – as a notification that an error has occurred. If the exception object is not caught and handled properly, the interpreter will display an error and terminate the program. If we want the program to continue with execution of the remaining code, then we should try to catch the exception object thrown by the error condition and then take appropriate corrective actions. This task is known as exception handling. 106 Rajeev Gupta
  • 107. Common Java Exceptions ArithmeticException ArrayIndexOutOfBoundException ArrayStoreException FileNotFoundException IOException – general I/O failure NullPointerException – referencing a null object OutOfMemoryException SecurityException – when applet tries to perform an action not allowed by the browser’s security setting. StackOverflowException StringIndexOutOfBoundException 107 Rajeev Gupta
  • 108. Exceptions in Java A method can signal an error condition by throwing an exception – throws The calling method can transfer control to a exception handler by catching an exception - try, catch Clean up can be done by - finally 108 Rajeev Gupta
  • 109. With Exception Handling - Example 3 class WithExceptionHandling{ public static void main(String[] args){ int a,b; float r; a = 7; b = 0; try{ r = a/b; System.out.println(“Result is “ + r);Program Reaches here } catch(ArithmeticException e){ System.out.println(“ B is zero); } System.out.println(“Program reached this line”); } 109 Rajeev Gupta }
  • 110. Multiple Catch Statements If a try block is likely to raise more than one type of exceptions, then multiple catch blocks can be defined as follows: … … try { // statements } catch( Exception-Type1 e) { // statements to process exception 1 } .. .. catch( Exception-TypeN e) { // statements to process exception N } … 110 Rajeev Gupta
  • 111. finally block Java supports definition of another block called finally that be used to handle any exception that is not caught by any of the previous statements. It may be added immediately after the try block or after the last catch block: … try { // statements } catch( Exception-Type1 e) { // statements to process exception 1 } .. .. finally { …. } When a finally is defined, it is executed regardless of whether or not an exception is thrown. Therefore, it is also used to perform certain house keeping operations such as closing files and releasing system resources. 111 Rajeev Gupta
  • 112. Catching and PropagatingExceptions Exceptions raised in try block can be caught and then they can be thrown again/propagated after performing some operations. This can be done by using the keyword “throw” as follows:  throw exception-object;  OR  throw new Throwable_Subclass; 112 Rajeev Gupta
  • 113. With Exception Handling - Example 4 class WithExceptionCatchThrow{ public static void main(String[] args){ int a,b; float r; a = 7; b = 0; try{ r = a/b; System.out.println(“Result is “ + r); } Program Does Not reach here catch(ArithmeticException e){when exception occurs System.out.println(“ B is zero); throw e; } System.out.println(“Program is complete”); } 113 Rajeev Gupta }
  • 114. With Exception Handling - Example 5 class WithExceptionCatchThrowFinally{ public static void main(String[] args){ int a,b; float r; a = 7; b = 0; try{ r = a/b; System.out.println(“Result is “ + r); }Program reaches here catch(ArithmeticException e){ System.out.println(“ B is zero); throw e; } finally{ System.out.println(“Program is complete”); } } } 114 Rajeev Gupta
  • 115. User-Defined Exceptions Problem Statement :  Consider the example of the Account class  Account class had the following constructor public Account (int id, double balance) { .... ...... }  How would we ensure that the initial balance is not negative? 115 Rajeev Gupta
  • 116. User-Defined Exceptions instandard formatclass MyException extends Exception{ MyException(String message) { super(message); // pass to superclass if parameter is not handled by used defined exception }}class TestMyException {… try { .. throw new MyException(“This is error message”); } catch(MyException e) { System.out.println(“Message is: “+e.getMessage()); } }} Get Message is a method defined in a standard Exception class. 116 Rajeev Gupta
  • 117. design by contract? Design by contract specifies the obligations of a calling- method and called-method to each other. Valuable technique to have well designed interface Help programmer clearly to think what a function does and what are pre and post condition that must satisfied. Java uses the assert statement to implement pre- and post-conditions. Java’s exceptions handling also support design by contract especially checked exceptions 117 Rajeev Gupta
  • 118.  Preconditions  Contract the calling-method must agree to.  Conditions that must be true before a called method can execute.  Preconditions involve the system state and the arguments passed into the method at the time of its invocation.  If a precondition fails then there is a bug in the calling-method or calling software component. Post conditions  contract the called-method agrees to.  What must be true after a method completes successfully.  Post conditions can be used with assertions in both public and non-public methods.  The post conditions involve the old system state, the new system state, the method arguments and the method’s return value.  If a post condition fails then there is a bug in the called-method or called software component. 118 Rajeev Gupta
  • 119. Preconditions119 Rajeev Gupta
  • 120. Post condition120 Rajeev Gupta
  • 121. Class invariants  what must be true about each instance of a class?  A class invariant as an internal invariant that can specify the relationships among multiple attributes, and should be true before and after any method completes.  If an invariant fails then there could be a bug in either calling-method or called- method.  It is convenient to combine all the expressions required for checking invariants into a single internal method that can be called by assertions.  For example if you have a class, which deals with negative integers then you define the isNegative() convenient internal method121 Rajeev Gupta
  • 122. DAY-4122 Rajeev Gupta
  • 123. Session-1 Char and byte oriented streams BufferedReader and BufferedWriter File handling Object Serialization [ObjectInputStream / ObjectOutputStream] 123 Rajeev Gupta
  • 124. Stream Stream is an abstraction that either produces or consumes information. A stream is linked to a physical device by the Java I/O system. All streams behave in the same manner, even if the actual physical devices to which they are linked differ. 2 types of streams:  byte : for binray data  All byte stream class are like XXXXXXXXStream  character: for text data  All char stream class are like XXXXXXXXReader/ XXXXXXWriter 124 Rajeev Gupta
  • 125. Classification of Java StreamClasses Byte Stream Character Stream classes classes125 Rajeev Gupta
  • 126. Some important classes form java.io126 Rajeev Gupta
  • 127. System class in java System class defined in java.lang package It encapsulate many aspect of JRE System class also contain 3 predefine stream variables  in  System.in (InputStream)  Out  System.out(PrintStream)  Err  System.err(console) 127 Rajeev Gupta
  • 128. File File abstraction that FileReader represent file and char[] in = new char[50]; // to store input directories int size = 0; FileReader fr =new FileReader(file);  File f=new File("....");  boolean flag= file.createNewFile(); size = fr.read(in); // read the whole file!  boolean flag= file.mkDir(); System.out.print(size + " "); // how many bytes read  boolean flag=file.exists(); FileWriter for(char c : in) // print the array System.out.print(c); File file = new File( "fileWrite2.txt"); FileWriter fw =new FileWriter(file); fr.close(); // again, always close fw.write("howdynfolksn"); // write characters to fw.flush(); // flush before closing fw.close(); // close file when done 128 Rajeev Gupta
  • 129. BufferedReader and BufferedWriter Reading form console  BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); Reading form file  BufferedReader br=new BufferedReader(new InputStreamReader(new File(“foo.txt”))); 129 Rajeev Gupta
  • 130. Serialization Storing the state of the object on a file along some metadata….so that it Can be recovered back……….. Serialization used in RMI (Remote method invocation ) while sending an object from one place to another in network… 130 Rajeev Gupta
  • 131. What actually happens duringSerialization The state of the object from heap is sucked and written along with some meta data in an file…. 131 Rajeev Gupta
  • 132. De- Serialization When an object is de-serialized, the JVM attempts to bring object back to the life by making an new object on the heap that have the same state as original object Transient variable don’t get saved during serialization hence come with null !!! 132 Rajeev Gupta
  • 133. Hello world Example…133 Rajeev Gupta
  • 134. Session-2 Multi-Threading  Creating threads: using Thread class and Runnable interface  Thread life cycle  Using sleep(), join(), thread priorities  Synchronization  Solving producer and consumer problem using wait() and notify()  Deadlock introduction  Concurrency Utilities Overview  Executor Framework, Semaphore, Latches 134 Rajeev Gupta
  • 135. What is threads? LWP135 Rajeev Gupta
  • 136. Basic fundamentals Thread: class in java.lang thread: separate thread of executionWhat happens during multithreading?1. JVM calls main() method2. main() starts a new thread. Main thread is tempory frozen while new thread start running so JVM switch between created thread and main thread till both complets 136 Rajeev Gupta
  • 137. Creating threads inJava? Implements Runnable interface Extending Thread class…….. Job and Worker analogy… 137 Rajeev Gupta
  • 138. Thread life cycle… If a thread is blocked ( put to sleep) specified no of ms should expire If thread waiting for IO that must be over.. If a thred calls wait() then another thread must call notify() or notifyAll() If an thred is suspended() some one must call resume() 138 Rajeev Gupta
  • 139. Java.lang.Thread Thread()  construct new thread void run()  must be overriden void start()  start thread call run method static void sleep(long ms)  put currently executing thread to sleep for specified no of millisecond boolean isAlive()  return true if thread is started but not expired void stop() void suspend() and void resume()  Suspend thread execution…. 139 Rajeev Gupta
  • 140. Java.lang.Thread void join(long ms)  Main thread Wait for specified thread to complete or till specified time is not over void join()  Main thread Wait for specified thread to complete static boolean interrupted() boolean inInterrupted() void interrupt()  Send interrupt request to a thread 140 Rajeev Gupta
  • 141. Creating Threads By extending Thread class class MyThread extends Thread { public void run() { } } Implementing the Runnable interface class MyRunnable implements Runnable { public void run() { } } 141 Rajeev Gupta
  • 142. package com;class MyThread3 extends Thread{ public MyThread3() { super("Dmeo thread3"); start(); } public void run() { try { for(int i=0;i<5;i++) { System.out.println("Child thread:"+i); Thread.sleep(500); } } catch(InterruptedException ex){} System.out.println("Main exited..."); }}public class DemoThreadExtendsThread { public static void main(String[] args) { new MyThread3(); try { for(int i=0;i<5;i++) { System.out.println("Main thread:"+i); Thread.sleep(500); } } catch(InterruptedException ex){} System.out.println("Eixting main thread"); }} 142 Rajeev Gupta
  • 143. package com;class MyThread implements Runnable{ Thread t; String name; public MyThread(String name) { // TODO Auto-generated constructor stub this.name=name; t=new Thread(this,name); } public void run() { for(int i=0;i<5;i++) { System.out.println(Thread.currentThread().getName()+":"+i); try { Thread.sleep(500); } catch(InterruptedException ex){} } }}public class DemoThread2 { public static void main(String[] args) { MyThread ot1=new MyThread("A"); MyThread ot2=new MyThread("B"); MyThread ot3=new MyThread("C"); …. ….} 143 Rajeev Gupta
  • 144. Understanding join( )144 Rajeev Gupta
  • 145. Using isAlive() and join() package com; class MyThread implements Runnable { Thread t; String name; public MyThread(String name) { // TODO Auto-generated constructor stub this.name=name; t=new Thread(this,name); } public void run() { for(int i=0;i<5;i++) { System.out.println(Thread.currentThread().getName()+":"+i); try { Thread.sleep(500); } catch(InterruptedException ex){} } } } public class DemoThread2 { public static void main(String[] args) { MyThread ot1=new MyThread("A"); MyThread ot2=new MyThread("B"); MyThread ot3=new MyThread("C"); System.out.println("Status of thread1"+ot1.t.isAlive()); System.out.println("Status of thread1"+ot2.t.isAlive()); System.out.println("Status of thread1"+ot3.t.isAlive()); try { Thread.sleep(1000); } catch(InterruptedException ex){} //applying join try { ot1.t.join(); ot2.t.join(); ot3.t.join(); } catch(InterruptedException ex){} System.out.println("Main exit"); } 145 } Rajeev Gupta
  • 146. Checking thread priorities 146 Rajeev Gupta
  • 147. Understanding thread synchronization147 Rajeev Gupta
  • 148. Synchronization Synchronization  Mechanism to controls the order in which threads execute  Competition vs. cooperative synchronization Mutual exclusion of threads  Each synchronized method or statement is guarded by an object.  When entering a synchronized method or statement, the object will be locked until the method is finished.  When the object is locked by another thread, the current thread must wait. Rajeev Gupta 148
  • 149. Thread Synchronization example bank accountproblem Example --- bank accounts Public class Account { private long balance; public boolean withdraw(long amount) { if (amount <= balance) { long newBalance = balance – amount; balance = newBalance; return true; } else { return false; } } // other methods and fields }• What might happen in the presence of multiple threads? 149 Rajeev Gupta
  • 150. Example (Cont.) if (amount <= balance) { long newBalance = balance – amount; balance = newBalance; return true; } Possible scenario Assume that the initial balance is $1,000,000, and two withdraw requests of $1,000,000 are made almost simultaneously. time balance withdraw 1 withdraw 2 t1 1,000,000 amount<=balance t2 1,000,000 amount<=balance t3 1,000,000 newbalance=...; t4 1,000,000 newbalance=...; t5 0 balance=...; t6 0 balance=...; t7 0 return true; t8 0 return true; 150 Rajeev Gupta
  • 151. Example public class Account { private long balance; public synchronized boolean withdraw(long amount) { if (amount <= balance) { long newBalance = balance – amount; balance = newBalance; return true; } else { return false; } } // other methods and fields } Rajeev Gupta 151
  • 152. Exercise Make withdraw method synchronized by using the synchronized statement. public class Account { private long balance; public boolean withdraw(long amount) { // WRITE YOUR CODE HERE… if (amount <= balance) { long newBalance = balance – amount; balance = newBalance; return true; } else { return false; } } } Rajeev Gupta 152
  • 153. Using thread synchronization153 Rajeev Gupta
  • 154. Inter thread communication Java have elegant Interprocess communication using wait() notify() and notifyAll() methods All these method defined final in the Object class Can be only called from a synchronized context 154 Rajeev Gupta
  • 155. wait() and notify(), notifyAll() wait()  Tells the calling thread to give up the monitor and go to the sleep until some other thread enter the same monitor and call notify() notify()  Wakes up the first thread that called wait() on same object notifyAll()  Wakes up all the thread that called wait() on same object, highest priority thread is going to run first 155 Rajeev Gupta
  • 156. Incorrect implementation of produceconsumer …class Q class Producer implements Runnable{ { int n; synchronized int get() Q q; { public Producer(Q q) { this.q=q; System.out.println("got:"+n); new Thread(this,"Producer").start(); return n; } } public void run() synchronized void put(int n) { { this.n=n; int i=0; while(true) System.out.println("Put:"+n); q.put(i++); } }} } 156 Rajeev Gupta
  • 157. Incorrect implementation of produce consumer …public class PandC {public static void main(String[] args) { Q q=new Q(); new Producer(q); new Consumer(q); System.out.println("ctrol C for exit");}} 157 Rajeev Gupta
  • 158. Correction needed in Queue class…class Q{ int n; boolean valueSet=false; synchronized int get() { if(!valueSet) try { wait(); } catch(InterruptedException ex){} System.out.println("got:"+n); valueSet=false; notify(); return n; } synchronized void put(int n) { if(valueSet) try { wait(); } catch(InterruptedException ex){} this.n=n; valueSet=true; System.out.println("Put:"+n); 158 Rajeev Gupta notify();
  • 159. DAY-5159 Rajeev Gupta
  • 160. Session-1 Session-1  Object class in Java  Collections Framework  List, Map, Set usages introduction  Usages  ArrayList, LinkedList, HashMap, TreeMap, HashSet  Comparable, Comparator interface implementation  User define key in HashMap 160 Rajeev Gupta
  • 161. Object Object is an special class in java defined in java.lang Every class automatically inherit this class whether we say it or not… Why Java has provided this class? 161 Rajeev Gupta
  • 162. Method defined in Object class… String toString() boolean equals() int hashCode() clone() void finalize() getClass() Method that can’t be overridden  final void notify()  final void notifyAll()  final void wait() 162 Rajeev Gupta
  • 163. toString( ) If we don’t overriding toString() method of Object class it print Object ID no by default Override it to print some useful information…. 163 Rajeev Gupta
  • 164. toString()164 Rajeev Gupta
  • 165. equals What O/P do you expect in this case…… O/P would be two employees are not equals.... ??? Problem is that using == java compare object id of two object and that can never be equals, so we are getting meaningless result… 165 Rajeev Gupta
  • 166. Overriding equals() Don’t forget DRY run….. 166 Rajeev Gupta
  • 167. hashCode() Whenever you override equals()for an type don’t forget to override hashCode() method… hashCode() make DS efficient What hashCode does  HashCode divide data into buckets  Equals search data from that bucket… 167 Rajeev Gupta
  • 168. clone() Lets consider an object that creation is very complicated, what we can do we can make an clone of that object and use that Costly , avoid using cloning if possible, internally depends on serialization Must make class supporting cloning by implementing an marker interface ie Cloneable 168 Rajeev Gupta
  • 169. finalize() As you are aware ..Java don’t support destructor Programmer is free from memory management  Memory mgt is done by an component of JVM ie called Garbage collector GC GC runs as low priority thread.. We can override finalize() to request java “Please run this code before recycling this object” Cleanup code can be written Not reliable, better not to use… Demo programm  WAP to count total number of employee object in the memory at any moment of time if an object is nullified then reduce count…. 169 Rajeev Gupta
  • 170. Java collection Java collections can be considered aka readymade data structure, we should know how to use it…. collection  Name of topic Collection  Base interface Collections  Static utility class provide various useful algorith 170 Rajeev Gupta
  • 171. collection Collection  Why it is called an framework?  Readymade Data structure in Java… 171 Rajeev Gupta
  • 172. 172 Rajeev Gupta
  • 173. ArrayList: aka growable array…173 Rajeev Gupta
  • 174. ArrayList of user defined object174 Rajeev Gupta
  • 175. Comparable and Comparator interface We need to teach Java how to sort user define object Comparable and Comparator interface help us to tell java how to sort user define object…. 175 Rajeev Gupta
  • 176. Implementing Comparable176 Rajeev Gupta
  • 177. Comparator Don’t need to change Employee class  177 Rajeev Gupta
  • 178. Useful stuff178 Rajeev Gupta
  • 179. Useful examples…179 Rajeev Gupta
  • 180. Useful examples…180 Rajeev Gupta
  • 181. LinkedList : AKA Doubly Link list………..can move back and forth....... 181 Rajeev Gupta
  • 182. Useful examples…182 Rajeev Gupta
  • 183. fundamental diff bw ArrayList andLinkedList ArrayLists manage arrays internally. [0][1][2][3][4][5] .... List<Integer> arrayList = new ArrayList<Integer>(); LinkedLists consists of elements where each element has a reference to the previous and next element [0]->[1]->[2] .... <- <- 183 Rajeev Gupta
  • 184. ArrayList vs LinkedList Java implements ArrayList as array internally  Hence good to provide starting size  i.e. List<String> s=new ArrayList<String>(20); is better then List<String> s=new ArrayList<String>(20); Removing element from starting of arraylist is very slow?  list.remove(0);  if u remove first element, java internally copy all the element (shift by one)  Adding element at middle in ArrayList is very inefficient… 184 Rajeev Gupta
  • 185. Performance ArrayList vs LinkedList !!!185 Rajeev Gupta
  • 186. HashMap Key ---->Value declaring an hashmap  HashMap<Integer, String> map = new HashMap<Integer, String>(); populating values map.put(5, "Five"); map.put(8, "Eight"); map.put(6, "Six"); map.put(4, "Four"); map.put(2, "Two"); getting value  String text = map.get(6);  System.out.println(text); 186 Rajeev Gupta
  • 187. Looping through HashMapfor(Integer key: map.keySet()) { String value = map.get(key); System.out.println(key + ": " + value); } 187 Rajeev Gupta
  • 188.  LinkedHashMap  aka dll  key and value are in same order in which u hv inserted....... TreeMap  sort keys in natural order(what is natural order?)  for int  1,2,3..........  for string  "a","b".............  For user define key  Define sorting order using Comparable /Comparator 188 Rajeev Gupta
  • 189. set Don’t allow duplicate element 189 Rajeev Gupta
  • 190. Assignment190 Rajeev Gupta
  • 191. User define key in HashMap If you are using user define key in hashmap don’t forget to override hashcode for that class… otherwise you may not find that content again… Demo 191 Rajeev Gupta
  • 192. HashMap vs Hashtable Hashtable is threadsafe, slow as compared to HashMap Better to use HashMap Some more intresting difference  Hashtable give runtime exception if key is “null” while HashMap don’t 192 Rajeev Gupta
  • 193. Session-2 Java 5 Language Features II Generics Annotations 193 Rajeev Gupta
  • 194. Generics Before Java 1.5  List list=new ArrayList();  Can add anything in that list  Problem while retrieving Now Java 1.5 onward  List<String> list=new ArrayList<String>(); list.add(“foo”);//ok list.add(22);// compile time error  Generics provide type safety  Generics is compile time phenomena… 194 Rajeev Gupta
  • 195. Issues with Generics Try not to mix non Generics code and Generics code…we can have strange behaviour. 195 Rajeev Gupta
  • 196. Polymorphic behaviour196 Rajeev Gupta
  • 197. <? extends XXXXXX>197 Rajeev Gupta
  • 198. <? Super XXXXX>198 Rajeev Gupta
  • 199. Generic class199 Rajeev Gupta
  • 200. Generic method200 Rajeev Gupta
  • 201. Annotation @ magic !!! Annotations in Java is all about adding meta-data facility to the Java Elements. Like Classes, Interfaces or Enums, Annotations define a type in Java and they can be applied to several Java Elements. Tools which will read and interpret the Annotations will implement a lot of functionalities from the meta-information obtained. For example, they can ensure the consistency between classes, can check the validity of the paramters passed by the clients at run-time and can generate lot of base code for a project. 201 Rajeev Gupta
  • 202. Built-in Annotations in Java There are some pre-defined annotations available in the Java Programming language. They are,  Override  Deprecated  SuppressWarnings Demo user define annotation and its need… 202 Rajeev Gupta
  • 203. References:- Head first java SCJP katthy Google  Stackoverflow.com  …..  ….. 203 Rajeev Gupta