Presentation Transcript

1. Java Written by Amir Kirsh, Edited by Liron Blecher

2. First things first • My Email: • [email protected] • Available 24x7 for anyquestions

3. First things first • About this course: • A lot of self learning • Time demanding homework • A lot of material • Very short time for each exercise

4. What you need to be

5. Java History • What can be done with Java? • Language Characteristics • The Java Environment • Java Editions • Hello World • Basic Syntax • Exceptions • Java API Agenda

6. Java History • Started as an internal project at Sun Microsystems in Dec-1990 • Main architect of the language - James Gosling • Initially designed for use in a set top box project and called OAK • Starting from Java 6 the source code of Java is released by Sun as open source under GNU GPL • Today Java progress is ruled by the Java Community Process (JCP) based on Java Specification Requests (JSRs)

7. Java History - Chronology • Dec-1990: Internal project at Sun (OAK, OS Green project) • May-1995: 1st Java public release as part of the HotJava browser • Jan-1996: JDK 1.0 • Feb-1997: JDK 1.1 (added inner classes, JDBC, …) • Dec-1998: J2SE 1.2 (added reflection, Swing, Collections utils) … • Sep-2004: J2SE 5.0 (added Generics, annotations, …) • Dec-2006: Java SE 6 (support in code compilation, scripting, …) • Jul-2011: Java SE 7 (String in Switch, Try with Resource, …) • Mar-2014: Java SE 8 (Next release… Lambdas expressions)

8. Java History • What can be done with Java? • Language Characteristics • The Java Environment • Java Editions • Hello World • Basic Syntax • Exceptions • Java API Agenda

9. What can be done with Java? • Simple Console Applications: Hello world, Utilities… • Desktop Applications: Swing, SWT, e.g. – Eclipse • Web Applets (less common today…) • Web Applications: Servlets, JSPs … • Server Side – DB connectivity, Client-Server, Networking, Web-Services … • Mobile Applications – J2ME, Android

10. When would Java not be our choice? • Real-Time applications (though Java is taking some steps in this direction) • Device Drivers – when you need access to devicememory and specific resources (C/C++ would be a choice) • When the device does not support Java Handsets which don’t have J2ME/Android old OS Java can still be layered on top of native code, using JNI or Inter-Process-Communication: • User Interface above a Device Driver or other native code • Management of the Real-Time part of an application

11. Java History • What can be done with Java? • Language Characteristics • The Java Environment • Java Editions • Hello World • Basic Syntax • Exceptions • Java API Agenda

12. Language Characteristics Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language. "The Java Language: An Overview"http://www.oracle.com/us/technologies/java/features/index.html

13. Language Characteristics Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language. • Based on C++ but without some complicated or annoying elements of C++ (e.g. pointers, operator overloading, header files) • Automatic Garbage Collection! • Useful libraries that are part of the language

14. Language Characteristics Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language. • Inheritance and Polymorphism • Object class is base for all classes • No global variables or functions!

15. Language Characteristics Java: A simple, object-oriented,network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language. • Local and remote files are treated similarly • Supports distributed applications • Rich libraries for network operations

16. Language Characteristics Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language. • Java code is compiled to intermediate language (Java byte-code class file) and is interpreted in Runtime by the Java Virtual Machine • No need to Link the application, linking is always done dynamically at Runtime • JIT (just-in-time) JVMs make the interpretation efficient

17. Language Characteristics Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language. The language is much more robust compared to C++ • No pointers, arrays bounds and variable initialization are checked: it is almost impossible to corrupt memory • Garbage Collection: harder (though possible) to create memory leaks • Strict type safety: very limited casting allowed

18. Language Characteristics Java: A simple, object-oriented, network-savvy, interpreted, robust,secure, architecture neutral, portable, high-performance, multithreaded, dynamic language. • The byte-code is checked by the JVM before execution for any unsafe or vulnerable operations • Code cannot access memory directly • Additional security restrictions for code that comes from the network (e.g. Applets)

19. Language Characteristics Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language. • The code is agnostic to the physical architecture due to the JVM layer • Code can be written and compiled on one environment and then executed on another one!

20. Language Characteristics Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language. • The language clearly defines issues that in other languages are left open: exact binary form of each data type, thread behavior, GUI behavior, etc. • The JVM implementation takes care of the differences between the different environments

21. Language Characteristics Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable,high-performance, multithreaded, dynamic language. • Java is much more efficient than other interpreted languages • Java applications are of “similar” order of performanceas C/C++, based on sophisticated JVM optimizations

22. Language Characteristics Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language. • Multithreading and thread synchronization are part of the language • As with anything else, same multithreading API for all Operating Systems

23. Language Characteristics Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded,dynamic language. • The application can load classes after it has started • Since linking is done in Runtime adding new stuff to existing classes doesn’t break any binaries using it • Reflection (though added after the above was stated) • Can compile code in Runtime and use it (again, added after the above was stated – but what the hell…)

24. Language Characteristics Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, dynamic language. Sounds Good!

25. Java History • What can be done with Java? • Language Characteristics • The Java Environment • Java Editions • Hello World • Basic Syntax • Exceptions • Java API Agenda

26. The Java Environment Java byte-code (Binary files with“.class” suffix) Java Program (Text files with“.java” suffix) Java Compiler javac [<params>] <java files> - Compile time classpath + required jars Run your program java [<params>] <app Main class> - Runtime classpath + required jars JRE (JVM + libs) JDK

27. The Java Environment – Terms JDK = Java Development Kit JRE = Java Runtime Environment JVM = Java Virtual Machine (part of the JRE) GC = Garbage Collector (part of the JVM) JSE = Java Standard Edition (the “basic Java” / “pure java”) JEE = Java Enterprise Edition (some more classes…) Java API = The Java Application Programming Interface Classpath = Where to look for classes (we’ll talk about it) JAR = a file packaging many classestogether IDE = Integrated Development Environment(not a must, one can use notepad or vi – but we will use Netbeans)

28. The Java Environment – JVM Usage: java [-options] class [args...] (to execute a class) or: java [-options] -jar jarfile [args...] (to execute a jar file) where options include: -client to select the "client" VM -server to select the "server" VM … -cp <class search path of directories and zip/jar files> -classpath <class search path of directories and zip/jar files> A ; separated list of directories, JAR archives, and ZIP archives to search for class files. -D<name>=<value> set a system property … -? -help print this help message … -Xms<size> set initial Java heap size -Xmx<size> set maximum Java heap size -Xss<size> set java thread stack size -Xprof output cpu profiling data …

29. The Java Environment – GC • Why GC? • Saves the need to deallocate memory explicitly, freeing the developer from explicit heap handling • Eliminates the possibility of: • Memory Leaks(well, in fact there can be Leaks, or "Loiterers", also with GC) • Releasing memory that is in use (creating a "dangling pointer") • Use of memory that was released or has not been allocated •  Increases productivity while making applications robust

30. The Java Environment – GC • GC History • Invented by John McCarthy around 1959 for Lisp • Integral part of many other programming languages • Smalltalk, Eiffel, Haskell, ML, Scheme, Modula-3, VB, C# and almost all of the scripting languages (Perl, Python, Ruby, PHP) • Trends in hardware and software made garbage collection far more practical: • Empirical studies in the 1970s and 1980s show garbage collection consuming between 25 percent and 40 percent of the runtime in large Lisp programs

31. The Java Environment – GC • GC Roles • Detect unused memory and free it • Manage the heap to allow fast allocations • Compact the heap • Manage a "list" of free spots and their sizes

32. The Java Environment – GC • GC Tracing Techniques • Reference Counting • Problems: cyclic references, sync-lock costs • Never used by Java GC, not used by modern GCs • Trace by reachability • Objects should be kept alive if they are reachable from: • Static references • References on Stack • References from reachable objects on heap • Use of hints and tricks! • http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)

33. The Java Environment – GC Java Objects in Memory: Source: micheltriana

34. The Java Environment – GC Java GC Generations

35. The Java Environment – GC Everything you need to know about GC in Java: http://www.javacodegeeks.com/2013/07/java-garbage-collection-distilled.html

36. Java History • What can be done with Java? • Language Characteristics • The Java Environment • Java Editions • Hello World • Basic Syntax • Exceptions • Java API Agenda

37. Java Editions • Java SE (Standard Edition) • Used for Desktop Application, DB, Core Servers, Networking and more • Includes the JVM and standard libraries • Java EE (Enterprise Edition) • Used for Enterprise Servers • Includes everything that is in Java SE and additional libraries for Web Servers, Distributed Computing, Enterprise Security, and more • Java ME (Mobile Edition) • A subset of Java SE (does not include all of its libraries and capabilities) • Android (well, not exactly…) • Android implements its own JVM called Dalvik

38. Java History • What can be done with Java? • Language Characteristics • The Java Environment • Java Editions • Hello World • Basic Syntax • Exceptions • Java API Agenda

39. Hello World public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World"); } } Method return value is similar to C.In this case void– means that the method does not return a value

40. main gets array of strings from the command line main in Java is a static method inside a class Each type in the class should declare its access modifier String[] means array of String objects String is a class defined in the Java language itself No “;” at end of class println is a method of the static field “out” inside System class Hello World public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World"); } }

41. Hello World – Compile and Run • Open cmd window (Start -> Run -> cmd) • Run: • javac HelloWorld.java • javac should be in your pathif it is not, add the “/bin” directory of your java installation to the path • Run: • java HelloWorld • Result should be: • Hello World

42. examples.helloworld.HelloWorld demo

43. Java History • What can be done with Java? • Language Characteristics • The Java Environment • Java Editions • Hello World • Basic Syntax • Exceptions • Java API Agenda

44. Java Syntax Java Syntax is very similar to C++. In the following slides we will cover both theJava things that are similar to C++ as well as things that do not appear in C++ or work differently.

45. Data Types For numbers that require exact accuracy use java.math.BigDecimal

46. Primitive Variables Primitive variables are variables of primitive types (i.e. not objects) – they pass By Value Example: int i = 3; foo(i); System.out.println(i); // prints 3 void foo(int i) { i = 5; } The original “i” is NOT changed!

47. Objects and References Object variables in Java are ALWAYSa reference to an instance Example: void someMethod(Person p) { p.setName("Momo"); } The original person sent to this method is modified (In case p is null we will get an Exception – we will talk about this later)

48. Objects and References Object variables MUST be initialized or otherwise they are:– uninitialized in case of local variables– null in case of a field Example 1: void someMethod() { Person p; p.setName("Koko"); } The above will not compile (compilation error: variable ‘p’ might not have been initialized)

49. Well, in fact it’s a null reference Objects and References Object variables MUST be initialized or otherwise they are:– uninitialized in case of local variables– null in case of a field Example 2: class Foo { Person p; // field p is initialized to null void someMethod() { p.setName("Annul"); } } NullPointerException thrown at runtime

50. Objects and References To create an instance of an objectyou should use ‘new’ Example: Person p = new Person("Noa"); // use Person c’tor System.out.println(p.getName()); The person ‘p’ references is created on the heap (You shouldn’t worry about the deallocation!) We will talk about “constructors” (== c’tors) later

Load More ...