book

Learning Java, 4th Edition

Name: Learning Java, 4th Edition
ISBN: 9781449319243

by Patrick Niemeyer, Daniel Leuck

June 2013

Beginner

1007 pages

33h 32m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Learning Java
Preface
Who Should Read This Book
New Developments
New in This Edition (Java 6 and 7)
Using This Book
Online Resources
Conventions Used in This Book
Using Code Examples
Safari® Books Online
How to Contact Us

Acknowledgments
1. A Modern Language
Enter Java
Java’s OriginsGrowing Up
A Virtual Machine
Java Compared with Other Languages
Safety of Design
Simplify, Simplify, Simplify...Type Safety and Method BindingIncremental DevelopmentDynamic Memory ManagementError HandlingThreadsScalability
Safety of Implementation
The VerifierClass LoadersSecurity Managers
Application and User-Level Security
A Java Road Map
The Past: Java 1.0–Java 1.6The Present: Java 7The FutureAvailability
2. A First Application
Java Tools and Environment
Configuring Eclipse and Creating a Project
Importing the Learning Java Examples
HelloJava
ClassesThe main() MethodClasses and ObjectsVariables and Class TypesHelloComponentInheritanceThe JComponent ClassRelationships and Finger PointingPackage and ImportsThe paintComponent() Method
HelloJava2: The Sequel
Instance VariablesConstructorsEventsThe repaint() MethodInterfaces
HelloJava3: The Button Strikes!
Method OverloadingComponentsContainersLayoutSubclassing and SubtypesMore Events and InterfacesColor CommentaryStatic MembersArraysOur Color Methods
HelloJava4: Netscape’s Revenge
ThreadsThe Thread ClassThe Runnable InterfaceStarting the ThreadRunning Code in the ThreadExceptionsSynchronization
3. Tools of the Trade
JDK Environment
The Java VM
Running Java Applications
System Properties
The Classpath
javap
The Java Compiler
JAR Files
File CompressionThe jar UtilityJAR manifestsMaking a JAR file runnableThe pack200 Utility
Policy Files
The Default Security ManagerThe policytool UtilityUsing a Policy File with the Default Security Manager
4. The Java Language
Text Encoding
Comments
Javadoc CommentsJavadoc as metadata
Types
Primitive TypesFloating-point precisionVariable declaration and initializationInteger literalsFloating-point literalsBinary literalsCharacter literalsReference TypesA Word About Strings
Statements and Expressions
Statementsif/else conditionalsdo/while loopsThe for loopThe enhanced for loopswitch statementsEnumerations and switch statementsbreak/continueUnreachable statementsExpressionsOperatorsAssignmentThe null valueVariable accessMethod invocationObject creationThe instanceof operator
Exceptions
Exceptions and Error ClassesException HandlingBubbling UpStack TracesChecked and Unchecked ExceptionsThrowing ExceptionsChaining and rethrowing exceptionsNarrowed rethrowtry CreepThe finally ClauseTry with ResourcesPerformance Issues
Assertions
Enabling and Disabling AssertionsUsing Assertions
Arrays
Array TypesArray Creation and InitializationUsing ArraysAnonymous ArraysMultidimensional ArraysInside Arrays
5. Objects in Java
Classes
Accessing Fields and MethodsStatic MembersConstants versus enumerations
Methods
Local VariablesShadowingThe “this” referenceStatic MethodsInitializing Local VariablesArgument Passing and ReferencesWrappers for Primitive TypesAutoboxing and Unboxing of PrimitivesPerformance implications of boxingVariable-Length Argument ListsMethod Overloading
Object Creation
ConstructorsWorking with Overloaded ConstructorsStatic and Nonstatic Initializer Blocks
Object Destruction
Garbage CollectionFinalizationWeak and Soft References
Enumerations
Enum ValuesCustomizing Enumerations
6. Relationships Among Classes
Subclassing and Inheritance
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
Interfaces as CallbacksInterface VariablesFlag interfacesSubinterfacesOverlapping and conflicting methods
Packages and Compilation Units
Compilation UnitsPackage NamesClass VisibilityImporting ClassesThe unnamed packageStatic imports
Visibility of Variables and Methods
Basic Access ModifiersSubclasses and VisibilityInterfaces and Visibility
Arrays and the Class Hierarchy
ArrayStoreException
Inner Classes
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
7. Working with Objects and Classes
The Object Class
Equality and EquivalenceHashcodesCloning Objects
The Class Class
Reflection
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
Annotations
Using AnnotationsPackage annotationsStandard AnnotationsThe apt Tool
8. Generics
Containers: Building a Better Mousetrap
Can Containers Be Fixed?
Enter Generics
Talking About Types
“There Is No Spoon”
ErasureRaw Types
Parameterized Type Relationships
Why Isn’t a List<Date> a List<Object>?
Casts
Writing Generic Classes
The Type VariableSubclassing GenericsExceptions and GenericsNo generic throwablesParameter Type LimitationsUsing Class<T>
Bounds
Erasure and Bounds (Working with Legacy Code)
Wildcards
A Supertype of All InstantiationsBounded WildcardsThinking Outside the ContainerLower BoundsReading, Writing, and Arithmetic<?>, <Object>, and the Raw TypeWildcard Type Relationships
Generic Methods
Generic Methods IntroducedType Inference from ArgumentsType Inference from Assignment ContextExplicit Type InvocationWildcard CaptureWildcard Types Versus Generic Methods
Arrays of Parameterized Types
Using Array TypesWhat Good Are Arrays of Generic Types?Wildcards in Array Types
Case Study: The Enum Class
Case Study: The sort() Method
Conclusion
9. Threads
Introducing Threads
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
Threading an Applet
Issues Lurking
Synchronization
Serializing Access to MethodsAccessing class and instance Variables from Multiple ThreadsReentrant lockingThe wait() and notify() MethodsWait conditionsPassing MessagesFood for thoughtThreadLocal Objects
Scheduling and Priority
Thread StateTime-SlicingPrioritiesYielding
Thread Groups
Working with ThreadGroupsUncaught Exceptions
Thread Performance
The Cost of SynchronizationThread Resource Consumption
Concurrency Utilities
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
Conclusion
10. Working with Text
Text-Related APIs
Strings
Constructing StringsStrings from ThingsComparing StringsThe Collator classSearchingEditingString Method SummaryStringBuilder and StringBuffer
Internationalization
The java.util.Locale ClassResource Bundles
Parsing and Formatting Text
Parsing Primitive NumbersWorking with alternate basesNumber formatsTokenizing TextStringTokenizer
Printf-Style Formatting
FormatterThe Format StringString ConversionsWidth, precision, and justificationUppercaseNumbered argumentsPrimitive and Numeric ConversionsFlagsMiscellaneous
Formatting with the java.text Package
MessageFormat
Regular Expressions
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
11. Core Utilities
Math Utilities
The java.lang.Math ClassBig/Precise NumbersFloating-Point ComponentsRandom Numbers
Dates and Times
Working with CalendarsTime ZonesLocaleParsing and Formatting with DateFormatPrintf-Style Date and Time Formatting
Timers
Collections
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
Properties
Loading and StoringSystem Properties
The Preferences API
Preferences for ClassesPreferences StorageChange Notification
The Logging API
OverviewLoggersHandlersFiltersFormattersLogging LevelsA Simple ExampleLogging Setup PropertiesThe LoggerPerformance
Observers and Observables
12. Input/Output Facilities
Streams
Basic I/OCharacter StreamsStream WrappersData streamsBuffered streamsPrintWriter and PrintStreamPipesStreams from Strings and BackImplementing a Filter Stream
File I/O
The java.io.File ClassFile constructorsPath localizationFile operationsFile StreamsRandomAccessFileResource Paths
The NIO File API
FileSystem and PathPath to classic file and backNIO File OperationsDirectory OperationsWatching Paths
Serialization
Initialization with readObject()SerialVersionUID
Data Compression
Archives and Compressed DataZip archivesDecompressing DataZip Archive As a Filesystem
The NIO Package
Asynchronous I/OPerformanceMapped and Locked FilesChannelsBuffersBuffer operationsBuffer typesByte orderAllocating buffersCharacter Encoders and DecodersCharsetEncoder and CharsetDecoderFileChannelConcurrent accessFile lockingMemory-mapped filesDirect transferAsynchronousFileChannelScalable I/O with NIO
13. Network Programming
Sockets
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
Datagram Sockets
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
Simple Serialized Object Protocols
A Simple Object-Based ServerLimitations
Remote Method Invocation
Real-World UsageRemote and Nonremote ObjectsRemote interfacesExporting remote objectsThe RMI registryAn RMI ExampleRunning the exampleDynamic class loadingPassing remote object referencesRMI and CORBA
Scalable I/O with NIO
Selectable ChannelsUsing SelectLargerHttpdNonblocking Client-Side Operations
14. Programming for the Web
Uniform Resource Locators (URLs)
The URL Class
Stream DataGetting the Content as an ObjectManaging ConnectionsHandlers in PracticeUseful Handler Frameworks
Talking to Web Applications
Using the GET MethodUsing the POST MethodThe HttpURLConnectionSSL and Secure Web CommunicationsURLs, URNs, and URIs
Web Services
XML-RPCWSDLThe ToolsThe Weather Service Client
15. Web Applications and Web Services
Web Application Technologies
Page-Oriented Versus “Single Page” ApplicationsJSPsXML and XSLWeb Application FrameworksGoogle Web ToolkitHTML5, AJAX, and More...
Java Web Applications
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
WAR Files and Deployment
Configuration with web.xml and AnnotationsURL Pattern MappingsDeploying HelloClientReloading web appsError and Index PagesSecurity and AuthenticationProtecting Resources with RolesSecure Data TransportAuthenticating UsersProcedural Authorization
Servlet Filters
A Simple FilterA Test ServletDeclaring and Mapping FiltersFiltering the Servlet RequestFiltering the Servlet Response
Building WAR Files with Ant
A Development-Oriented Directory LayoutDeploying and Redeploying WARs with Ant
Implementing Web Services
Defining the ServiceOur Echo ServiceUsing the ServiceData TypesStandard typesValue data objects
Conclusion
16. Swing
Components
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
Events
Event Receivers and Listener InterfacesEvent SourcesEvent DeliveryEvent TypesThe java.awt.event.InputEvent ClassMouse and Key Modifiers on InputEventsMouse-wheel eventsFocus Events
Event Summary
Adapter ClassesDummy Adapters
The AWT Robot!
Multithreading in Swing
17. Using Swing Components
Buttons and Labels
HTML Text in Buttons and Labels
Checkboxes and Radio Buttons
Lists and Combo Boxes
The Spinner
Borders
Menus
Pop-Up Menus
Component-Managed Pop Ups
The JScrollPane Class
The JSplitPane Class
The JTabbedPane Class
Scrollbars and Sliders
Dialogs
File Selection DialogThe Color Chooser
18. More Swing Components
Text Components
The TextEntryBox ApplicationFormatted TextFiltering InputDocumentFilterValidating DataSay the Magic WordSharing a Data ModelHTML and RTF for FreeManaging Text Yourself
Focus Navigation
TreesNodes and ModelsSave a TreeTree EventsA Complete Example
Tables
A First Stab: FreeloadingRound Two: Creating a Table ModelRound Three: A Simple SpreadsheetSorting and FilteringPrinting JTables
Desktops
Pluggable Look-and-Feel
Creating Custom Components
Generating EventsA Dial ComponentModel and View Separation
19. Layout Managers
FlowLayout
GridLayout
BorderLayout
BoxLayout
CardLayout
GridBagLayout
The GridBagConstraints ClassGrid CoordinatesThe fill ConstraintSpanning Rows and ColumnsWeightingCalculating the weights of rows and columnsAnchoringPadding and InsetsRelative PositioningComposite Layouts
Other Layout Managers
Absolute Positioning
20. Drawing with the 2D API
The Big Picture
The Rendering Pipeline
A Quick Tour of Java 2D
Filling ShapesDrawing Shape OutlinesConvenience MethodsDrawing TextDrawing ImagesTransformations and renderingThe Whole Iguana
Filling Shapes
Solid ColorsColor GradientsTexturesDesktop Colors
Stroking Shape Outlines
Using Fonts
Font Metrics
Displaying Images
The Image ClassImage ObserversPreloading imagesScaling and Size
Drawing Techniques
Double BufferingLimiting Drawing with ClippingOffscreen Drawing
Printing
21. Working with Images and Other Media
Loading Images
ImageObserverMediaTrackerImageIconImageIO
Producing Image Data
Drawing AnimationsBufferedImage AnatomyColor ModelsCreating an ImageUpdating a BufferedImage
Filtering Image Data
How ImageProcessor WorksConverting an Image to a BufferedImageUsing the RescaleOp ClassUsing the AffineTransformOp Class
Saving Image Data
Simple Audio
Java Media Framework
22. JavaBeans
What’s a Bean?
What Constitutes a Bean?
The NetBeans IDE
Installing and Running NetBeansInstalling our example beansCreating a project and fileThe NetBeans workspace
Properties and Customizers
Event Hookups and Adapters
Taming the JugglerRunning the exampleMolecular Motion
Binding Properties
Constraining Properties
Building Beans
The Dial BeanDesign Patterns for PropertiesGenerating bean patterns in NetBeans
Limitations of Visual Design
Serialization Versus Code Generation
Customizing with BeanInfo
Getting Properties InformationGetting events informationSupplying iconsCreating customizers and property editors
Handcoding with Beans
Bean Instantiation and Type ManagementWorking with Serialized BeansRuntime Event Hookups with ReflectionHow it works
BeanContext and BeanContextServices
The Java Activation Framework
Enterprise JavaBeans and POJO-Based Enterprise Frameworks
23. Applets
The Politics of Browser-Based Applications
Applet Support and the Java Plug-in
The JApplet Class
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
Java Web Start
Conclusion
24. XML
The Butler Did It
A Bit of Background
Text Versus BinaryA Universal ParserThe State of XMLThe XML APIsXML and Web Browsers
XML Basics
AttributesXML DocumentsEncodingNamespacesValidationHTML to XHTML
SAX
The SAX APIJAXPSAX’s strengths and weaknessesBuilding a Model Using SAXCreating the XML fileThe modelThe SAXModelBuilderTest driveLimitations and possibilitiesXMLEncoder/Decoder
DOM
The DOM APITest-Driving DOMGenerating XML with DOMJDOM
XPath
NodesPredicatesFunctionsThe XPath APIXMLGrep
XInclude
Enabling XInclude
Validating Documents
Using Document ValidationDTDsXML SchemaSimple typesComplex typesGenerating Schema from XML samplesThe Validation APIAlternative schema languages
JAXB Code Binding and Generation
Annotating Our ModelUnmarshalling from XMLGenerating a Java Model from an XML SchemaGenerating an XML Schema from a Java Model
Transforming Documents with XSL/XSLT
XSL BasicsTransforming the Zoo InventoryXSLTransformXSL in the Browser
Web Services
The End of the Book
A. The Eclipse IDE
The IDE Wars
Getting Started with Eclipse
Importing the Learning Java Examples
Using Eclipse
Getting at the SourceThe Lay of the LandRunning the ExamplesBuilding the Ant-Based ExamplesLoner Examples
Eclipse Features
Coding ShortcutsAutocorrectionRefactoringDiffing FilesOrganizing ImportsFormatting Source Code
Conclusion
B. BeanShell: Java Scripting
Running BeanShell
Java Statements and Expressions
Imports
BeanShell Commands
Scripted Methods and Objects
Scripting Interfaces and Adapters
Changing the Classpath
Learning More . . .
Glossary
Index
About the Authors
Colophon
Copyright

404

Not Found

Either this content does not exist or you do not have access to it. Try searching for something new.

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Learning Java, 4th Edition

by Patrick Niemeyer, Daniel Leuck

404

Not Found