Table of Contents Fast Track to Java 8 EVALUATIONA COPY

Size: px

Start display at page:

Download "Table of Contents Fast Track to Java 8 EVALUATIONA COPY"

Allyson Parsons
6 years ago
Views:

1 Table of Contents Fast Track to Java 8 Fast Track to Java 8 and OO Development 1 Course Overview 2 Course Objectives 3 Course Objectives 4 Labs 5 Typographic Conventions 6 Course Outline 7 Session 1 - A Simple Java Class and Running a Java Program 8 Session Objectives 9 A Simple Application Class 10 The HelloWorld Program Broken Down 11 Compiling HelloWorld 12 Note on Comments 13 Lab HelloWorld 14 Review Questions 15 Lesson Summary 16 Session 2 - Java Overview 17 Session Objectives 18 Language and Platform Features 19 What is Java? 20 Java is Modern and Object-Oriented 21 Java is Portable and Safe 22 Java has Multiple Platforms 23 Program Life Cycle 24 Java Source and Java Bytecode 25 Life Cycle of a Java Program 26 Java Programs Insulated From Environment 27 Java is Dynamic - The Runtime Process 28 The Java SE Development Kit (JDK) 29 Java Development Kit (JDK) 30 The Java API 31 Downloading and Installing the JDK 32 Lab 2.1 The Development Environment 33 Review Questions 34 Lesson Summary 35 Session 3 Class and Object Basics 36 Session Objectives 37 Object-Oriented Programming Overview 38 What is Object-Oriented Programming? 39 What is an Object? 40 Important Characteristics of Objects 41 About Object-Oriented Programming (OOP) 42 What's a Type? 43 Types, Instances, and Property Values 44 Classes and Objects 45 Lab Exploring Types 46 Identity and Object References Copyright LearningPatterns Inc. All rights reserved i

2 Lab Identity and Object References 48 Classes, References, and Instantiation 49 The Class in Java 50 Class Definition 51 A Class Definition is a Blueprint 52 Creating and Referencing Objects 53 More About Identifiers 54 Methods and Data in a Class 55 Behavior and Methods 56 Invoking Methods 57 Storing Data in Objects 58 About Instance Variables 59 Data Access and Return Values in Methods 60 Data Access and Return Values in Methods 61 Accessing Data (Another Way) 62 Pretty Pictures 63 More About Variables 64 About Java Primitive Data Types 65 Numeric Literals 66 Non-Numeric Literals 67 Strings 68 Primitive Types are Value Types 69 Arithmetic Operations 70 Primitive Type Conversion and Casting 71 Lab Writing a Class Definition 72 Review Questions 73 Lesson Summary 74 Session 4 More on Classes and Objects 75 Session Objectives 76 Working With Methods and Data 77 Working Within Methods 78 Calling Methods 79 Local Variables 80 The this Variable and Instance Data 81 Pretty Pictures 82 Overloading Methods 83 Calling Overloaded Methods 84 The tostring() Method 85 Encapsulation and Access Control 86 Encapsulation: Black Boxes 87 Encapsulation 88 Encapsulation 89 Key Advantages of Encapsulation 90 Program Correctness 91 Access Control 92 Access for Data Members and Methods 93 Private Access 94 Public Access 95 Lab Encapsulation 96 Constructors 97 Constructors 98 Using Constructors Copyright LearningPatterns Inc. All rights reserved ii

3 Explicit Constructor Call 100 Lab Adding Constructors to a Class 101 static or Class Members 102 Static Data Members and Methods 103 Declaring Static Members 104 Accessing Static Members 105 Accessing Data in Static Methods 106 final Variables 107 Lab Using static Members (OPTIONAL LAB) 108 Type-Safe Enums 109 Enumerated Types Defined 110 Problems with int Enumerated Types 111 enum Types 112 More enum Examples 113 enum Features 114 switch on enum 115 for-each with enum 116 Advanced enum Features 117 Lab Thinking About enums (Discussion-Only Lab) 118 Other Language Details 119 Scopes and Blocks 120 Scope Example 121 Assignment 122 Comparison 123 Null Objects 124 Wrapper Classes 125 Reference Types as Method Parameters 126 Reference Types as Method Parameters 127 final Method Parameters 128 Lab Debugging 129 Review Questions 130 Lesson Summary 131 Lesson Summary 132 Session 5 - Flow of Control 133 Session Objectives 134 Branching Statements 135 Program Execution Sequence in Java 136 The Comparison Operators 137 The Logical Operators 138 if-else Statement 139 switch Statement 140 Iteration Statements 141 while Statement 142 do-while Statement 143 for Statement 144 break Statement 145 continue Statement 146 Lab Data Validation 147 Review Questions 148 Lesson Summary 149 Session 6 - Strings and Arrays Copyright LearningPatterns Inc. All rights reserved iii

4 Session Objectives 151 String and StringBuffer/StringBuilder 152 Using Strings 153 Changing Strings 154 Classes StringBuffer and StringBuilder 155 StringBuffer and StringBuilder 156 Regular Expressions 157 Arrays 158 Arrays 159 Arrays 160 Creating Arrays and Accessing Elements 161 Arrays of Object References 162 Array of Strings 163 args Array 164 Iterating Over Arrays 165 varargs 166 Lab Arrays 167 Review Questions 168 Lesson Summary 169 Session 7 - Packages 170 Session Objectives 171 Packages Overview 172 Dealing with Complexity 173 Packages 174 package Statement 175 The Default (or Unnamed) Package 176 import Statement 177 The import Statement 178 Importing a Complete Package 179 Importing a Single Package Member 180 Using the Fully Qualified Name 181 Standard Imports 182 Resolving Naming Conflicts 183 Creating Packages 184 Creating a Package 185 Access Control for Class Members 186 Access Control for Classes 187 Summary - Using Packages 188 Finding Classes 189 Tools Must Locate Class Definitions 190 Organizing Files and Packages 191 Class Path 192 Classpath Example 193 Classpath Example 194 What is a JAR? 195 Classpath Example 196 Lab Packages 197 Review Questions 198 Lesson Summary 199 Session 8 - Composition and Inheritance Copyright LearningPatterns Inc. All rights reserved iv

5 Session Objectives 201 Composition 202 Dealing With Complexity and Composition 203 Composition 204 Delegation 205 Benefits of Composition 206 Issues with Composition 207 About Object Relationships 208 Other Kinds of Relationships 209 Lab Composition (Optional) 210 Inheritance 211 Inheritance and Dealing With Complexity 212 Inheritance Hierarchy 213 The extends Keyword 214 Inheriting from the Superclass 215 Inheritance and Superclass Data Members 216 A Subclass IS-A Superclass 217 Accessing Superclass Members 218 Constructors and Inheritance 219 Final Classes 220 Lab Inheritance 221 Overriding and Polymorphism 222 Changing Behavior with Method Overriding 223 OO Concepts - Polymorphism 224 Polymorphism 225 Importance of Polymorphism 226 The super Keyword 227 Access Control - protected Access 228 Access Control - protected Access 230 Lab Polymorphism 231 class Object 232 Class Object 233 Methods of Class Object 234 Automatic Storage Management 235 Abstract Classes 236 Abstract Classes 237 Abstract Methods 238 Using Abstract Classes 239 Review Questions 240 Lesson Summary 241 Session 9 - Interfaces 242 Session Objectives 243 Interface Basics 244 What if All You Have to Share is an Idea 245 Interface Types 246 Interface Definitions 247 The implements Keyword 248 Example of Using Interface Types 249 Interface Types - Revisited 250 Interface Types - Revisited Copyright LearningPatterns Inc. All rights reserved v

6 Extending Interfaces 252 Implementing Extended Interfaces 253 Example of Using Interface Types 254 Example of Using Interface Types 255 Example of Using Interface Types 256 Interfaces are Abstract 257 Data Members in Interfaces 258 Implementing Multiple Interfaces 259 Lab Interfaces 260 Default Methods and static Methods 261 Default Methods in Interfaces (Java 8+) 262 Using Default Methods 263 Uses of Default Methods 264 Static Methods in Interfaces (Java 8+) 265 Lab 9.2: Default Method 266 Review Questions 267 Lesson Summary 268 Session 10 - Exceptions 269 Session Objectives 270 Exception Hierarchy 271 Overview of Exceptions 272 Exception Hierarchy 273 Exception Hierarchy 274 Exception, Error, RuntimeException 275 Handling Exceptions try and catch 276 Handling Exceptions with try and catch 277 Exceptions and Program Flow 278 Variable Scope 279 The throws Clause 280 Throwing Exceptions with throw 281 User-Defined Exceptions 282 User-Defined Exceptions 283 Multiple catch Blocks 284 Multiple catch Blocks 285 finally Block 286 Runtime Exceptions 287 Multicatch (Java 7) 288 Using try-with-resources (Java 7) 289 Lab Using Exceptions 290 Review Questions 291 Lesson Summary 292 Lesson Summary 293 Session 11 - Collections and Generics 294 Session Objectives 295 Overview 296 Java Collections Framework Overview 297 java.util Collection Interfaces 298 Collection Interface 299 Generics and Type-Safe Collections 300 List and ArrayList 301 List Interface Copyright LearningPatterns Inc. All rights reserved vi

7 ArrayList 303 Using ArrayList - Example 304 The for-each Construct 305 Autoboxing and Collections of Object 306 Autoboxing 307 Using Autoboxing/Unboxing - Example 308 Summarizing Collection Features 309 Collections of Object 310 Issues with Collection of Object 311 Lab Using Collections 312 Other Collection Types 313 Set Interface 314 Using Sets 315 Map Interface 316 HashMap 317 Generic HashMaps 318 Creating and Using HashMap 319 Iterating Through a HashMap 320 Lab Using Sets 321 Iterator 322 Processing Items with an Iterator 323 Iterator Interface 324 Using Iterator - Example 325 [Optional] More About Generics 326 What Are Generics 327 Declaring a Generic Class 328 Summary - Basic Generics Usage 329 Using Generics - Example 330 Inheritance with Generic Types 331 Inheritance with Generic Types 332 Assignment with Generic Types 333 Wildcard Parameter Types 334 Generic Methods 335 [Optional] The Collections Class 336 Collections Class 337 Unmodifiable Wrappers 338 Unmodifiable Example 339 Checked Interface Example 340 Algorithms 341 Sort Example 342 Review Questions 343 Lesson Summary 344 Lesson Summary 345 Session 12 - Database Access with JDBC and JPA 346 Session Objectives 347 JDBC Overview 348 What is JDBC? 349 JDBC Architecture 350 The Fundamental JDBC API 351 Common JDBC Types 352 Naming Databases with URLs Copyright LearningPatterns Inc. All rights reserved vii

8 The Item Database Table 354 Database Connection - Example 355 Using Statement - Example 356 Using PreparedStatement - Example 357 Summary 358 JPA Overview 359 Java Persistence API (JPA) Overview 360 JPA Architecture High Level View 361 JPA Architecture Programming View 362 Working with JPA 363 Entity Classes 364 MusicItem Entity Class 365 Annotation Overview 366 Additional MusicItem Annotations 367 Lab Mapping an Entity Class 368 The Persistence Unit 369 persistence.xml Structure 370 The EntityManager 371 JPA EM and EMF Example 372 Working with Transactions 373 Complete JPA Example 374 Summary 375 Lab Using JPA 376 Persisting a New Entity 377 Updating a Persistent Instance 378 Removing an Instance 379 Executing a Query 380 Lab Insert/Query Demo 381 Review Questions 382 Lesson Summary 383 Lesson Summary 384 Session 13 - Additional Language Features 385 Session Objectives 386 Assertions 387 Assertions Defined 388 Assertion Uses 389 Assertion Non-Uses 390 Assertion Syntax 391 Using Assertions to Check State - Example 392 Using Assertions to Check Flow of Control 393 Enabling/Disabling Assertions at Runtime 394 Enabling/Disabling Assertions - Examples 395 What They Look Like at Runtime 396 Annotations 397 The Issue 398 Annotations - The Solution 399 Example Applications 400 Lambda Expressions (Java 8) 401 Motivation: Common Actions are Verbose 402 Solution: Lambda Expressions 403 Functional Interface 404 Lambda Expressions 405 How Lambda Expressions Work Copyright LearningPatterns Inc. All rights reserved viii

9 Lambda Expression Syntax 407 Summary 408 Other Java Features 409 XML and Web Service Support 410 Java DB 411 Scripting Language Integration 412 Monitoring and Management Tools 413 Other Features 414 Session 14 - I/O Streams (Optional) 415 Session Objectives 416 Readers and Writers 417 Overview of I/O Streams 418 Character Streams 419 Class Reader 420 Class Writer 421 Common Reader Subclasses 422 Common Writer Subclasses 423 Using Readers and Writers 424 Using Readers and Writers - Example 425 Path Separators 426 High-Level (Filtering) Streams 427 BufferedReader - Filtering Stream Example 428 Converting between Streams and Readers/Writers 429 Byte Stream Classes 430 Common Stream Subclasses 431 Converting Between Byte & Character Streams 432 Converting Between Byte & Character Streams 433 Character Stream & Byte Stream Equivalents 434 Formatted Output 435 Formatted Output 436 Integer Format Specifiers 437 Format Specifier Modifiers 438 Format Specifier Modifiers Example 439 Other Format Specifiers 440 Summary 441 New I/O (NIO) APIs 442 New I/O (NIO) 443 NIO Features 444 NIO Features 445 [Optional] Lab Formatted Output 446 Review Questions 447 Lesson Summary 448 Recap 449 What We've Learned 450 Resources 451 Appendix - JDBC Java Database Connectivity 452 Session Objectives 453 JDBC Overview 454 Relational Database Description 455 Web-Based Data Access Architecture Copyright LearningPatterns Inc. All rights reserved ix

10 What is JDBC? 457 JDBC Characteristics 458 JDBC Specification and Packages 459 JDBC Architecture and API 460 JDBC Architecture 461 The Fundamental JDBC API 462 The DriverManager Class 463 What is a JDBC Driver? 464 Naming Databases with URLs 465 JDBC URL Syntax 466 Database Connections 467 Database Connections 468 Establishing a Database Connection 469 Using try-with-resources 470 Closing the Connection 471 Issuing Statements and Processing Data 472 Creating Statements 473 The Statement Interface 474 Using Statement - Example 475 The ResultSet Interface 476 Extracting Data from a ResultSet 477 SQL -> Java Type Mappings 478 Extracting Data from a ResultSet - Example 479 Prepared Statements 480 Using PreparedStatement - Example Copyright LearningPatterns Inc. All rights reserved x

12 Introduction Course Overview An introductory Java course that starts with basic principles Provides a solid foundation in the concepts and practices for writing good object-oriented systems in Java Provides knowledge needed to productively use core Java technology for programming Including database access with JDBC/JPA Be prepared to work hard and learn a great deal! The course contains numerous hands-on labs They exercise all the important concepts discussed The lab solutions for the course are provided to you The course covers all core features of Java It supports all recent versions of Java Copyright LearningPatterns Inc. All rights reserved 2

13 Introduction Course Objectives Learn Java's architecture and uses Understand Java language basics Compile and execute Java programs with development tools such as javac and java Learn object-oriented (OO) programming and the object model Understand the differences between traditional programming and object-oriented programming Understand important OO principles such as composition inheritance and polymorphism Use Java packages to organize code Understand interfaces, their importance, and their uses Copyright LearningPatterns Inc. All rights reserved 3

14 Introduction Course Objectives Learn (and practice!) Java naming conventions and good Java coding style Create well-structured Java programs Use core Java API class libraries Understand how exceptions are used for error handling Understand the basics of database access with JDBC and JPA Learn the basics of the Collections Framework See some of the new/advanced Java language features, including Java 8 lambda expressions Understand and use basic I/O streams (optional) Copyright LearningPatterns Inc. All rights reserved 4

15 Introduction Labs Lab The workshop has numerous hands-on lab exercises, structured as a series of brief labs The detailed lab instructions are separate from the main student manual Setup zip files are provided with skeleton code for the labs Students add code focused on the topic they're working with There is a solution zip with completed lab code Lab slides have an icon like in the upper right corner of this slide The end of a lab is marked with a stop like this one: STOP Copyright LearningPatterns Inc. All rights reserved 5

16 Introduction Typographic Conventions Code in the text uses a fixed-width code font, e.g.: JavaInstructor teacher = new JavaInstructor() Code fragments use the same font, e.g. teacher.teach() We bold/color text for emphasis Filenames are in italics, e.g. JavaInstructor.java We sometimes denote more info in the notes with a star * Longer code examples appear in a separate code box - e.g. package com.javatunes.teach; public class JavaInstructor implements Teacher { public void teach() { System.out.println("Java is way cool"); } } Copyright LearningPatterns Inc. All rights reserved 6

19 Session 1: A Simple Java Class & Program Session Objectives Look at a simple Java program, and how it is compiled and run Set your computer up for Java development Setting paths, environment variables, etc. Use a text editor to type in a simple Java class Use the Java Development Kit to compile and run the code Copyright LearningPatterns Inc. All rights reserved 9

20 Session 1: A Simple Java Class & Program A Simple Application Class To get started, we'll look at a very simple Java application, that displays the string "Hello World" This is a simple non-graphic standalone application that runs on its own All programs in Java are just a class with a main method in it The HelloWorld class needs to appear in a file HelloWorld.java The main method is a special method that is the starting point for every Java application It must be declared as shown, and has to appear in a class System.out.println is one way to print things to the console public class HelloWorld { public static void main(string[] args) { System.out.println("Hello World"); } } Java classes can be deployed into several runtime execution environments, including: Standalone applications that are run explicitly, like our Hello World application. Servlets, which are run in a Web server. Applets, which are downloaded from a Web server and run in a Web browser. We will concentrate on applications in this course. main is the special method which is the starting point for every standalone Java application. Applets and servlets work a little differently The main method has to appear inside a class. main takes an argument an array of Strings. This array holds arguments that are given on the command line when the application is run. System.out.println causes something to be printed to System.out, which is the standard output (the console ) more on this later. Copyright LearningPatterns Inc. All rights reserved 10

21 Session 1: A Simple Java Class & Program The HelloWorld Program Broken Down We'll cover these details in more depth later Class definition Block Comment // a simple application to display "Hello World" public class HelloWorld { public static void main(string[] args) { System.out.println("Hello World"); } } Method definition Semicolon Method call Method argument Copyright LearningPatterns Inc. All rights reserved 11

22 Session 1: A Simple Java Class & Program Compiling HelloWorld To use a Java class, you have to compile the Java code using javac (the Java compiler) C:\StudentWork>javac HelloWorld.java After compiling, a file called HelloWorld.class (containing Java bytecode) is created You use the Java Virtual Machine (JVM), to run a Java program The JVM comes with Java as the java executable C:\StudentWork>java HelloWorld This would produce the output "Hello World" printed in your command prompt window HelloWorld.class is the bytecode for the program produced by the compiler We will talk more about all these details later in the course For now, we're giving you enough information to just run the program Copyright LearningPatterns Inc. All rights reserved 12

23 Session 1: A Simple Java Class & Program Note on Comments Java has 3 kinds of comments Single line comment: Start with // Multiple lines using /* */ Javadoc comments (see note) using /** */ /** * This class prints "Hello World" to standard output */ class HelloWorld { // this comment starts mid-line public static void main(string[] args) { System.out.println("Hello World"); // we often comment out a line code this way // System.out.println("Bye"); } } /* Note that this class still needs a lot of work. We need to add all sorts of interesting things, and show how cool Java has become. */ Comments are text that is ignored by the Java compiler Comments can start anywhere on a line Javadoc comments are used in generating API documentation directly from the source code These comments precede the items that they are documenting in the code A tool called javadoc reads these comments Along with your source code javadoc also understands a number of parameters that you can embed in these comments to enhance the generated documentation We cover this tool in an appendix Copyright LearningPatterns Inc. All rights reserved 13

25 Session 1: A Simple Java Class & Program Review Questions 1. What is the purpose of the main method? 2. How do you print something to standard output (the console)? 3. What tool do you use to compile Java source code? 4. What tool do you use to run compiled Java code? Copyright LearningPatterns Inc. All rights reserved 15

26 Session 1: A Simple Java Class & Program Lesson Summary The main() method is the entry point for all Java programs It appears in a Java class definition System.out.println() is one simple way to print to the console It is part of the standard Java libraries Java source code is created in file with a.java extension It is compiled with the javac program Compiled programs are run with the java program The Java virtual machine, or JVM Copyright LearningPatterns Inc. All rights reserved 16

28 Session 2: Java Overview Session Objectives Discuss the advantages of programming in Java Understand how Java is both a language and a platform List the major target environments that Java addresses and which Java platform is used for each Define portability and explain how Java achieves this Explain the Java program development and runtime lifecycle Explain what the JDK is and list some of its tools and their uses Copyright LearningPatterns Inc. All rights reserved 18

30 Session 2: Java Overview What is Java? Java is a programming language A strongly typed, object-oriented, general purpose programming language Java is a runtime system The Java virtual machine (JVM) translates Java bytecode (output from the compiler) to native operating system code at runtime Java is a platform JRE, the Java Runtime Environment, contains the JVM + other runtime facilities A JVM is available for every operating system Usually, the JVM is provided by the operating system vendor The Java API, consisting of many built-in classes that come with Java e.g., String and System Sun Microsystems (acquired by Oracle) was Java's inventor, but there are many companies now involved in the development of Java specifications and technologies. Most database, application server, and operating system vendors are heavily involved in Java. There are also several vendors developing IDEs and other tools to help with Java development, deployment, debugging, profiling, etc. These companies collaborate with Sun through something called the Java Community Process. Copyright LearningPatterns Inc. All rights reserved 20

31 Session 2: Java Overview Java is Modern and Object-Oriented Many important modern features are built into Java Networking, multithreading, database access, exceptions, internationalization, security, data structures, GUI, and more Java is Object-Oriented Object-Oriented Programming is a way of thinking about and modeling systems OO programming creates types which model the real world These types form an abstract blueprint of what you're modeling in your system e.g., Customer, Employee, PurchaseOrder, ShoppingCart, etc. They have both properties (data) and methods (behavior) Deciding on the types in your system is one of the first steps in modeling it The Java language itself remains relatively small these features comes as the core Java API, a set of thousands of classes that have been designed with reuse in mind Instead of a large body of keywords and syntax to learn OO Programming is a methodology or paradigm that is still evolving within the field of software engineering An approach that has a proven track record Copyright LearningPatterns Inc. All rights reserved 21

32 Session 2: Java Overview Java is Portable and Safe Java programs are platform independent Java is compiled to bytecode that is the same across platforms Bytecode is checked for validity, compiled to native code, and executed in the Java virtual machine at runtime At runtime, Java code becomes Windows code, UNIX code, etc. As long as there is a Java virtual machine, the code will run Java eliminates error prone features e.g., pointer arithmetic and "go to" statements Java helps you develop reliable software Automatic memory management (garbage collection) helps prevent memory leaks, no raw arithmetic on memory pointers, automatic array bounds checking, compiler-checked exceptions The Java Virtual Machine (JVM) can be invoked explicitly to run a Java application, or it may be invoked implicitly by another application such as a Web server to run servlets or a Web browser to run applets. It is mostly true that Java code can be run, virtually unchanged, on any machine that has a JVM. Hence the "Write once, run anywhere" slogan. Java is consistent across all implementations the Java Language Spec alone defines the language System administrators can keep one copy of code in one place, and it will run on all platforms However, Java code should still be tested in the target environments in which it is expected to run Java also has a very large, standard API of pretested, reusable code This helps you find developers who know the platform, and makes it easier to build systems with it Copyright LearningPatterns Inc. All rights reserved 22

Session 2: Java Overview Java has Multiple Platforms (1) Java SE Embedded and Java 8 compact profiles define subsets of the full Java SE API These can run in smaller environments than the full Java

Android programs are compiled into Dalvik executables (not bytecode) Dalvik is a VM written specifically for the Android platform, and works differently in a number of areas The details of Android,

33 Session 2: Java Overview Java has Multiple Platforms (1) Java SE Embedded and Java 8 compact profiles define subsets of the full Java SE API These can run in smaller environments than the full Java SE environment They still require more resources than a Java ME environment (2) Android, while written in Java, actually uses a slightly different architecture It does not use the standard JVM Android programs are compiled into Dalvik executables (not bytecode) Dalvik is a VM written specifically for the Android platform, and works differently in a number of areas The details of Android, Java ME, and Java SE Embedded/compact are beyond the scope of this course The name of the Java distribution has changed over many releases - mostly for marketing reasons Java 1.x release used the term JDK (JDK 1.0, 1.1) Release 1.2 introduced the term Java 2 (Java 2 Release 1.2, Java 2 Release 1.3, Java 2 Release 1.4) The release after Java 2 Release 1.4 used the term Java 5 (really just release 1.5 renamed) The next releases built on that - Java 6, Java 7, and Java 8 Copyright LearningPatterns Inc. All rights reserved 23

35 Session 2: Java Overview Java Source and Java Bytecode You write a program in the Java programming language And store it in a.java file, for example MyClass.java It is compiled into an intermediate language called Java bytecode Stored in a.class file, for example MyClass.class These are platform independent codes that are interpreted by an interpreter, the Java Virtual Machine, or JVM You can think of bytecode as the native instructions for the JVM Bytecode helps make "write once run anywhere" possible The JVM converts the bytecode into the native code for the target machine it is running on It then runs the program Copyright LearningPatterns Inc. All rights reserved 25

36 Session 2: Java Overview Life Cycle of a Java Program Java Source Code HelloWorld.java public class HelloWorld { } Java Compiler javac Java Bytecode HelloWorld.class 0 aload_0 1 invokespecial #3 4 aload_0 5 aload_1 UNIX JVM java Windows JVM java Solaris JVM java MVS JVM java Mac OS JVM java UNIX Native code Windows Native code Solaris Native code MVS Native code Mac OS Native code The JVMs for many platforms are available as standard distributions from Oracle JVMs for other platforms are available from their vendors, as well as from open-source initiatives like OpenJDK Copyright LearningPatterns Inc. All rights reserved 26

37 Session 2: Java Overview Java Programs Insulated From Environment Java provides a platform that programs can run on independently of the environment It is a software only platform made up of the Java API and the JVM SomeProgram.java Java API Java Virtual Machine Native Platform Copyright LearningPatterns Inc. All rights reserved 27

38 Session 2: Java Overview Java is Dynamic - The Runtime Process Several phases take place at runtime Java Bytecode HelloWorld.class Java Class Loader java Includes symbolic reference information from the compiler Loads bytecode into memory Java Verifier java Java Interpreter java Confirms that bytecodes are valid and follow security rules Translates bytecode into native code and performs final name resolution (linking) Copyright LearningPatterns Inc. All rights reserved 28

40 Session 2: Java Overview Java Development Kit (JDK) The Java SE Development Kit (or "JDK") is a set of tools that includes all the basic components needed to build Java applications Some of the major components include: The Java core API libraries Command line tools javac java javadoc jar javap compiler runtime system documentation tool creates JAR (Java ARchive) files allows you to peek inside.class files Copyright LearningPatterns Inc. All rights reserved 30

41 Session 2: Java Overview The Java API Java comes with a large number of software components that make up the Java Application Programming Interface (API) They're grouped into packages (libraries of related functionality), in many areas, including Core Language (java.lang): Core functionality used by most programs, such as the String, Double, and Exception classes Utility (java.util): Core functionality such as collections, internationalization, date/time utilities, and logging I/O (java.io): Support for I/O, including file I/O, buffers, access to file objects, and abstract channels Persistence (java.sql, javax.persistence): Database Access Networking (java.net): Networking, including TCP/IP and SSL GUI (java.awt, javax.swing): Graphical User Interfaces (GUI) XML(javax.xml, javax.jws): XML manipulation and Web services There is an enormous amount of functionality available with the Java SE platform These packages make it easy to build highly functional and portable programs immediately We can't even include all the packages here, as there are well over a hundred And thousands of classes in the packages There is even more functionality available in the Java EE platform Which defines standards for enterprise technologies such as Web applications and distributed objects Copyright LearningPatterns Inc. All rights reserved 31

42 Session 2: Java Overview Downloading and Installing the JDK You can try the following URL: For Java 8 (Based on JDK 8 update bit install) Install file: jdk-8u20-windows-x64.exe Default installation directory: C:\Program Files\Java\jdk1.8.0_20 For Java 7 (Based on JDK 7 update bit install) Install file: jdk-7u67-windows-x64.exe Default installation directory: C:\Program Files\Java\jdk1.7.0_67 NOTE: the core API documentation is not included It must be downloaded separately and unzipped into the Java installation directory As update releases come out, their install files will take the following forms: Java 8: jdk-8u<updateversion>-windows-i586-p.exe Java 7: jdk-7u<updateversion>-windows-i586-p.exe Java 6: jdk-6u<updateversion>-windows-i586-p.exe Copyright LearningPatterns Inc. All rights reserved 32

44 Session 2: Java Overview Review Questions 1. Explain the Java program development and runtime lifecycle. 2. What is portability? How does Java achieve it? 3. What is the role of the Java virtual machine? 4. What is the JDK? Name some of its tools, where in the JDK they're located, and what they are used for. Copyright LearningPatterns Inc. All rights reserved 34

45 Session 2: Java Overview Lesson Summary Java programs are written in source files with a.java extension They are compiled into bytecode with javac, then run in the JVM (Java Virtual Machine), which converts them to the target platform Java programs can run unchanged in different environments and operating systems. Java achieves this by using the same bytecode format and standard libraries across all platforms The JVM provides an independent operating environment for Java programs It also converts bytecode into native code for the target platform The JDK provides all the tools for working with Java Including javac (the java compiler) java (The JVM), and others Copyright LearningPatterns Inc. All rights reserved 35

47 Session 7: Packages Session Objectives Explain some of the issues that packages are designed to address Understand the relationship between a package name and its corresponding directory structure on the filesystem Use the various forms of the import statement and understand what import does and does not do Create packages and put classes in them Understand what the classpath is and how it's used Copyright LearningPatterns Inc. All rights reserved 171

49 Session 7: Packages Dealing with Complexity So many classes, so little time Systems often can have hundreds of classes (or more) How do you organize them? It's also common to have multiple classes with the same name Classes with slightly different functionality, or written by different groups The Java APIs have this For example, it has a general purpose Date class It also has one specialized to work with SQL databases Packages are used to solve these issues in Java Copyright LearningPatterns Inc. All rights reserved 173

50 Session 7: Packages Packages package: A collection of related type declarations Classes, interfaces, exceptions, enumerations Provides organization, access protection and namespace management Makes classes easier to find and use Provides flexibility in access control Helps avoid naming conflicts Package names are hierarchical They are dot-separated list of identifiers The Java API is organized as a number of packages Think of it as several libraries With the library name becoming part of the class name Some of the core API packages include: java.lang basic language classes java.util collection and utility classes java.awt and javax.swing GUI framework java.io I/O classes Copyright LearningPatterns Inc. All rights reserved 174

51 Session 7: Packages package Statement A package statement at the top of a source file identifies a package Anything defined in the file is part of the package // file: Date.java - in the java.util package package java.util; // public means it can be accessed outside the package public class Date { // Date represents a specific instant in time } u The package name becomes part of the class name java.util.date is the full name of the class above The only thing that can precede a package statement is a comment. Copyright LearningPatterns Inc. All rights reserved 175

52 Session 7: Packages The Default (or Unnamed) Package Classes that aren't in a named package are in the default package This package has no name Only for temporary code, or very small programs All classes in the same directory, and without package statements, are in the default package for that directory (1) In general, code should be in a named package Lets first look at how to use packages We'll then look at how to create them The classes in the labs up until now have all been in the default package (1) From the Java Language Specification - Packages Section A compilation unit that has no package declaration is part of an unnamed package. Unnamed packages are provided by the Java SE platform principally for convenience when developing small or temporary applications or when just beginning development. Note that an unnamed package cannot have subpackages, since the syntax of a package declaration always includes a reference to a named top level package. An implementation of the Java SE platform must support at least one unnamed package; it may support more than one unnamed package but is not required to do so. Which compilation units are in each unnamed package is determined by the host system. In implementations of the Java SE platform that use a hierarchical file system for storing packages, one typical strategy is to associate an unnamed package with each directory; only one unnamed package is observable at a time, namely the one that is associated with the "current working directory". The precise meaning of "current working directory" depends on the host system. Copyright LearningPatterns Inc. All rights reserved 176

54 Session 7: Packages The import Statement Imports go at the beginning of your file After the package statement, before anything else Imports describe how to resolve the type names in your file e.g. a class name like Date Two possible formats: Import all members of a package: import packagename.*; Import one package member import packagename.identifier; Three choices in using a package member (e.g. a class name) Import all members in the package Import the specific class or interface Use the fully qualified name - the name of the package prepended to the name of the member For all you C/C++ programmers, import is NOT #include. It doesn't actually include any code. It just informs the compiler what class a particular name refers to. For example, String refers to java.lang.string because all the classes in the java.lang package are always implicitly imported. public members of a package can be accessed from outside the package We'll talk more about this soon Import of all the package members does not copy all the class files in that package, or load all the classes into the JVM It only lets the compiler and interpreter know where to look for class files used in the classes of this file. If they are used, the compiler knows where to find them to check that all the methods invoked exist, and the interpreter will know where to look so it can load them at runtime. When we learn about inheritance, we'll see that in some cases protected members can also be accessed outside the package Copyright LearningPatterns Inc. All rights reserved 178

55 Session 7: Packages Importing a Complete Package To import all the members of a package, use import packagename.*; import java.util.*; class AlarmClock { // Date is in package java.util Date currenttime = new Date(); Timer snoozeinterval = new Timer();... Why do it this way? East of use if you're using many members from a package, it makes it very easy to import them Why not do it this way? Doesn't document the classes used in this program Can lead to ambiguity in what type is imported Timer is a class in java.util that lets you schedule tasks The package structure is hierarchical. There are two subpackages of the java.util package in the core API named java.util.jar and java.util.zip. import java.util.* does not give you access to the classes in these packages nor does import java.util.*.*. To use them, you must import java.util.jar.*, import java.util.zip.*. The * can only be in the last position. Although "over-importing" does no real harm, if you import an entire package, it is unclear to the reader of your code which dependencies your code has on other classes or interfaces. Copyright LearningPatterns Inc. All rights reserved 179

56 Session 7: Packages Importing a Single Package Member To import a single member of a package, use: import packagename.identifier; import java.util.date; import java.util.timer; class AlarmClock { Date currenttime = new Date(); Timer snoozeinterval = new Timer();... Why do it this way? Helps avoid naming conflicts Documents/clarifies the member classes used You may be using one or only a few members of a package Why not do it this way? Quite a bit of typing, somewhat verbose But most development environments can do the typing for you :-) If you look at the source code for the Java API, you will notice that imports are used for each class, rather than for entire packages. If you're reading this code, you'll know exactly what other classes are being used without having to search for them. Copyright LearningPatterns Inc. All rights reserved 180

57 Session 7: Packages Using the Fully Qualified Name Without importing, you must use the fully qualified name every time its used // e.g. To use the Date class in java.util java.util.date d = new java.util.date(); Why do it this way? Sometimes needed to avoid naming conflicts To be explicit for clarity If you are using the member only once Generated code often uses this style Why not do it this way? Hard to maintain - a lot of changes if you need to use a different package It can also be a lot of typing Copyright LearningPatterns Inc. All rights reserved 181

58 Session 7: Packages Standard Imports Java imports two packages for you in every file 1. The current package This is identified by the package statement in the file It includes all members of the package your class is in If you don't have a package statement, the current package is the default package of the current directory That's why the classes in our earlier labs knew about each other 2. The java.lang package A special package containing core Java types It contains classes such as String and System That's how we used them in the earlier labs without any import The String class is really java.lang.string An implicit import java.lang.* is done for you You can't really reuse code that's in the default package For example, you can't import classes in the default package into another package It's not recommended to use it for any production code Copyright LearningPatterns Inc. All rights reserved 182

59 Session 7: Packages Resolving Naming Conflicts If members in different packages have the same name, you can have a naming conflict For example java.util.date and java.sql.date You can solve this by using the fully-qualified name import java.util.*; // Contains java.util.date import java.sql.*; // Contains java.sql.date class AlarmClock { // compile ERROR: which Date? Date currenttime = new Date(); } import java.util.*; import java.sql.*; // this is OK, because of fully qualified name class AlarmClock { } java.util.date currenttime = new java.util.date(); Can you think of another way to solve this? The naming conflict can also be dealt with by the following incantation: import java.util.*; import java.sql.*; // dictates interpretation of "Date" import java.util.date; Are there other ways? Copyright LearningPatterns Inc. All rights reserved 183

61 Session 7: Packages Creating a Package Add a package statement to each member of the package Package names are hierarchical, and have the form: package identifier[.identifier ]; The package members are usually functionally related Below, we define two classes in the package com.mycompany.time It's common practice to use a reverse URL in a package name // File Timepiece.java package com.mycompany.time; import java.util.*; class TimePiece {... } // File AlarmClock.java package com.mycompany.time; import java.util.*; class AlarmClock extends TimePiece {... } To create a package, just put a type declaration (class, interface, exception, enumeration) in it You do this by putting a package statement at the (very) top of the source code file This statement must be the first non-comment statement in the file, and precedes the class statement Copyright LearningPatterns Inc. All rights reserved 185

62 Session 7: Packages Access Control for Class Members You can control access for class members A public class member is accessible anywhere the class that defines it is accessible If you can access the class, you can get to its public members Constructors and many methods are often public A private class member is only accessible within the class that defines it Instance variables (data) are usually private A member with no declared access level has "default access" (Also called "package private" access) Remember you still need an instance to call regular methods of a class, even if you have imported a package A class member with "package private" access is accessible to all other classes that are defined in the same package. Outside the package, the access appears the same as private. So, classes that are in the same package have "special privileges." Package access is similar to "friendly" access in C++. Copyright LearningPatterns Inc. All rights reserved 186

63 Session 7: Packages Access Control for Classes Classes must be declared public to be accessible from packages other than the one they are defined in For example, public class Date { } Only one class per source file can be declared public The file name of a public class definition must match the class name, with a.java extension added public class Date must be defined in Date.java Generally, only one class is defined in a source code file Though more advanced techniques might define other classes However, only one can be a top level, public class If a class is not declared public, it is only accessible from within the package it is defined in. We didn't have to care about this in our labs, because everything was in the same package, i.e., the default package. If you have more than one class in the same file, how will you remember where it is? When you compile a.java file that contains multiple classes, the compiler will produce a.class file for each separate class. Later, we'll discuss another access modifier (protected) that can be accessed by a subclass, even if it is outside of the package. Copyright LearningPatterns Inc. All rights reserved 187

64 Session 7: Packages Summary - Using Packages Add package statements to your source files The scope of a package statement is the entire source file Every type defined in the file is in that package Packages usually span multiple source files Include access modifiers (public/private) in your class definition Data will usually be private Include import statements, as needed, to use types outside your package (1) The Java Language spec recommends using your reversed Internet domain name to start package names - e.g. com.mycompany This helps to prevent package name collisions between libraries written by different companies Otherwise, there might be many different companies that write a util.date class, or some other common name This way, the type would be com.mycompany.util.date, and so would not collide with com.yourcompany.util.date The package naming convention also applies to educational institutions and other organizations org.omg.corba, edu.mit, gov.irs Otherwise, you could quickly get collisions for common names Most companies selling commercial Java packages use this convention, though many drop the com prefix Java reserves the java package name for the core API class libraries supplied with the Java Runtime Environment. Copyright LearningPatterns Inc. All rights reserved 188

66 Session 7: Packages Tools Must Locate Class Definitions To compile a source file the compiler must know about any type used in the source file It looks at both.java and.class files to find these If a.java file is not compiled, or is newer than its.class file, the compiler will compile it To run an application, the Java Virtual Machine (JVM) must be able to find all the types in your application The compiler and JVM need to know how to find your application classes They know how to get to the standard Java classes Let's look at how this is done for application classes A package named com.entertainment that contains the Television class must be somewhere in the directory structure under one of the CLASSPATH root directories. For example, if we use the default CLASSPATH=. (current directory) and the current directory is C:\StudentWork, then the full path should be C:\StudentWork\com\entertainment\Television.class Copyright LearningPatterns Inc. All rights reserved 190

67 Session 7: Packages Organizing Files and Packages Java uses the file system to organize packages All files in a package must be located in a subdirectory that matches the full package name The directory name reflects the package name of the type e.g. java.util or java.lang Package subdirectories can branch off any directory in the classpath Below Java source and compiled files are kept in separate directories classes java src java util lang util lang Date.class String.class Date.java String.java Hashtable.class System.class Hashtable.java System.java These rules that map package names to directory names are required by the Java language They will be enforced by the java programs For example, if you try to compile a file in the java.lang package, and it's not in a directory tree java/lang, then the compiler will complain Copyright LearningPatterns Inc. All rights reserved 191

68 Session 7: Packages Class Path The classpath indicates where Java tools look for classes Can be declared in the CLASSPATH environment variable Can be given to tools using the classpath option The class path can contain directories, zip, and jar files Entries are separated by a colon(*nix) or semicolon(windows) Package subdirectories can be on any directory on the classpath Zip and jar files on the classpath will be read, and their contents added to the classpath In the example below there are three things on the classpath The current directory - denoted by. (dot) (as well as any package subdirectories) All classes in the myutil.jar file in the directory c:\myapp\lib The directory C:\MyApp\classes, and any package subdirectories java classpath.;c:\myapp\lib\myutil.jar;c:\myapp\classes MyApp If the CLASSPATH environment variable has no setting, the classpath automatically contains the current directory (.) If you explicitly set CLASSPATH, you give up the free dot (.), and thus have to include it back in, if you want it For jar and zip files, the actual JAR or ZIP file name must be included at the end of the path Classes can also be found automatically in: <java>\jre\lib\ext, <java>\jre\classes, and <java>\jre\lib\rt.jar When locating package members, the classpathroot + packagename + classname is searched, using each of the roots listed in the classpath First, Java searches the current package by concatenating all possible root directories of the classpath with the packagename and looks inside these files for the classname Next, Java searches all imported packages for a file with the classname Finally, Java automatically searches the special JDK directories jre\lib\ext, jre\classes and jre\lib\rt.jar Copyright LearningPatterns Inc. All rights reserved 192

69 Session 7: Packages Classpath Example Assume you want to run the program TelevisionTest And all its classes are in the package com.entertainment And its class files were under C:\StudentWork\workspace\Lab03.3 You could run it as follows (see notes on passing class names to java) java -classpath C:\StudentWork\workspace\Lab03.3 com.entertainment.televisiontest Since the classpath contains the directory with our packages in them, the JVM will find the classes Lab03.3 com entertainment Television.class TelevisionTest.class Note that the classpath points to the directory where the package directories are Keep in mind that when running a program with the JVM (java) The classname you pass in must be the fully qualified name (package name + classname) without the extension java uses dots in the fully qualified name, not directories Hence, we use com.entertainment.televisiontest in the example above Copyright LearningPatterns Inc. All rights reserved 193

70 Session 7: Packages Classpath Example Assume the classes were split into two directories as shown below You could run TelevisionTest as follows: java -classpath C:\StudentWork\workspace\Lab03.3\classes1; C:\StudentWork\workspace\Lab03.3\classes2 com.entertainment.televisiontest The classpath contains both directories that hold our packages Lab03.3 classes1 com entertainment Television.class classes2 com entertainment TelevisionTest.class The directories on the classpath are separated by seimcolons in the Windows environment There should be no newlines or spaces between them - for example C:\StudentWork\workspace\Lab03.3\classes1; C:\StudentWork\workspace\Lab03.3\classes2 It is only due to space limitations that it appears that the directories are on different lines in the slide They would be separated by colons in a Unix environment Copyright LearningPatterns Inc. All rights reserved 194

71 Session 7: Packages What is a JAR? JAR stands for Java Archive It aggregates (collects) many files into one Based on the ZIP file format The standard packaging mechanism to distribute Java code in a platform independent way Can also include audio and image files, and authentication using digital signatures Includes a manifest file that lists the filenames in the jar and the algorithms used to compress and/or sign each one JAR is: the only archive format that is cross-platform the only format that handles audio and image files as well as class files backward-compatible with existing applet code an open standard, fully extendable, and written in java the preferred way to bundle the pieces of a java applet JAR consists of a zip archive, as defined by PKWARE, containing a manifest file and potentially signature files, as defined in the JAR File Specification On Microsoft Windows systems, the Java 2 Runtime Environment's installation program will register a default association for JAR files so that double-clicking a JAR file on the desktop will automatically run it with javaw -jar Dependent extensions bundled with the application will also be loaded automatically This feature makes the end-user runtime environment easier to use on Microsoft Windows systems. Copyright LearningPatterns Inc. All rights reserved 195

72 Session 7: Packages Classpath Example Assume all your classes were in a jar entertainment.jar Located in the Lab03.3 directory, as shown below You could run TelevisionTest as follows: java -classpath C:\StudentWork\workspace\Lab03.3\enertainment.jar com.entertainment.televisiontest The classpath contains the jar file itself The JVM will find the classes inside the jar Lab03.3 entertainment.jar The directory structure within a JAR file is automatically taken into account when searching it for classes. You can place files in the following places, and they'll be found automatically You can place zip and jar files in a <java>\jre\lib\ext You can also place "loose" class files in a <java>\jre\classes (which you must create) <java>\jre\lib\rt.jar, the JAR file containing the core API is also found automatically The search sequence looks like this: classpath[0] + packagename + classname classpath[ n] + packagename + classname classpath[0] + importpackagename[0] + classname classpath[0] + importpackagename[ n] + classname classpath[ n] + importpackagename[0] + classname classpath[ n] + importpackagename[ n] + classname jre\lib\ext, then jre\classes, then jre\lib\rt.jar Copyright LearningPatterns Inc. All rights reserved 196

is Fast Track to Java 8 and OO Development

is Fast Track to Java 8 and OO Development or tri N s di IO n tio AT uc od pr re U ed AL riz ho ut na EV U is i ib d tie PY oh pr O n C io t bu Fast Track to Java 8 and OO Development This material is copyrighted by LearningPatterns Inc. This content