book

Learning Java, 4th Edition

by Patrick Niemeyer, Daniel Leuck

June 2013

Beginner

1007 pages

33h 32m

English

O'Reilly Media, Inc.

Read now

Unlock full access

New in This Edition (Java 6 and 7)

Java’s OriginsGrowing Up
Simplify, Simplify, Simplify...Type Safety and Method BindingIncremental DevelopmentDynamic Memory ManagementError HandlingThreadsScalability
The VerifierClass LoadersSecurity Managers
The Past: Java 1.0–Java 1.6The Present: Java 7The FutureAvailability
Importing the Learning Java Examples
ClassesThe main() MethodClasses and ObjectsVariables and Class TypesHelloComponentInheritanceThe JComponent ClassRelationships and Finger PointingPackage and ImportsThe paintComponent() Method
Instance VariablesConstructorsEventsThe repaint() MethodInterfaces
Method OverloadingComponentsContainersLayoutSubclassing and SubtypesMore Events and InterfacesColor CommentaryStatic MembersArraysOur Color Methods
ThreadsThe Thread ClassThe Runnable InterfaceStarting the ThreadRunning Code in the ThreadExceptionsSynchronization
System Properties
javap
File CompressionThe jar UtilityJAR manifestsMaking a JAR file runnableThe pack200 Utility
The Default Security ManagerThe policytool UtilityUsing a Policy File with the Default Security Manager
Javadoc CommentsJavadoc as metadata
Primitive TypesFloating-point precisionVariable declaration and initializationInteger literalsFloating-point literalsBinary literalsCharacter literalsReference TypesA Word About Strings
Statementsif/else conditionalsdo/while loopsThe for loopThe enhanced for loopswitch statementsEnumerations and switch statementsbreak/continueUnreachable statementsExpressionsOperatorsAssignmentThe null valueVariable accessMethod invocationObject creationThe instanceof operator
Exceptions and Error ClassesException HandlingBubbling UpStack TracesChecked and Unchecked ExceptionsThrowing ExceptionsChaining and rethrowing exceptionsNarrowed rethrowtry CreepThe finally ClauseTry with ResourcesPerformance Issues
Enabling and Disabling AssertionsUsing Assertions
Array TypesArray Creation and InitializationUsing ArraysAnonymous ArraysMultidimensional ArraysInside Arrays
Accessing Fields and MethodsStatic MembersConstants versus enumerations
Local VariablesShadowingThe “this” referenceStatic MethodsInitializing Local VariablesArgument Passing and ReferencesWrappers for Primitive TypesAutoboxing and Unboxing of PrimitivesPerformance implications of boxingVariable-Length Argument ListsMethod Overloading
ConstructorsWorking with Overloaded ConstructorsStatic and Nonstatic Initializer Blocks
Garbage CollectionFinalizationWeak and Soft References
Enum ValuesCustomizing Enumerations
Shadowed VariablesOverriding Methods@OverrideOverridden methods and dynamic bindingStatic method bindingfinal methods and performanceCompiler optimizationsMethod selection revisitedExceptions and overridden methodsReturn types and overridden methodsSpecial References: this and superCastingCasting aspersionsUsing Superclass ConstructorsFull Disclosure: Constructors and InitializationAbstract Methods and Classes
Interfaces as CallbacksInterface VariablesFlag interfacesSubinterfacesOverlapping and conflicting methods
Compilation UnitsPackage NamesClass VisibilityImporting ClassesThe unnamed packageStatic imports
Basic Access ModifiersSubclasses and VisibilityInterfaces and Visibility
ArrayStoreException
Inner Classes as AdaptersInner Classes Within MethodsLimitations on inner classes in methodsStatic inner classesAnonymous inner classesScoping of the “this” referenceHow do inner classes really work?Security implications
Equality and EquivalenceHashcodesCloning Objects
Modifiers and SecurityAccessing FieldsAccessing MethodsAccessing ConstructorsWhat About Arrays?Accessing Generic Type InformationAccessing Annotation DataDynamic Interface AdaptersWhat Is Reflection Good For?The BeanShell Java scripting language
Using AnnotationsPackage annotationsStandard AnnotationsThe apt Tool
Can Containers Be Fixed?
Talking About Types
ErasureRaw Types
Why Isn’t a List<Date> a List<Object>?
The Type VariableSubclassing GenericsExceptions and GenericsNo generic throwablesParameter Type LimitationsUsing Class<T>
Erasure and Bounds (Working with Legacy Code)
A Supertype of All InstantiationsBounded WildcardsThinking Outside the ContainerLower BoundsReading, Writing, and Arithmetic<?>, <Object>, and the Raw TypeWildcard Type Relationships
Generic Methods IntroducedType Inference from ArgumentsType Inference from Assignment ContextExplicit Type InvocationWildcard CaptureWildcard Types Versus Generic Methods
Using Array TypesWhat Good Are Arrays of Generic Types?Wildcards in Array Types
The Thread Class and the Runnable InterfaceCreating and starting threadsA natural-born threadUsing an adapterControlling ThreadsDeprecated methodsThe sleep() methodThe join() methodThe interrupt() methodDeath of a Thread
Issues Lurking
Serializing Access to MethodsAccessing class and instance Variables from Multiple ThreadsReentrant lockingThe wait() and notify() MethodsWait conditionsPassing MessagesFood for thoughtThreadLocal Objects
Thread StateTime-SlicingPrioritiesYielding
Working with ThreadGroupsUncaught Exceptions
The Cost of SynchronizationThread Resource Consumption
ExecutorsTasks with results: Callable and FutureExecutorServiceCollective tasksScheduled tasksCompletionServiceThe ThreadPoolExecutor implementationThread productionThe Fork/Join frameworkLocksRead and write locksConditionsSynchronization ConstructsCountDownLatchSemaphoreCyclicBarrierauthor="pat” timestamp="20120806T231934-0500” comment="I'm not sure if we need to recast our example using Phaser or replace it... I think Phaser pretty much replaces CyclicBarrier, but it is only in Java 7... so normally we'd show both... but they are very similar... Also I'm tired :)”PhaserExchangerAtomic OperationsWeak implementationsField updaters
Constructing StringsStrings from ThingsComparing StringsThe Collator classSearchingEditingString Method SummaryStringBuilder and StringBuffer
The java.util.Locale ClassResource Bundles
Parsing Primitive NumbersWorking with alternate basesNumber formatsTokenizing TextStringTokenizer
FormatterThe Format StringString ConversionsWidth, precision, and justificationUppercaseNumbered argumentsPrimitive and Numeric ConversionsFlagsMiscellaneous
MessageFormat
Regex NotationWrite once, run awayEscaped charactersCharacters and character classesCustom character classesPosition markersIteration (multiplicity)GroupingCapture groupsNumberingAlternationSpecial optionsGreedinessLookaheads and lookbehindsThe java.util.regex APIPatternThe MatcherSplitting and tokenizing stringsAnother look at ScannerReplacing textUsing captured text in a replacementControlling the substitutionOur simple template engine
The java.lang.Math ClassBig/Precise NumbersFloating-Point ComponentsRandom Numbers
Working with CalendarsTime ZonesLocaleParsing and Formatting with DateFormatPrintf-Style Date and Time Formatting
The Collection InterfaceGenerics and collectionsLegacy code and runtime type safetyConverting between collections and arraysIteratorFor loop over collectionsjava.util.EnumerationCollection TypesSetListQueueBlockingQueueThe Map InterfaceConcurrentMapCollection ImplementationsArraysLinked listsTreesHash mapsJava Collections implementationsHash Codes and Key ValuesSynchronized and Unsynchronized CollectionsSynchronizing iteratorsConcurrentHashMap and ConcurrentLinkedQueueRead-Only and Read-Mostly CollectionsCopy-on-write (“read-mostly”) collectionsWeakHashMapEnumSet and EnumMapSorting CollectionsA Thrilling Example
Loading and StoringSystem Properties
Preferences for ClassesPreferences StorageChange Notification
OverviewLoggersHandlersFiltersFormattersLogging LevelsA Simple ExampleLogging Setup PropertiesThe LoggerPerformance
Basic I/OCharacter StreamsStream WrappersData streamsBuffered streamsPrintWriter and PrintStreamPipesStreams from Strings and BackImplementing a Filter Stream
The java.io.File ClassFile constructorsPath localizationFile operationsFile StreamsRandomAccessFileResource Paths
FileSystem and PathPath to classic file and backNIO File OperationsDirectory OperationsWatching Paths
Initialization with readObject()SerialVersionUID
Archives and Compressed DataZip archivesDecompressing DataZip Archive As a Filesystem
Asynchronous I/OPerformanceMapped and Locked FilesChannelsBuffersBuffer operationsBuffer typesByte orderAllocating buffersCharacter Encoders and DecodersCharsetEncoder and CharsetDecoderFileChannelConcurrent accessFile lockingMemory-mapped filesDirect transferAsynchronousFileChannelScalable I/O with NIO
Clients and ServersClientsServersSockets and securityauthor="pat” timestamp="20120926T110720-0500” comment="one of those sections I hate to get rid of but is less relevant in terms of the example... should probably find a more modern example...”The DateAtHost ClientThe TinyHttpd ServerDo French web servers speak French?Taming the daemonRoom for improvementSocket OptionsSO_TIMEOUTTCP_NODELAYSO_LINGERTCP_KEEPALIVEHalf-closeProxies and FirewallsProxySelector
author="pat” timestamp="20120926T141346-0500” comment="I actually rewrote this as a standalone client but then decided to leave it as an applet”The HeartBeat AppletThe HeartBeat applet codeThe Pulse server codeInetAddress
A Simple Object-Based ServerLimitations
Real-World UsageRemote and Nonremote ObjectsRemote interfacesExporting remote objectsThe RMI registryAn RMI ExampleRunning the exampleDynamic class loadingPassing remote object referencesRMI and CORBA
Selectable ChannelsUsing SelectLargerHttpdNonblocking Client-Side Operations
Stream DataGetting the Content as an ObjectManaging ConnectionsHandlers in PracticeUseful Handler Frameworks
Using the GET MethodUsing the POST MethodThe HttpURLConnectionSSL and Secure Web CommunicationsURLs, URNs, and URIs
XML-RPCWSDLThe ToolsThe Weather Service Client
Page-Oriented Versus “Single Page” ApplicationsJSPsXML and XSLWeb Application FrameworksGoogle Web ToolkitHTML5, AJAX, and More...
The Servlet LifecycleServletsThe HelloClient ServletServletExceptionsContent typeThe Servlet ResponseServlet ParametersGET, POST, and “extra path”GET or POST: Which one to use?The ShowParameters ServletUser Session ManagementThe ShowSession ServletThe ShoppingCart ServletCookiesThe ServletContext APIAsynchronous Servlets
Configuration with web.xml and AnnotationsURL Pattern MappingsDeploying HelloClientReloading web appsError and Index PagesSecurity and AuthenticationProtecting Resources with RolesSecure Data TransportAuthenticating UsersProcedural Authorization
A Simple FilterA Test ServletDeclaring and Mapping FiltersFiltering the Servlet RequestFiltering the Servlet Response
A Development-Oriented Directory LayoutDeploying and Redeploying WARs with Ant
Defining the ServiceOur Echo ServiceUsing the ServiceData TypesStandard typesValue data objects
Peers and Look-and-FeelThe MVC FrameworkPaintingEnabling and Disabling ComponentsFocus, PleaseOther Component MethodsContainersLayout ManagersInsetsZ-Ordering (Stacking Components)The revalidate() and doLayout() MethodsManaging ComponentsListening for ComponentsWindows, Frames and Splash ScreensOther Methods for Controlling FramesContent PanesDesktop Integration
Event Receivers and Listener InterfacesEvent SourcesEvent DeliveryEvent TypesThe java.awt.event.InputEvent ClassMouse and Key Modifiers on InputEventsMouse-wheel eventsFocus Events
Adapter ClassesDummy Adapters
HTML Text in Buttons and Labels
Component-Managed Pop Ups
File Selection DialogThe Color Chooser
The TextEntryBox ApplicationFormatted TextFiltering InputDocumentFilterValidating DataSay the Magic WordSharing a Data ModelHTML and RTF for FreeManaging Text Yourself
TreesNodes and ModelsSave a TreeTree EventsA Complete Example
A First Stab: FreeloadingRound Two: Creating a Table ModelRound Three: A Simple SpreadsheetSorting and FilteringPrinting JTables
Generating EventsA Dial ComponentModel and View Separation
The GridBagConstraints ClassGrid CoordinatesThe fill ConstraintSpanning Rows and ColumnsWeightingCalculating the weights of rows and columnsAnchoringPadding and InsetsRelative PositioningComposite Layouts
Filling ShapesDrawing Shape OutlinesConvenience MethodsDrawing TextDrawing ImagesTransformations and renderingThe Whole Iguana
Solid ColorsColor GradientsTexturesDesktop Colors
Font Metrics
The Image ClassImage ObserversPreloading imagesScaling and Size
Double BufferingLimiting Drawing with ClippingOffscreen Drawing
ImageObserverMediaTrackerImageIconImageIO
Drawing AnimationsBufferedImage AnatomyColor ModelsCreating an ImageUpdating a BufferedImage
How ImageProcessor WorksConverting an Image to a BufferedImageUsing the RescaleOp ClassUsing the AffineTransformOp Class
What Constitutes a Bean?
Installing and Running NetBeansInstalling our example beansCreating a project and fileThe NetBeans workspace
Taming the JugglerRunning the exampleMolecular Motion
Constraining Properties
The Dial BeanDesign Patterns for PropertiesGenerating bean patterns in NetBeans
Getting Properties InformationGetting events informationSupplying iconsCreating customizers and property editors
Bean Instantiation and Type ManagementWorking with Serialized BeansRuntime Event Hookups with ReflectionHow it works
Applet LifecycleThe Applet Security SandboxTrusted appletsGetting Applet ResourcesApplet parametersApplet resourcesDriving the browserInter-applet communicationApplet persistence and navigationThe <applet> TagAttributesParameters¿Habla Applet?The Complete <applet> TagLoading Class FilesPackagesappletviewer
Text Versus BinaryA Universal ParserThe State of XMLThe XML APIsXML and Web Browsers
AttributesXML DocumentsEncodingNamespacesValidationHTML to XHTML
The SAX APIJAXPSAX’s strengths and weaknessesBuilding a Model Using SAXCreating the XML fileThe modelThe SAXModelBuilderTest driveLimitations and possibilitiesXMLEncoder/Decoder
The DOM APITest-Driving DOMGenerating XML with DOMJDOM
NodesPredicatesFunctionsThe XPath APIXMLGrep
Enabling XInclude
Using Document ValidationDTDsXML SchemaSimple typesComplex typesGenerating Schema from XML samplesThe Validation APIAlternative schema languages
Annotating Our ModelUnmarshalling from XMLGenerating a Java Model from an XML SchemaGenerating an XML Schema from a Java Model
XSL BasicsTransforming the Zoo InventoryXSLTransformXSL in the Browser
Importing the Learning Java Examples
Getting at the SourceThe Lay of the LandRunning the ExamplesBuilding the Ant-Based ExamplesLoner Examples
Coding ShortcutsAutocorrectionRefactoringDiffing FilesOrganizing ImportsFormatting Source Code
Imports
Scripting Interfaces and Adapters

Content preview from Learning Java, 4th Edition

Eclipse Features

Eclipse has too many interesting features to really do them justice here, but we’ll mention a few to show you why people love this IDE.

Coding Shortcuts

Of course, you’ve noticed all the color coding and meta-information present when viewing Java source code in Eclipse. You can customize all of this behavior to suit your taste through the Eclipse → Preferences → Java → Editor → Syntax Coloring panel. Many other options can be set through the Eclipse → Preferences → Java → Code Style and Editor panes.

What may not be immediately obvious is that editing is also enhanced. When typing, try pressing Ctrl-Space to attempt autocompletion or have Eclipse present you with relevant options. For example, instead of typing JButton, try typing JBu plus Ctrl-Space. Eclipse completes the name for you. If the portion of the name you type is ambiguous, a drop-down list appears, similar to that shown in Figure A-5.

Eclipse also provides abbreviations for common items. Try typing sysout and pressing Crtl-Space. Eclipse expands this to System.out.println() and places the cursor in the parentheses automatically. If you type a quotation mark, Eclipse closes the quotation for you. Note the green bar that it places after the closing quote. Pressing Tab takes you to that point so that you don’t have to use the arrow keys. Pressing Tab again takes you to the next green bar spot, which is the end of the line.

Figure A-5. Using completion in Eclipse