Some Salient Characteristics of Java

1. Some Salient Characteristics of Java • Java is platform independent: the same program can run on any correctly implemented Java system • Java is object-oriented: • Structured in terms of classes, which group data with operations on that data • Can construct new classes by extending existing ones • Java designed as • A core language plus • A rich collection of commonly available packages • Java can be embedded in Web pages

2. JRE & JDK • A Java distribution comes typically in two flavors, the Java Runtime Environment (JRE) and the Java Development Kit (JDK). • The Java runtime environment (JRE) consists of the JVM and the Java class libraries and contains the necessary functionality to start Java programs. • The JDK contains in addition the development tools necessary to create Java programs. The JDK consists therefore of a Java compiler, the Java virtual machine, and the Java class libraries.

3. JVM • JVM (Java virtual machine) • Is a software implementation of a computer that executes programs like a real machine. Is written specifically for a specific operating system. Java programs are compiled by the Java compiler into bytecode. The Java virtual machine interprets this bytecode and executes the Java program. • This gives Java the “write once run anywhere” nature. Appendix A: Introduction to Java

4. Java Processing and Execution • Begin with Java source code in text files: Model.java • A Java source code compiler produces Java byte code • Outputs one file per class: Model.class • A Java Virtual Machine loads and executes class files

5. Compiling and Executing a Java Program

6. Classloader & Classpath • ClassLoader • The Java ClassLoader is a crucial, but often overlooked, component of the Java run-time system. It is the class responsible for finding and loading class files at run time. Creating your own ClassLoader lets you customize the JVM in useful and interesting ways, allowing you to completely redefine how class files are brought into the system. • Classpath • The classpath defines where the Java compiler and Java runtime look for .class files to load. This instructions can be used in the Java program.For example if you want to use an external Java library you have to add this library to your classpath to use it in your program.

7. Garbage Collector • Garbage collector • The JVM automatically re-collects the memory which is not referred to by other objects. The java garbage collector checks all object references and find the objects which can be automatically released. • While the garbage collector releases the programmer from the need to explicitly manage memory the programmer still need to ensure that he does not keep unneeded object references otherwise the garbage collector cannot release the associated memory. Keeping unneeded object references are typically called memory leaks.

8. Package • Java groups classes into functional packages. • Packages are typically used to group classes into logical units. For example all graphical views of an application might be placed in the same package called com.appname.application.views • Other main reason for the usage of packages is to avoid name collisions of classes. A name collision occurs if two programmers give the same fully qualified name to a class. The fully qualified name of a class in Java consists out of the package name followed by a dot (.) and the class name. (package1.class1 ; package2.class1) • The import statement tells the compiler to make available classes and methods of another package • (See coding practices for naming)

9. Classes and Objects • The class is the unit of programming. The class can be seen as the blueprint of an object. It describes how an object is created. • A Java program is a collection of classes • Each class definition (usually) in its own .java file • The file name must match the class name • A class describes objects (instances) • Describes their common characteristics: is a blueprint • Thus all the instances have these same characteristics • These characteristics are: • Data fields for each object • Methods (operations) that do work on the objects

10. Inheritance • A class can be derived from another class. In this case this class is called a subclass. Another common phrase is that a class extends another class. • Inheritance is a mechanism in which one object acquires all the properties and behavior of another object of another class. • It represents the “IS A” relations • Multiple inheritance is not supported in Java.

11. Abstraction & Encapsulation • Abstraction is the process of hiding implementation details and showing only functionality. • Abstraction hides the implementation details, whereas encapsulation hides the data. • Abstraction lets you focus on what the object does rather than how it does it.

12. Abstract Class • A class that is declared as abstract is known as abstract class. • It needs to be extended and its method implemented. • It cannot be instantiated. publicabstractclass MyAbstractClass { abstractdouble returnDouble(); }

13. Abstract class vs Interface

14. Interface • Interface is a blueprint of a class that have static constants and abstract methods. • It can be used to achieve fully abstraction and multiple inheritance. publicinterface MyDefinition { // constant definition String URL="http://www.google.com"; // define several method stubs void test(); void write(String s); }

15. References and Primitive Data Types • Java distinguishes two kinds of entities • Primitive types • Objects • Primitive-type data is stored in primitive-type variables • Reference variables store the address of an object • No notion of “object (physically) in the stack” • No notion of “object (physically) within an object”

16. Primitive Data Types • Represent numbers, characters, boolean values • Integers: byte, short, int, and long • Real numbers: float and double • Characters: char

17. Operators • subscript [ ], call ( ), member access . • pre/post-increment ++ --, boolean complement !, bitwise complement ~, unary + -, type cast (type), object creation new • * / % • binary + - (+ also concatenates strings) • signed shift << >>, unsigned shift >>> • comparison < <= > >=, class test instanceof • equality comparison == != • bitwise and & • bitwise or | • logical (sequential) and && • logical (sequential) or || • conditional cond ? true-expr : false-expr • assignment =, compound assignment += -= *= /= <<= >>= >>>= &= |=

18. Declaring and Setting Variables • int square; square = n * n; • double cube = n * (double)square; • Can generally declare local variables where they are initialized • All variables get a safe initial value anyway (zero/null)

19. Referencing and Creating Objects • You can declare reference variables • They reference objects of specified types • Two reference variables can reference the same object • The new operator creates an instance of a class • A constructor executes when a new object is created • Example: String greeting = ″hello″;

20. Constructor • Constructor is just like a method that is use to initialize the state of an object. • It is invoked at the time of creation. • The return value is the current instance

21. Methods • A Java method defines a group of statements as performing a particular operation • static indicates a static or class method • A method that is not static is an instance method • All method arguments are call-by-value • Primitive type: value is passed to the method • Method may modify local copy but will not affect caller’s value • Object reference: address of objectis passed • Change to reference variable does not affect caller • But operations can affect the object, visible to caller

22. Method Overloading vs Method Overwriting • If a class has multiple methods by the same name but different parameters its called method Overloading. It increases the readibility of the program. • If a subclass provides a specific implementation of a method that is already provided by its parent class it is known as method overriding. It is used for runtime polymorphism.

23. Escape Sequences • An escape sequence is a sequence of two characters beginning with the character \ • A way to represents special characters/symbols

24. The String Class • The String class defines a data type that is used to store a sequence of characters • String is an immutable object • You cannot modify a String object • If you attempt to do so, Java will create a new object that contains the modified character sequence

25. The StringBuffer Class • Stores character sequences • Unlike a String object, you can change the contents of a StringBuffer object

26. StringTokenizer Class • We often need to process individual pieces, or tokens, of a String

27. Wrapper Classes for Primitive Types • Sometimes we need to process primitive-type data as objects • Java provides a set of classes called wrapper classes whose objects contain primitive-type values: Float, Double, Integer, Boolean, Character, etc.

28. Modifiers • Access modifiers • There are three access modifiers keywords available in Java. public, protected and private. • There are four access levels: public, protected, default and private. They define how the corresponding element is visible to other components. Table 1. Access Level

29. Static • Variables • Static variable is used to refer the common property of all objects (that is not unique for each object) • Static variables get memory only once in class area at the time of loading • Methods • Static methods belong to the class rather than the object of a class. • A static method can be invocked withouth a need to create na instance of the class. • Static methods can access static data and change their value

30. Final • Variable • You cannot change the value of final variables. • Method • Final methods cannot be overwritten (see previous slide) • Class • Final classes cannot be inherited.

31. Converting Numeric Strings to Numbers • A dialog window always returns a reference to a String • Therefore, a conversion is required, using static methods of class String:

32. Input/Output using Streams • An InputStream is a sequence of characters representing program input data • An OutputStream is a sequence of characters representing program output • The console keyboard stream is System.in • The console window is associated with System.out

33. Opening and Using Files: Reading Input import java.io.*; public static void main (String[] args) { // open an input stream (**exceptions!) BufferedReader rdr = new BufferedReader( new FileReader(args[0])); // read a line of input String line = rdr.readLine(); // see if at end of file if (line == null) { ... }

34. Opening and Using Files: Reading Input (2) // using input with StringTokenizer StringTokenizer sTok = new StringTokenizer (line); while (sTok.hasMoreElements()) { String token = sTok.nextToken(); ...; } // when done, always close a stream/reader rdr.close();

35. Alternate Ways to Split a String • Use the split method of String: String[] = s.split(“\\s”); // see class Pattern in java.util.regex • Use a StreamTokenizer (in java.io)

36. Opening and Using Files: Writing Output // open a print stream (**exceptions!) PrintStream ps = new PrintStream(args[0]); // ways to write output ps.print(“Hello”); // a string ps.print(i+3); // an integer ps.println(“ and goodbye.”); // with NL ps.printf(“%2d %12d%n”, i, 1<<i); // like C ps.format(“%2d %12d%n”, i, 1<<i); // same // closing output streams is very important! ps.close();

37. Exceptions • What are they? • An exception is a representation of an error condition or a situation that is not the expected result of a method. • Exceptions fall into two categories: • Checked Exceptions • Unchecked Exceptions • Checked exceptions are inherited from the core Java class Exception. They represent exceptions that are frequently considered “non fatal” to program execution • Checked exceptions must be handled in your code, or passed to parent classes for handling.

38. Exceptions (2) • Unchecked exceptions represent error conditions that are considered “fatal” to program execution. • You do not have to do anything with an unchecked exception. Your program will terminate with an appropriate error message. • To handle the exception, you write a “try-catch” block. To pass the exception “up the chain”, you declare a throws clause in your method or class declaration.

39. Coding Exceptions • Example • try {… normal program code}catch(Exception e) {… exception handling code}

40. Throw vs Throws

41. What is a Thread? • Individual and separate unit of execution that is part of a process • multiple threads can work together to accomplish a common goal • Video Game example • one thread for graphics • one thread for user interaction • one thread for networking

42. Advantages • easier to program • 1 thread per task • can provide better performance • thread only runs when needed • no polling to decide what to do • multiple threads can share resources • utilize multiple processors if available

43. Creating Threads (method 1) • extending the Thread class • must implement the run() method • thread ends when run() method finishes • call .start() to get the thread ready to run

44. Creating Threads Example 1 class Output extends Thread { private String toSay; public Output(String st) { toSay = st; } public void run() { try { for(;;) { System.out.println(toSay); sleep(1000); } } catch(InterruptedException e) { System.out.println(e); } } }

45. Example 1 (continued) class Program { public static void main(String [] args) { Output thr1 = new Output(“Hello”); Output thr2 = new Output(“There”); thr1.start(); thr2.start(); } } • main thread is just another thread (happens to start first) • main thread can end before the others do • any thread can spawn more threads

46. Creating Threads (method 2) • implementing Runnable interface • virtually identical to extending Thread class • must still define the run()method • setting up the threads is slightly different

47. Creating Threads Example 2 class Output implements Runnable { private String toSay; public Output(String st) { toSay = st; } public void run() { try { for(;;) { System.out.println(toSay); Thread.sleep(1000); } } catch(InterruptedException e) { System.out.println(e); } } }

48. Example 2 (continued) class Program { public static void main(String [] args) { Output out1 = new Output(“Hello”); Output out2 = new Output(“There”); Thread thr1 = new Thread(out1); Thread thr2 = new Thread(out2); thr1.start(); thr2.start(); } } • main is a bit more complex • everything else identical for the most part

49. Advantage of Using Runnable • remember - can only extend one class (no multiple extends) • implementing runnable allows class to extend something else

50. Controlling Java Threads • _.start(): begins a thread running • wait() and notify(): for synchronization • more on this later • _.stop(): kills a specific thread (deprecated) • _.suspend() and resume(): deprecated • _.join(): wait for specific thread to finish • _.setPriority(): 0 to 10 (MIN_PRIORITY to MAX_PRIORITY); 5 is default (NORM_PRIORITY)