David Parsons. Foundational Java. Key Elements and Practical Programming

Transcription

1 Foundational Java

2

3 David Parsons Foundational Java Key Elements and Practical Programming

4 David Parsons Inst. of Information and Math. Sciences Massey University 17 State Highway Albany Campus Albany, Auckland New Zealand ISBN e-isbn DOI / Springer London Dordrecht Heidelberg New York British Library Cataloguing in Publication Data A catalogue record for this book is available from the British Library Library of Congress Control Number: Springer-Verlag London Limited 2012 Apart from any fair dealing for the purposes of research or private study, or criticism or review, as permitted under the Copyright, Designs and Patents Act 1988, this publication may only be reproduced, stored or transmitted, in any form or by any means, with the prior permission in writing of the publishers, or in the case of reprographic reproduction in accordance with the terms of licenses issued by the Copyright Licensing Agency. Enquiries concerning reproduction outside those terms should be sent to the publishers. The use of registered names, trademarks, etc., in this publication does not imply, even in the absence of a specific statement, that such names are exempt from the relevant laws and regulations and therefore free for general use. The publisher makes no representation, express or implied, with regard to the accuracy of the information contained in this book and cannot accept any legal responsibility or liability for any errors or omissions that may be made. Printed on acid-free paper Springer is part of Springer Science+Business Media (

5 To my mother, Angela ( ), always there for me

6

7 Preface In the Spring of 1996, I attended the Object Technology conference at Christ Church College, Oxford. The excited buzz around the new Java language at this conference got me curious, and a few months spent getting up to speed with the syntax convinced me that it was worth trying out as a teaching language. After overcoming some hurdles, including getting a teaching lab upgraded from Windows 3.1 to Windows 95 so we could actually run Java, I taught a class of student volunteers at what is now Southampton Solent University the basics of Java in From this experience I wrote the first edition of Introductory Java which was published by Letts Educational in In 1999, I left academia to spend some years in industry, training and consulting in Java. This gave me a whole new perspective on the language as a professional tool. The second edition of Introductory Java was published in 2003, but another update was long overdue. This book was originally intended to be the 3rd Edition of Introductory Java. However, such were the changes that had taken place over the years, both in Java and in my own experiences of it, that this became a whole new book, with a new title and focus. It has grown out of 15 years of teaching Java both to students and to professionals across the world, and reflects a wealth of experience and insight. I have had a great journey with Java, and I am grateful for the opportunity to share my Java story with readers of this book. Overview and Goals Foundational Java: Key Elements and Practical Programming guides the reader through all the core features of Java, and some more recent innovations, in a way that builds skills and confidence through tried and trusted stages, supported by exercises that reinforce the key learning points. Using this book, the reader is introduced to all the most useful and commonly applied Java syntax and libraries, and is provided with many example programs that can provide the basis for more substantial applications. Integral to the book is the use of the Eclipse Integrated Development Environment (IDE) and the JUnit testing framework. This ensures maximum productivity and code quality when learning Java. However, the fundamentals of using the Java compiler and run time are also explained to ensure that skills are not confined to one environment. In addition, coverage of the Ant tool ensures that the reader is equipped vii

8 viii Preface to automatically build, test, and deploy their applications, including simple web applications, independent of an IDE. Organization and Features The book is organized into 20 chapters that cover various levels of Java (see Suggested Uses for further information.) Each chapter covers a discrete topic and includes scaffolded exercises that build skills in a step by step fashion. Earlier versions of the book used an objects first approach; however experience has shown me that it is better to cover the language fundamentals before addressing object oriented concepts, so this book follows an objects later philosophy. The key features of this book are that it Meets the needs of both students and professionals Provides both introductory and intermediate coverage Is completely up to date, including Java 7 Makes unit testing one of its key themes, introducing the JUnit 4 testing framework to emphasize the importance of unit testing in modern software development Uses the Eclipse IDE, the most popular open source Java IDE, but also explains how Java can be run from the command line Includes coverage of the Ant build tool Comes with code examples and exercises throughout Is accompanied by a full set of PowerPoint presentation slides that have been road tested with classes Builds on two previous editions and a set of classroom training materials that have been refined and developed as Java has continued to evolve Includes some important illustrations in color Target Audiences This is primarily an undergraduate textbook. It can be used for basic introductory courses or for intermediate classes. From that perspective, it has been structured as a teaching text that breaks into weekly topics that build upon one another. It is also a book suitable for professional software developers who need to pick up Java from previous experience in other tools or languages. The materials have been tried and tested in commercial training courses for professional software developers over the last 7 years. The choice of intermediate topics has been driven by customer requirements. All of these topics have been requested by clients in various courses. Suggested Uses The book has been structured in such a way that it breaks easily into weekly topics. There is a core set of chapters that can be used as an introductory course, in a single semester, and a further set of chapters that can be used for intermediate study, for

9 Preface ix follow-on, longer or double-weighted courses. It contains exercises throughout, designed to reinforce learning about the topics covered in each part of the chapter. The final exercises at the end of each chapter draw together the key aspects that have been covered, which are also reiterated in chapter summaries. Foundational Java can be used for courses of different lengths and levels by using it in three different ways. The first 12 chapters, listed below, cover the core knowledge of Java, and provide a solid basis for an introductory course on object oriented programming with Java. These fit easily into a 12 week semester, providing 11 weeks of teaching material (Chap. 1 is just an introduction) and opportunities for revision and reflection. 1. The Java Story 2. Compiling and Running Java Programs 3. Data Types, Arithmetic, and Arrays 4. Control Structures 5. Creating Objects 6. Creating Domain Classes 7. Objects Working Together: Association, Aggregation, and Composition 8. Inheritance, Polymorphism, and Interfaces 9. Exception Handling 10. Unit Testing with JUnit 11. Exploring the Java Libraries 12. The Collections Framework and Generics The following four chapters, listed below, are more intermediate and provide more specialized coverage of Java; interaction with external connections to files, databases and build tools, as well as providing an introduction to multithreading. These are useful in longer semesters, or courses that require intermediate level study. 13. Input and Output Streams 14. Automatic Building and Testing with Ant 15. Java and the Database (JDBC) 16. Multithreading The final four chapters are specific to building applications with a graphical user interface, and launching applications from a web server, and provide optional coverage for courses that have requirements for this type of programming. They provide additional resources and flexibility for longer or broader courses. 17. Building GUIs with the JFC Swing Library 18. Event-Driven Programming 19. Dialogs and Menus, Models and Views 20. Java Web Start and Applets Supplemental Resources A number of supplemental resources are available from the book s website at

10 x Preface Resources on the website for students include Downloadable source code for all the examples in the book Downloadable source code for solutions to selected exercises Self-test questions Additional resources for instructors include A complete set of PowerPoint slides Downloadable source code for solutions to all exercises A note about the code Source code in the text appears in a Courier font to mark it out clearly from the surrounding text Java source code appears in this font Due to the page width, it has often proved necessary to break lines of code in places where the original source code (which can be downloaded from the website) would not have a line break. In the majority of cases the line breaks have been inserted so that they do not affect compilation. For example, this code statement appears in Chap. 3. double mean = ((double)intarray[0] + intarray[1] + intarray[2]) / intarray.length; This is, in fact, a single statement, even though it is broken across three lines of text. A single statement in Java is terminated by a semicolon, and line feeds do not, in most cases, affect the way the code works. However in a very small number of cases it has not been possible to break lines within the margin constraints of the book in such a way that their workings are unaffected. If in doubt, or if you are having problems with compiling or running code, please refer to the original source code files. Acknowledgements It is difficult to acknowledge all the individuals who have contributed to this book, because my experience of Java has been so long and broad. I am grateful to the many authors of courseware from my various past employers: The Object People, BEA Systems, Valtech, IBM and Software Education Associates. The experience of teaching from material authored by others, however good or bad it is, provides new perspectives and understanding that goes way beyond what is possible when only teaching from your own perspective. I am grateful to my colleague Hokyoung Ryu, for giving me the impetus to (re) write this book and test the material on his students. I am also grateful to Wayne Wheeler and Simon Rees at Springer-Verlag London Ltd., who gave me the opportunity to bring this book to publication.

11 Contents 1 The Java Story A Brief History of Java Characteristics of Java Simple Object-Oriented Distributed Robust Secure Architecture-Neutral Portable High-Performing Multithreaded Dynamic The JDK and the JRE Java Versions Java APIs Summary Compiling and Running Java Programs Java from the Command Line Setting the Path to the JDK A First Java Program The MyJavaProgram Class The main Method Output with the System Class Compiling Java Running Java The Java Classpath Packages Compiling into a Package Folder Comment Syntax xi

12 xii Contents 2.7 Using the Eclipse Integrated Development Environment (IDE) Creating a New Project Editing Code in Eclipse Compiling and Running Code in Eclipse Summary Data Types, Arithmetic, and Arrays Java Primitive Data Types Literals and Variables Literals and the Compiler Boolean Variables Unicode Characters and Escape Sequences Variable Scope Arithmetic and Other Operators Arithmetic Statements Increment and Decrement Operators Prefix and Postfix Operators Assignment Operators Promotion and Typecasting String Concatenation Bitwise Operators Arrays Declaring Arrays Initializing Arrays Accessing Array Data The Array length Field Multidimensional Arrays Precedence, Casting, and Promotion Summary Control Structures Making Selections if Statements Expressing Conditions with Relational and Boolean Operators Using Selection: The CoinExample Class The DieExample Class Writing Test Code switch Statements The Ternary Operator Iteration while and do while Loops for Loops Summary... 70

13 Contents xiii 5 Creating Objects Classes and Objects Object Creation: Constructors Classes and Methods for String Data The String Class StringBuilders StringBuffers The tostring Method References and Memory Garbage Collection Object Equality String Concatenation and Memory Java Library Packages Importing Classes Wild Cards and Multiple Imports Packages and Sub-packages Managing Imports with Eclipse Using Javadoc Viewing Javadoc in Eclipse Summary Creating Domain Classes Object Orientation and Domain Objects Clock Objects in the Real World Encapsulation and Information Hiding Object Identity Creating New Classes Adding Fields to a Class Adding Methods to a Class Constructors Overloaded Constructors Chaining Constructors Internal Encapsulation in Constructors Access Modifiers Javadoc and Code Comments Creating Javadoc in Eclipse Running Javadoc from the Command Line Types of Method Object Reuse Static Fields and Methods Static Methods Invoking Static Methods Static Final Fields Static Methods in Java Library Classes

14 xiv Contents 6.9 Objects as JavaBean Components Reflection Summary Objects Working Together: Association, Aggregation, and Composition Aggregations as Collections Message Passing Object Association Association Direction Implementing Associations Associating Objects: The Snakes and Ladders Game The Snakes and Ladders Game Source Code When to Create Objects Association, Aggregation, or Composition? Aggregation Example Composition Electronic Gates Half Adder Components Summary Inheritance, Polymorphism, and Interfaces Abstraction Inheritance Polymorphism The Relationship Between Inheritance and Polymorphism Inheriting from the Object Class Overriding the tostring Method Overriding the equals Method Overriding the hashcode Method Annotation An Inheritance Hierarchy Using Abstraction Abstract Classes Protected Visibility and Inheritance Creating Subclasses Calling Superclass Constructors Adding Further Subclasses Dynamic Binding Using Polymorphic Methods Interfaces Naming Interfaces Implementing an Interface Summary

15 Contents xv 9 Exception Handling Java Exceptions The Exception Handling Hierarchy Checked and Unchecked Exceptions Exception Handling Keywords Handling Checked Exceptions Catching Exceptions: try and catch Handling Unchecked Exceptions Exiting Catching Multiple Exceptions Ordering Multiple catch Blocks Throwing an Exception with throw Delegating Responsibility Writing and Using Custom Exceptions Throwing a Custom Exception finally Blocks Re-throwing Custom Exceptions Summary Unit Testing with JUnit The JUnit Test Framework Using JUnit with Eclipse Test Cases and Units Under Test Creating a JUnit Test Case Required Imports Writing Test Methods Using TestRunners The Eclipse TestRunner Types of Assertions Asserting Floating Point Equality Object Equality Other Assertions Exceptions, Timeouts, and Failures Forcing Failures Arranging a Test Methods The 3A Pattern Methods Writing a Test Suite Summary Exploring the Java Libraries Frequently Used Classes in the Java.lang Package The Java.lang.Object Class The Java.lang.Math Class The Java.lang.System Class Wrapper Classes

16 xvi Contents 11.2 Classes in the Java.util Package The Date Class The Calendar Class and Factory Methods Formatter Classes in the Java.text Package Formatting Dates Parsing Dates Formatting and Parsing Numbers Formatting and Parsing Currency Summary The Collections Framework and Generics Objects That Contain Objects Associations and Collections The Core Collection Interfaces Partial Implementations of the Core Interfaces Concrete Implementations of the Core Interfaces Legacy Classes Typesafe Collections with Generics A Concrete Collection Class: The ArrayList Adding and Retrieving Objects Wrapping and Autoboxing Iterators ListIterator Enhanced for Loop An ArrayList of Module Objects Maps Map Views Using a TreeMap Utility Classes Comparing Objects with the Comparable Interface The Collections Class Creating a Comparator Generics and Inheritance Specifying Bounds Summary Input and Output Streams Java Stream Classes Different Types of Stream Byte Streams Streaming Bytes To and From Files Filter Streams Readers and Writers Buffered Readers and Writers PrintStreams and PrintWriters

17 Contents xvii 13.6 The File Class Streaming Objects Serializing Course Objects The New IO Library Buffer Classes File Channels View Buffers Charsets and String Data Summary Automatic Building and Testing with Ant Installing and Configuring Ant Using Ant in Eclipse The Ant Build File: build.xml Ant Properties Tasks and Targets Running an Ant Build File in Eclipse Packaging Code with the Ant jar Task Target Dependencies Running Code, Forking, and Classpaths Setting the Classpath with a path Element Running Tests Running Tests with the junit and test Elements Running Multiple Tests with the batchtest Element Summary Java and the Database (JDBC) An Example Database Using MySQL Creating a New Database Generating Primary Keys Using a DDL Script Viewing Table Schema Creating an Authorized MySQL User Java Database Access with JDBC JDBC Drivers Making a Two-Tier Connection SQL Exceptions Executing SQL Queries and Updates Using JDBC Processing ResultSets Updating Records Using Prepared Statements Summary

18 xviii Contents 16 Multithreading Creating and Running a Thread Thread States Running Multiple Threads Thread Priority Setting Thread Priority Yielding Implementing the Runnable Interface Synchronizing Threads Monitors and Synchronization wait, notify, and notifyall Synchronized Code Example The Sensor Class The Analyzer Class Concurrent Collections Summary Building GUIs with the JFC Swing Library Components, Containers, and Frames Creating a Main Window Frame Setting the JFrame s Title Selecting the JFrame s Closing Behavior Sizing the JFrame Showing the JFrame Swing Component Classes The JLabel Class Adding Components to a Frame Manually Positioning and Sizing Components Common Methods of Component and JComponent The JTextField Class The JButton Class Placing Components Using setbounds Colors, Fonts, and Icons Setting Colors Setting Fonts Font Style and Size Icons on Labels and Buttons Some Additional Components JTextArea Check Boxes and Radio Buttons JComboBox JSlider JPanel Setting the Look and Feel

19 Contents xix 17.7 Layout Managers BorderLayout FlowLayout GridLayout Summary Event-Driven Programming Event Listeners Event Classes EventListener Interfaces A JButton ActionListener Adding a Listener Multiple Action and Focus Listeners Responding to Mouse Events Mouse Listener Events Mouse Motion Events Event Handlers as Inner Classes Implementing a DieListener Inner Classes Local Inner Classes Anonymous Inner Classes JPanel Subclasses and Multi-panel Layouts The GridBagLayout Separating the Model from the View The Model Class: FlightDistances The View Class: DistanceViewer Summary Dialogs and Menus, Models and Views Predefined Dialogs in Swing Message Box Dialogs Using JOptionPane File Chooser Dialogs Using JFileChooser Color Chooser Dialogs Using JColorChooser Custom Dialogs with JDialog Using Menus Adding a Menu to a Frame Menu Enhancement: Separators, Mnemonics, and Accelerators MenuListeners Model View Controller in Swing Components Model and View in JTextPane Components Model and View in the JTable Component Summary

20 xx Contents 20 Java Web Start and Applets Web Browsers, URLs, and HTML Pages URLs HTML (HyperText Markup Language) Java Web Start Creating a JAR in Eclipse Java Network Launch Protocol (JNLP) Deploying to a Server Running Applications from the Cache Security Applets How Applets Differ from Applications Running an Applet in the Applet Viewer Summary Bibliography About the Author Index