Introduction... xxxiii. Chapter 1: Essential Java In Depth... 2

Transcription

1 Introduction... xxxiii Chapter 1: Essential Java... 1 In Depth... 2 All about Java... 2 Java Appears... 3 All about Bytecodes... 3 Features of Java... 4 Java Environment... 6 Java Development Kit... 6 Java Platforms... 6 Java Virtual Machine... 8 Java API... 8 Java Programs... 9 What are Application Servers (Tomcat, JRun, WebSphere, WebLogic, etc.)... 9 Program Design Performance Maintainability Extensibility Availability New Features of Java SE Immediate Solutions Getting and Installing Java What about CLASSPATH? Subfolders Created by JDK Creating Source Files... 16

2 Knowing Java s Reserved Words Creating an Application Line 1 public class App Line 2 public static void main(string[] args) Line 3 System.out.println( Hello from Java! ); Compiling Code Compiling Code: Using Command-Line Options Cross-Compilation Options Compiling Code: Checking for Deprecated Methods Running Code Running Code: Using Command-Line Options Commenting Your Code Import Java Packages and Classes Finding Java Classes with CLASSPATH Summary Chapter 2: Variables, Arrays, and Strings In Depth Variables Data Typing Arrays Strings Immediate Solutions What Data Types are Available? Creating Integer Literals Creating Floating-Point Literals Creating Boolean Literals Creating Character Literals Creating String Literals Creating Binary Literals Using Underscores in Numeric Literals Declaring Integer Variables Declaring Floating-Point Variables Declaring Character Variables Declaring Boolean Variables Initializing Variables Dynamically vi

3 Conversion between Data Types Automatic Conversions Casting to New Data Types Declaring One-Dimensional Arrays Creating One-Dimensional Arrays Initializing One-Dimensional Arrays Declaring Multi-Dimensional Arrays Creating Multi-Dimensional Arrays Initializing Multi-Dimensional Arrays Creating Irregular Multi-Dimensional Arrays Getting an the Length of an Array Understanding General Form of Static Import Importing Static Members The String Class Creating Strings Getting String Length Concatenating Strings Getting Characters and Substrings Searching For and Replacing Strings Changing Case in Strings Checking for Empty String Formatting Numbers in Strings The StringBuffer Class Creating StringBuffers Getting and Setting StringBuffer Lengths and Capacities Setting Characters in String Buffers Appending and Inserting Using StringBuffers Deleting Text in StringBuffers Replacing Text in StringBuffer Using the Wrapper Class Autoboxing and Unboxing of Primitive Types Learning the Fundamentals of Varargs Methods Overloading Varargs Methods Learning the Ambiguity in Varargs Methods Using Non-Reifiable Formal Parameters Summary vii

4 Chapter 3: Operators, Conditionals, and Loops In Depth Operators Conditionals Loops Immediate Solutions Operator Precedence Incrementing and Decrementing (++ and --) Unary NOT (~ And!) Multiplication and Division (* and /) Modulus (%) Addition and Subtraction (+ and -) Shift Operators (>>, >>>, and <<) Relational Operators (>, >=, <, <=, ==, and!=) Bitwise and Bitwise Logical AND, XOR, and OR (&, ^, and /) Logical (&& and ) The if-then-else Operator (?:) Assignment Operators (= and [operator]=) Using the Math Class Changes in the Math Class Class StrictMath Comparing Strings The if Statement The else Statement Nested if Statement The if-else Ladders The switch Statement Using Strings in switch Statement The while Loop The do-while Loop The for Loop The for-each Loop Supporting for-each in Your Own Class A (Poor) Solution Significance of for-each Nested Loops viii

5 Using the break Statement Using the continue Statement Summary Chapter 4: Object-Oriented Programming In Depth Classes Objects Data Members Methods Inheritance Exception Handling Debugging Immediate Solutions Declaring and Defining Classes Declaring and Creating Objects Creating Instance Variables Setting Variable Access Creating Class Variables Creating Methods Setting Method Access Passing Parameters to Methods Command-Line Arguments Passed to main() method Returning Values from Methods Creating Class Methods Creating Data Access Methods Creating Constructors Passing Parameters to Constructors A Full Class Example Understanding Variable Scope Using Recursion Garbage Collection and Memory Management Avoiding Circular References Garbage Collection and the finalize() Method Overloading Methods Overloading Constructors Passing Objects to Methods ix

6 Passing Arrays to Methods Using the this Keyword Returning Objects from Methods Returning Arrays from Methods The ProcessBuilder and StringBuilder Classes The ProcessBuilder Class The StringBuilder Class Catching an Exception Nesting the try Statements Using the finally Clause Throwing Exceptions Creating a Custom Exception Catching Multiple Exception Types Rethrowing Exceptions with Improved Type Checking Debugging Java Programs Summary Chapter 5: Inheritance, Inner Classes, and Interfaces x In Depth Why Inheritance? Why Interfaces? Why Inner Classes? Lambda Expressions Method References Immediate Solutions Creating a Subclass Access Specifiers and Inheritance Calling Superclass Constructors Creating Multilevel Inheritance Handling Multilevel Constructors Overriding Methods Accessing Overridden Members Using Superclass Variables with Subclassed Objects Dynamic Method Dispatch (Runtime Polymorphism) Creating Abstract Classes Stopping Overriding with final Stopping Inheritance with final

7 Creating Constants with final Is-a vs. Has-a Relationships The Java Object Class Using Interfaces for Multiple Inheritance The Readable Interface The Appendable Interface The Iterable Interface Creating Iterable Objects Creating Inner Classes Creating Anonymous Inner Classes Using Lambda Expression Default Methods Summary Chapter 6: AWT Applets, Applications, and Event Handling In Depth The Abstract Windowing Toolkit Applets Applications Handling Events Immediate Solutions Using the Abstract Window Toolkit Creating Applets Using the <APPLET> HTML Tag Handling Non-Java Browsers Embedding <APPLET> Tags in Code Using the init, start, stop, destroy, paint, and update Methods Drawing Graphics in Applets Reading Parameters in Applets Using Java Consoles in Browsers Adding Controls to Applets: Text Fields Adding Controls to Applets: Buttons Handling Events Standard Event Handling Using Delegated Classes Using Action Commands Handling Events the Old Way xi

8 Extending Components Using Adapter Classes Using Anonymous Inner Adapter Classes Creating Windowed Applications Exiting an Application When Its Window Is Closed Applications You Can Run as Applets Setting Applet Security Policies Other Facilities in the java.awt Package System Tray Splash Screen Dialog Modality Gif Writer Text Antialiasing Summary Chapter 7: AWT Text Fields, Buttons, Checkboxes, Radio Buttons, and Layouts In Depth Text Fields Buttons Checkboxes Radio Buttons Layouts Immediate Solutions Using Text Fields Using Labels Using Buttons Using Checkboxes Using Radio Buttons Layout Managers Flow Layouts Grid Layouts Using Panels Border Layouts Card Layouts Grid Bag Layouts Using Insets and Padding xii

9 Creating Your Own Layout Manager Summary Chapter 8: AWT Lists, Choices, Text Areas, Scroll bars, and Scroll Panes In Depth Lists Choices Text Areas Scroll bars Scroll Panes Immediate Solutions Using Text Areas Replacing Text in Text Areas Searching and Selecting Text in Text Areas Using Lists Using Multiple-Selection Lists Using Choice Controls Using Scroll bars Scroll bars and Border Layouts Using Scroll Panes Summary Chapter 9: AWT Graphics, Images, Text, and Fonts In Depth Graphics Images Text and Fonts The Keyboard and Mouse Immediate Solutions Using the Mouse Using the Keyboard Using Fonts Using Images Resizing Images Drawing Graphics Drawing Lines xiii

10 Drawing Ovals Drawing Rectangles Drawing Rounded Rectangles Drawing Freehand Drawing Arcs Drawing Polygons Setting Drawing Modes Selecting Colors Using Canvases Using the ImageObserver Interface Using the MediaTracker Class Working Pixel by Pixel: The PixelGrabber and MemoryImageSource Classes Brightening Images Converting Images to Grayscale Embossing Images Summary Chapter 10: AWT Windows, Menus, and Dialog Boxes In Depth Windows Menus Dialog Boxes Immediate Solutions Creating Frame Windows Showing and Hiding Windows Handling Window Events Automatically Hiding Windows upon Closing Using the Window Class Creating Menus Creating a MenuBar Object Creating Menu Objects Creating MenuItem Objects Handling Menu Events More Menu Options Adding Menu Separators Disabling Menu Items xiv

11 Adding Checkboxes to Menus Creating Submenus Pop-Up Menus Dialog Boxes File Dialog Boxes Summary Chapter 11: Swing Applets, Applications, and Pluggable Look and Feel In Depth The Java Foundation Classes Swing Heavyweight versus Lightweight Components Swing Features Graphics Programming Using Panes Model View Controller Architecture Immediate Solutions Working with Swing Preparing to Create a Swing Applet Understanding Root Panes Understanding Layered Panes Understanding Content Panes Working with Content Panes Creating a Swing Applet Painting in Swing vs. AWT Displaying Controls in Swing Vs AWT Using the JPanel Class Creating a Swing Application Closing JFrame Windows Using Insets for Selecting Component Borders Using Insets The Synth Skinnable Look and Feel The Pluggable Look and Feel The Pluggable Look and Feel for Components The Nimbus Look and Feel Summary xv

12 Chapter 12: Swing Text Fields, Buttons, Toggle Buttons, Checkboxes, and Radio Buttons xvi In Depth Labels and Text Fields Password Field Text Area Editor Pane Text Pane Text Component Printing Buttons Toggle Buttons Checkboxes and Radio Buttons Immediate Solutions Using Labels Using Image Icons Using Images in Labels Using Text Fields Setting Text Field Alignment Creating Password Field Creating Text Areas Customizing a Text Area Creating Editor Panes Using HTML in Editor Panes Using RTF Files in Editor Panes Creating Text Panes Inserting Images and Controls into Text Panes Setting Text Pane Text Attributes Working with Sound in Applets Working with Sound in Application Abstract Button: The Foundation of Swing Buttons Using Buttons Displaying Images in Buttons Using Rollover and Disabled Images Default Buttons and Mnemonics Using Toggle Buttons Creating Toggle Button Groups

13 Using Checkboxes Using Radio Buttons Using Checkbox and Radio Button Images Getting and Setting the State of Checkboxes and Radio Buttons Summary Chapter 13: Swing Viewports, Scrolling, Sliders, Lists, Tables, and Trees In Depth Viewports Scroll Panes Sliders Scrollbars Lists Tables Trees Immediate Solutions Handling Viewports Creating Scroll Panes Creating Scroll Pane Headers and Borders Scrolling Images Creating Sliders Filling a Slider Painting Slider Tick Marks Painting Slider Labels Setting the Slider Extent Creating Scrollbars Creating Lists Handling Multiple List Selections List Selection Modes Displaying Images in Lists Creating a Custom List Model Creating a Custom List Cell Renderer Handling Double Clicks in Lists Drag and Drop Support Creating a Table Table Sorting and Filtering Sorting Rows xvii

14 xviii Filtering Table Rows Adding Rows and Columns to Tables at Runtime Creating Trees Adding Data to Trees Handling Tree Events Summary Chapter 14: Swing Combo Boxes, Progress Bars, Tooltips, Separators, and Choosers In Depth Combo Boxes Progress Bars Choosers Tooltips Separators Immediate Solutions Creating Combo Boxes Handling Combo Box Selection Events Creating Editable Combo Boxes Adding Images to Combo Boxes Creating a Combo Box Model Creating a Combo Box Custom Renderer Creating Progress Bars Updating Progress Bars Handling Progress Bar Events Creating Tooltips Creating Separators Resizing Separators Automatically Creating Color Choosers Creating File Choosers Creating File Chooser Filters Summary Chapter 15: Swing Layered Panes, Tabbed Panes, Split Panes, and Layouts In Depth Layered Panes Tabbed Panes

15 Split Panes Layouts Immediate Solutions Understanding Swing Components and Z-order Making Swing Components Transparent Using Layered Panes Creating Tabbed Panes Specifying Tab Placement in the Tabbed Panes Using Split Panes Making Split Panes One-Touch Expandable Setting Split Pane Orientation Setting Split Pane Divider Size Using the Box Layout Manager Using the Box Class Using the Overlay Layout Manager Summary Chapter 16: Swing Menus and Toolbars In Depth Menus Toolbars Immediate Solutions Creating a Menu Bar Creating a Menu Creating a Menu Item Creating a Basic Menu System Adding Images to Menu Items Creating Checkbox Menu Items Creating Radio Button Menu Items Creating Submenus Creating Menu Accelerators Enabling/Disabling and Changing Menu Items at Runtime Adding and Removing Menu Items at Runtime Adding Buttons and Other Controls to Menus Creating Pop-Up Menus Creating Toolbars xix

16 Adding Combo Boxes and Other Controls to Toolbars Summary Chapter 17: Swing Windows, Desktop Panes, Inner Frames, and Dialog Boxes In Depth Windows Dialog Boxes Immediate Solutions Creating a Window Designing Shaped and Translucent Windows Creating Translucent Windows Creating Different Shaped Windows Creating a Frame Window Creating a Desktop Pane Creating Internal Frames Using JOptionPane to Create Dialog Boxes Creating Option Pane Confirmation Dialog Boxes Creating Option Pane Message Dialog Boxes Creating Option Pane Text Field Input Dialog Boxes Creating Option Pane Combo Box Input Dialog Boxes Creating Option Pane Internal Frame Dialog Boxes Creating Dialog Boxes with JDialog Getting Input from Dialog Boxes Created with JDialog Summary Chapter 18: Working with Streams, Files, and I/O Handling In Depth Streams, Readers, and Writers NIO Essentials in NIO Buffers Charsets and Selectors Enhancements in NIO with Java The Path Interface The Files Class The Paths Class The File Attribute Interfaces xx

17 The FileSystem Class The FileSystems Class The FileStore Class Prospects of NIO Immediate Solutions Working with Streams The InputStream Class The OutputStream Class The ByteArrayInputStream Class The ByteArrayOutputStream Class The BufferedInputStream Class The BufferedOutputStream Class The FileInputStream Class The FileOutputStream Class Working with the Reader Class Working with the Writer Class Accepting Input from the Keyboard with the InputStreamReader Class Working with the OutputStreamWriter Class Working with Files Using the File Class Using the FileReader Class Using the FileWriter Class Working with the RandomAccessFile Class Working with Character Arrays Using the CharArrayReader Class Using the CharArrayWriter Class Working with Buffers Using the BufferedReader Class Using the BufferedWriter Class Working with the PushbackReader Class Working with the PrintWriter Class Working with the StreamTokenizer Class Implementing the Serializable Interface Working with the Console Class Working with the Clipboard Working with the Printer xxi

18 Printing with the Formatter Class Using the System.out.printf() Method Using the String.format() Method Formatting Dates Using the String.format() Method Using the java.util.formatter Class Scanning Input with the Scanner class Summary Chapter 19: Working with Multiple Threads In Depth Using Threads in Java Life Cycle of a Thread Synchronization of Threads Multithreaded Custom Class Loader Immediate Solutions Getting the Main Thread Naming a Thread Pausing a Thread Creating a Thread with the Runnable Interface Creating a Thread with the Thread Class Creating Multiple Threads Joining Threads Checking if a Thread Is Alive Setting Thread Priority and Stopping Threads Synchronizing Synchronizing Code Blocks Synchronizing Methods Synchronizing Classes Communicating between Threads Suspending and Resuming Threads Creating Graphics Animation with Threads Eliminating Flicker in Graphics Animation Created Using Threads Suspending and Resuming Graphics Animation Using Double Buffering Simplifying Producer-Consumer with the Queue Interface Implementing Concurrent Programming Limitations of Synchronization Previous to J2SE xxii

19 Simplifying Servers Using the Concurrency Utilities Knowing Various Concurrency Utilities Learning about the java.util.concurrent Package Learning about the java.util.concurrent.locks Package Reader/Writer Locks Learning about the java.util.concurrent.atomic Package Summary Chapter 20: Networking and Security with Java In Depth Basics of Networking Networking Enhancements in Java SE JDK 8 Security Enhancements Sockets in Java Client-Server Networking Proxy Servers Internet Addressing Domain Name Service Inet4Addresses and Inet6Addresses The URL Class The URI Class URI Syntax and Components TCP/IP and Datagram Blackboard Assignment Retrieval Transaction Immediate Solutions Understanding Networking Interfaces and Classes in the java.net Package The Networking Interfaces and Classes Understanding the InetAddresses IP Addresses Scope Host Name Resolution Caching InetAddress Factory() Method Instance() Method Creating and Using Sockets Creating TCP Clients and Servers TCP/IP Client Sockets xxiii

20 Understanding the Whois Example TCP/IP Server Sockets Submitting an HTML Form from a Java Program Handling URL Using the URLConnection Objects Working with Datagrams DatagramPacket Datagrams Server and Client Working with BART Learning about the java.security Package The Permission Class The Policy Class Summary Chapter 21: Collections In Depth The Collection Interfaces The Collection Classes The Map Interfaces The Map Classes Collections Framework Enhancements in Java SE Support for Lambda Expressions, Streams, and Aggregate Operations Performance Improvement for HashMaps with Key Collisions Improved Type Inference Immediate Solutions Using the Collection Interface The Queue Interface The List Interface The Set Interface The SortedSet Interface Using the Collection Classes The AbstractCollection Class The AbstractList Class The AbstractSequentialList Class The ArrayList Class The ArrayDeque Class The LinkedList Class xxiv

21 The Generic Class The HashSet Class The TreeSet Class Using the Comparator Interface Using the Iterator Interface Using the ListIterator Interface Using the AbstractMap Class Using the HashMap Class Using the TreeMap Class Using the Arrays Class Learning the Fundamentals of Enumerations The values() and valueof() Methods Java Enumeration as a Class Type Enumeration Inheriting Enum The Enumeration Interface The Legacy Classes and Interfaces The Vector Class The Stack Class The Dictionary Class The Hashtable Class The Properties Class Using the Aggregate Operations Using the java.util.function Package Summary Chapter 22: Creating Packages, Interfaces, JAR Files, and Annotations In Depth Packages and Interfaces JAR Files The Core Java API Package The java.lang Package The java.lang.annotation Subpackage The java.lang.instrument Subpackage The java.lang.management Subpackage The java.lang.reflect Subpackage The java.lang.invoke Subpackage The java.lang.ref Subpackage xxv

22 Basics of Annotation Other Built-In Annotations... Annotation... Annotation... Annotation... Annotation... Annotation... Annotation... Annotation... Annotation... Annotation... Annotation... SafeVarargs Type Annotations and Pluggable Type Systems Repeating Annotations Retrieving Annotations Immediate Solutions Creating a Package Creating Packages that have Subpackages Creating an Interface Implementing an Interface Extending an Interface Using Interfaces for Callbacks Performing Operations on a JAR File Creating a JAR File Getting the Contents of a JAR File Extracting Files from a JAR File Updating JAR Files Reading from JAR Files in Code Using javac to Get Classes from a JAR File Letting Applets Get Classes from JAR Files Marker Annotations Single Member Annotations Summary xxvi

23 Chapter 23: Working with Java Beans In Depth What is Java Bean? Advantages of Java Bean Introspection Design Patterns for Properties Design Patterns for Events Methods and Design Patterns Using the BeanInfo Interface Persistence Customizers Immediate Solutions Understanding Java Beans Designing Programs Using Java Beans Creating Applets that Use Java Beans Creating a Java Bean Creating a Bean Manifest File Creating a Bean JAR File Creating a New Bean Adding Controls to Beans Giving a Bean Properties Design Patterns for Properties Using Simple Properties Adding a Color Property to SimpleBean Using Indexed Properties Using Boolean Properties Designing Patterns for Events Learning Methods and Design Patterns Using the BeanInfo Interface Using Feature Descriptors Creating Bound Properties Giving a Bean Methods Giving a Bean an Icon Creating a BeanInfo Class Setting Bound and Constrained Properties xxvii

24 Implementing Persistence Using the Java Beans API Learning the Basics of an Event Using the Java Beans Conventions Using the Remote Notification and Distributed Notification Using Beans with JSP Summary Chapter 24: Introducing JDBC In Depth What does JDBC Do? Components of JDBC JDBC Specification JDBC Architecture The JDBC Package The java.sql Package The javax.sql Package JDBC versus ODBC and Other APIs Relation between JDBC and ODBC Various Kinds of JDBC Drivers Describing the Type-1 Driver Describing the Type-2 Driver (Java to Native API) Describing the Type-3 Driver (Java to Network Protocol/All Java Driver) Describing the Type-4 Driver (Java to Database Protocol) The JavaSoft Framework Two-Tier and Three-Tier Models The Structured Query Language (SQL) Immediate Solutions Learning about the Driver Interface Learning about the DriverManager Class The Connection Interface The Statement Interface The PreparedStatement Interface Comparing the Execution Control of the Statement and PreparedStatement Describing the setxxx() Methods of the PreparedStatement Interface Advantages and Disadvantages of Using a PreparedStatement Object xxviii

25 Using the PreparedStatement Interface Create a PreparedStatement Object Provide the Values of the PreparedStatement Parameters Execute the SQL Statements The ResultSet Interface Describing the Methods of ResultSet Using ResultSet Moving the Cursor Position Reading the Column Values The ResultSetMetaData Interface Describing the ResultSetMetaData Interface Using the ResultSetMetaData Interface Implementing JDBC Processes with java.sql Package Understanding the Basic JDBC Steps Processing the ResultSet Using the ResultSet Object to Update Data Using the ResultSet Object to Delete a Row Using a ResultSet Object to Insert a Row Closing the Statement Closing the Connection Using a Loop to Set Values in PreparedStatement Object Returning Values for the executeupdate() Method Using the Interactive SQL Tool Summary Chapter 25: Images and Animation In Depth Images Different Formats of Images The ImageIcon Class The java.awt.geom Package Immediate Solutions Using the Image Class Creating an Image Loading an Image Displaying an Image Drawing an Image Object xxix

26 Loading an Image Object Using the ImageObserver Interface Using the MediaTracker Class Using the ImageIcon Class in an Applet Getting Images Drawing Images Using ImageObserver Interface Creating a Game Using the java.awt.geom Package Collecting the Images Organizing and Loading the Images in the Applet Animating the Images Finishing Up Summary Chapter 26: Java DB In Depth Evolution of Java DB Comparisons between Java DB and MySQL Architecture of Java DB Embedded Architecture Client/Server Architecture Compilation of SQL into Java Bytecode Drivers of Java DB Java DB URLs Java DB Product Documentation Derby Tools and Utilities Installing and Configuring Java DB on Windows Immediate Solutions Configure Environment Variables DERBY_HOME PATH JAVA_HOME Java DB Directory Structure Creating Database in Java DB Using ij-tool Creating a New Database in Embedded Mode Creating a New Database in Network Mode Connecting with a Database Connecting with a Database in Embedded Mode xxx

27 Connecting with a Database in Network Mode Disconnecting from a Database Adding Tables in an Existing Database Deleting Tables from an Existing Database Adding Data into a Table Displaying Content of a Table Java DB Database Encryption Using Java DB with Java Application Summary Chapter 27: Java FX In Depth Working with JavaFX JavaFX Applications JavaFX Availability Key Features of JavaFX Application Development Scope of JavaFX JavaFX Ensemble Modena DViewer JavaFX Architecture Scene Graph in JavaFX Java Public APIs for JavaFX Features Graphics System Glass Windowing Toolkit Threads Pulse Media and Images Web Component CSS UI Controls Layout D and 3-D Transformations Visual Effects Introducing Scene Builder in JavaFX Intended Audience Key Features of JavaFX Scene Builder xxxi

28 Immediate Solutions Creating Simple JavaFX Application Creating JavaFX Application on NetBeans IDE Using the UI Controls Using Visual Effects Using Canvas API Summary Glossary Index Bonus chapters available with the book for Download Chapter 1: Java and XML Using the Document Object Model... 1 Chapter 2: Java and XML Using the Simple API for XML Chapter 3: Understanding RMI Chapter 4: Working with Servlets Chapter 5: Dynamic Java Scripting Chapter 6: Introduction to Groovy Chapter 7: MXBeans and JMX Chapter 8: Inclusion of Sound Chapter 9: Filing and Printing Documents xxxii