book

Java: The Complete Reference, Twelfth Edition, 12th Edition

by Herbert Schildt

November 2021

Intermediate to advanced

1280 pages

34h 57m

English

McGraw-Hill

Read now

Unlock full access

Java’s LineageThe Birth of Modern Programming: CC++: The Next StepThe Stage Is Set for JavaThe Creation of JavaThe C# ConnectionHow Java Impacted the InternetJava AppletsSecurityPortabilityJava’s Magic: The BytecodeMoving Beyond AppletsA Faster Release ScheduleServlets: Java on the Server SideThe Java BuzzwordsSimpleObject-OrientedRobustMultithreadedArchitecture-NeutralInterpreted and High PerformanceDistributedDynamicThe Evolution of JavaA Culture of Innovation

Object-Oriented ProgrammingTwo ParadigmsAbstractionThe Three OOP PrinciplesA First Simple ProgramEntering the ProgramCompiling the ProgramA Closer Look at the First Sample ProgramA Second Short ProgramTwo Control StatementsThe if StatementThe for LoopUsing Blocks of CodeLexical IssuesWhitespaceIdentifiersLiteralsCommentsSeparatorsThe Java KeywordsThe Java Class Libraries
Java Is a Strongly Typed LanguageThe Primitive TypesIntegersbyteshortintlongFloating-Point TypesfloatdoubleCharactersBooleansA Closer Look at LiteralsInteger LiteralsFloating-Point LiteralsBoolean LiteralsCharacter LiteralsString LiteralsVariablesDeclaring a VariableDynamic InitializationThe Scope and Lifetime of VariablesType Conversion and CastingJava’s Automatic ConversionsCasting Incompatible TypesAutomatic Type Promotion in ExpressionsThe Type Promotion RulesArraysOne-Dimensional ArraysMultidimensional ArraysAlternative Array Declaration SyntaxIntroducing Type Inference with Local VariablesSome var RestrictionsA Few Words About Strings
Arithmetic OperatorsThe Basic Arithmetic OperatorsThe Modulus OperatorArithmetic Compound Assignment OperatorsIncrement and DecrementThe Bitwise OperatorsThe Bitwise Logical OperatorsThe Left ShiftThe Right ShiftThe Unsigned Right ShiftBitwise Operator Compound AssignmentsRelational OperatorsBoolean Logical OperatorsShort-Circuit Logical OperatorsThe Assignment OperatorThe ? OperatorOperator PrecedenceUsing Parentheses
Java’s Selection StatementsifThe Traditional switchIteration Statementswhiledo-whileforThe For-Each Version of the for LoopLocal Variable Type Inference in a for LoopNested LoopsJump StatementsUsing breakUsing continuereturn
Class FundamentalsThe General Form of a ClassA Simple ClassDeclaring ObjectsA Closer Look at newAssigning Object Reference VariablesIntroducing MethodsAdding a Method to the Box ClassReturning a ValueAdding a Method That Takes ParametersConstructorsParameterized ConstructorsThe this KeywordInstance Variable HidingGarbage CollectionA Stack Class
Overloading MethodsOverloading ConstructorsUsing Objects as ParametersA Closer Look at Argument PassingReturning ObjectsRecursionIntroducing Access ControlUnderstanding staticIntroducing finalArrays RevisitedIntroducing Nested and Inner ClassesExploring the String ClassUsing Command-Line ArgumentsVarargs: Variable-Length ArgumentsOverloading Vararg MethodsVarargs and AmbiguityLocal Variable Type Inference with Reference Types
Inheritance BasicsMember Access and InheritanceA More Practical ExampleA Superclass Variable Can Reference a Subclass ObjectUsing superUsing super to Call Superclass ConstructorsA Second Use for superCreating a Multilevel HierarchyWhen Constructors Are ExecutedMethod OverridingDynamic Method DispatchWhy Overridden Methods?Applying Method OverridingUsing Abstract ClassesUsing final with InheritanceUsing final to Prevent OverridingUsing final to Prevent InheritanceLocal Variable Type Inference and InheritanceThe Object Class
PackagesDefining a PackageFinding Packages and CLASSPATHA Short Package ExamplePackages and Member AccessAn Access ExampleImporting PackagesInterfacesDefining an InterfaceImplementing InterfacesNested InterfacesApplying InterfacesVariables in InterfacesInterfaces Can Be ExtendedDefault Interface MethodsDefault Method FundamentalsA More Practical ExampleMultiple Inheritance IssuesUse static Methods in an InterfacePrivate Interface MethodsFinal Thoughts on Packages and Interfaces
Exception-Handling FundamentalsException TypesUncaught ExceptionsUsing try and catchDisplaying a Description of an ExceptionMultiple catch ClausesNested try StatementsthrowthrowsfinallyJava’s Built-in ExceptionsCreating Your Own Exception SubclassesChained ExceptionsThree Additional Exception FeaturesUsing Exceptions
The Java Thread ModelThread PrioritiesSynchronizationMessagingThe Thread Class and the Runnable InterfaceThe Main ThreadCreating a ThreadImplementing RunnableExtending ThreadChoosing an ApproachCreating Multiple ThreadsUsing isAlive( ) and join( )Thread PrioritiesSynchronizationUsing Synchronized MethodsThe synchronized StatementInterthread CommunicationDeadlockSuspending, Resuming, and Stopping ThreadsObtaining a Thread’s StateUsing a Factory Method to Create and Start a ThreadUsing Multithreading
EnumerationsEnumeration FundamentalsThe values( ) and valueOf( ) MethodsJava Enumerations Are Class TypesEnumerations Inherit EnumAnother Enumeration ExampleType WrappersCharacterBooleanThe Numeric Type WrappersAutoboxingAutoboxing and MethodsAutoboxing/Unboxing Occurs in ExpressionsAutoboxing/Unboxing Boolean and Character ValuesAutoboxing/Unboxing Helps Prevent ErrorsA Word of WarningAnnotationsAnnotation BasicsSpecifying a Retention PolicyObtaining Annotations at Run Time by Use of ReflectionThe AnnotatedElement InterfaceUsing Default ValuesMarker AnnotationsSingle-Member AnnotationsThe Built-In AnnotationsType AnnotationsRepeating AnnotationsSome Restrictions
I/O BasicsStreamsByte Streams and Character StreamsThe Predefined StreamsReading Console InputReading CharactersReading StringsWriting Console OutputThe PrintWriter ClassReading and Writing FilesAutomatically Closing a FileThe transient and volatile ModifiersIntroducing instanceofstrictfpNative MethodsUsing assertAssertion Enabling and Disabling OptionsStatic ImportInvoking Overloaded Constructors Through this( )A Word About Value-Based Classes
What Are Generics?A Simple Generics ExampleGenerics Work Only with Reference TypesGeneric Types Differ Based on Their Type ArgumentsHow Generics Improve Type SafetyA Generic Class with Two Type ParametersThe General Form of a Generic ClassBounded TypesUsing Wildcard ArgumentsBounded WildcardsCreating a Generic MethodGeneric ConstructorsGeneric InterfacesRaw Types and Legacy CodeGeneric Class HierarchiesUsing a Generic SuperclassA Generic SubclassRun-Time Type Comparisons Within a Generic HierarchyCastingOverriding Methods in a Generic ClassType Inference with GenericsLocal Variable Type Inference and GenericsErasureBridge MethodsAmbiguity ErrorsSome Generic RestrictionsType Parameters Can’t Be InstantiatedRestrictions on Static MembersGeneric Array RestrictionsGeneric Exception Restriction
Introducing Lambda ExpressionsLambda Expression FundamentalsFunctional InterfacesSome Lambda Expression ExamplesBlock Lambda ExpressionsGeneric Functional InterfacesPassing Lambda Expressions as ArgumentsLambda Expressions and ExceptionsLambda Expressions and Variable CaptureMethod ReferencesMethod References to static MethodsMethod References to Instance MethodsMethod References with GenericsConstructor ReferencesPredefined Functional Interfaces
Module BasicsA Simple Module ExampleCompile and Run the First Module ExampleA Closer Look at requires and exportsjava.base and the Platform ModulesLegacy Code and the Unnamed ModuleExporting to a Specific ModuleUsing requires transitiveUse ServicesService and Service Provider BasicsThe Service-Based KeywordsA Module-Based Service ExampleModule GraphsThree Specialized Module FeaturesOpen ModulesThe opens Statementrequires staticIntroducing jlink and Module JAR FilesLinking Files in an Exploded DirectoryLinking Modular JAR FilesJMOD FilesA Brief Word About Layers and Automatic ModulesFinal Thoughts on Modules
Enhancements to switchUse a List of case ConstantsIntroducing the switch Expression and the yield StatementIntroducing the Arrow in a case StatementA Closer Look at the Arrow caseAnother switch Expression ExampleText BlocksText Block FundamentalsUnderstanding Leading WhitespaceUse Double Quotes in a Text BlockEscape Sequences in Text BlocksRecordsRecord BasicsCreate Record ConstructorsAnother Record Constructor ExampleCreate Record Getter MethodsPattern Matching with instanceofPattern Variables in a Logical AND ExpressionPattern Matching in Other StatementsSealed Classes and InterfacesSealed ClassesSealed InterfacesFuture Directions
The String ConstructorsString LengthSpecial String OperationsString LiteralsString ConcatenationString Concatenation with Other Data TypesString Conversion and toString( )Character ExtractioncharAt( )getChars( )getBytes( )toCharArray( )String Comparisonequals( ) and equalsIgnoreCase( )regionMatches( )startsWith( ) and endsWith( )equals( ) Versus ==compareTo( )Searching StringsModifying a Stringsubstring( )concat( )replace( )trim( ) and strip( )Data Conversion Using valueOf( )Changing the Case of Characters Within a StringJoining StringsAdditional String MethodsStringBufferStringBuffer Constructorslength( ) and capacity( )ensureCapacity( )setLength( )charAt( ) and setCharAt( )getChars( )append( )insert( )reverse( )delete( ) and deleteCharAt( )replace( )substring( )Additional StringBuffer MethodsStringBuilder
Primitive Type WrappersNumberDouble and FloatUnderstanding isInfinite( ) and isNaN( )Byte, Short, Integer, and LongCharacterAdditions to Character for Unicode Code Point SupportBooleanVoidProcessRuntimeExecuting Other ProgramsRuntime.VersionProcessBuilderSystemUsing currentTimeMillis( ) to Time Program ExecutionUsing arraycopy( )Environment PropertiesSystem.Logger and System.LoggerFinderObjectUsing clone( ) and the Cloneable InterfaceClassClassLoaderMathTrigonometric FunctionsExponential FunctionsRounding FunctionsMiscellaneous Math MethodsStrictMathCompilerThread, ThreadGroup, and RunnableThe Runnable InterfaceThreadThreadGroupThreadLocal and InheritableThreadLocalPackageModuleModuleLayerRuntimePermissionThrowableSecurityManagerStackTraceElementStackWalker and StackWalker.StackFrameEnumRecordClassValueThe CharSequence InterfaceThe Comparable InterfaceThe Appendable InterfaceThe Iterable InterfaceThe Readable InterfaceThe AutoCloseable InterfaceThe Thread.UncaughtExceptionHandler InterfaceThe java.lang Subpackagesjava.lang.annotationjava.lang.constantjava.lang.instrumentjava.lang.invokejava.lang.managementjava.lang.modulejava.lang.refjava.lang.reflect
Collections OverviewThe Collection InterfacesThe Collection InterfaceThe List InterfaceThe Set InterfaceThe SortedSet InterfaceThe NavigableSet InterfaceThe Queue InterfaceThe Deque InterfaceThe Collection ClassesThe ArrayList ClassThe LinkedList ClassThe HashSet ClassThe LinkedHashSet ClassThe TreeSet ClassThe PriorityQueue ClassThe ArrayDeque ClassThe EnumSet ClassAccessing a Collection via an IteratorUsing an IteratorThe For-Each Alternative to IteratorsSpliteratorsStoring User-Defined Classes in CollectionsThe RandomAccess InterfaceWorking with MapsThe Map InterfacesThe Map ClassesComparatorsUsing a ComparatorThe Collection AlgorithmsArraysThe Legacy Classes and InterfacesThe Enumeration InterfaceVectorStackDictionaryHashtablePropertiesUsing store( ) and load( )Parting Thoughts on Collections
StringTokenizerBitSetOptional, OptionalDouble, OptionalInt, and OptionalLongDateCalendarGregorianCalendarTimeZoneSimpleTimeZoneLocaleRandomTimer and TimerTaskCurrencyFormatterThe Formatter ConstructorsThe Formatter MethodsFormatting BasicsFormatting Strings and CharactersFormatting NumbersFormatting Time and DateThe %n and %% SpecifiersSpecifying a Minimum Field WidthSpecifying PrecisionUsing the Format FlagsJustifying OutputThe Space, +, 0, and ( FlagsThe Comma FlagThe # FlagThe Uppercase OptionUsing an Argument IndexClosing a FormatterThe Java printf( ) ConnectionScannerThe Scanner ConstructorsScanning BasicsSome Scanner ExamplesSetting DelimitersOther Scanner FeaturesThe ResourceBundle, ListResourceBundle, and PropertyResourceBundle ClassesMiscellaneous Utility Classes and InterfacesThe java.util Subpackagesjava.util.concurrent, java.util.concurrent.atomic, and java.util.concurrent.locksjava.util.functionjava.util.jarjava.util.loggingjava.util.prefsjava.util.randomjava.util.regexjava.util.spijava.util.streamjava.util.zip
The I/O Classes and InterfacesFileDirectoriesUsing FilenameFilterThe listFiles( ) AlternativeCreating DirectoriesThe AutoCloseable, Closeable, and Flushable InterfacesI/O ExceptionsTwo Ways to Close a StreamThe Stream ClassesThe Byte StreamsInputStreamOutputStreamFileInputStreamFileOutputStreamByteArrayInputStreamByteArrayOutputStreamFiltered Byte StreamsBuffered Byte StreamsSequenceInputStreamPrintStreamDataOutputStream and DataInputStreamRandomAccessFileThe Character StreamsReaderWriterFileReaderFileWriterCharArrayReaderCharArrayWriterBufferedReaderBufferedWriterPushbackReaderPrintWriterThe Console ClassSerializationSerializableExternalizableObjectOutputObjectOutputStreamObjectInputObjectInputStreamA Serialization ExampleStream Benefits
The NIO ClassesNIO FundamentalsBuffersChannelsCharsets and SelectorsEnhancements Added by NIO.2The Path InterfaceThe Files ClassThe Paths ClassThe File Attribute InterfacesThe FileSystem, FileSystems, and FileStore ClassesUsing the NIO SystemUse NIO for Channel-Based I/OUse NIO for Stream-Based I/OUse NIO for Path and File System Operations
Networking BasicsThe java.net Networking Classes and InterfacesInetAddressFactory MethodsInstance MethodsInet4Address and Inet6AddressTCP/IP Client SocketsURLURLConnectionHttpURLConnectionThe URI ClassCookiesTCP/IP Server SocketsDatagramsDatagramSocketDatagramPacketA Datagram ExampleIntroducing java.net.httpThree Key ElementsA Simple HTTP Client ExampleThings to Explore in java.net.http
Two Event Handling MechanismsThe Delegation Event ModelEventsEvent SourcesEvent ListenersEvent ClassesThe ActionEvent ClassThe AdjustmentEvent ClassThe ComponentEvent ClassThe ContainerEvent ClassThe FocusEvent ClassThe InputEvent ClassThe ItemEvent ClassThe KeyEvent ClassThe MouseEvent ClassThe MouseWheelEvent ClassThe TextEvent ClassThe WindowEvent ClassSources of EventsEvent Listener InterfacesThe ActionListener InterfaceThe AdjustmentListener InterfaceThe ComponentListener InterfaceThe ContainerListener InterfaceThe FocusListener InterfaceThe ItemListener InterfaceThe KeyListener InterfaceThe MouseListener InterfaceThe MouseMotionListener InterfaceThe MouseWheelListener InterfaceThe TextListener InterfaceThe WindowFocusListener InterfaceThe WindowListener InterfaceUsing the Delegation Event ModelSome Key AWT GUI ConceptsHandling Mouse EventsHandling Keyboard EventsAdapter ClassesInner ClassesAnonymous Inner Classes
AWT ClassesWindow FundamentalsComponentContainerPanelWindowFrameCanvasWorking with Frame WindowsSetting the Window’s DimensionsHiding and Showing a WindowSetting a Window’s TitleClosing a Frame WindowThe paint( ) MethodDisplaying a StringSetting the Foreground and Background ColorsRequesting RepaintingCreating a Frame-Based ApplicationIntroducing GraphicsDrawing LinesDrawing RectanglesDrawing Ellipses and CirclesDrawing ArcsDrawing PolygonsDemonstrating the Drawing MethodsSizing GraphicsWorking with ColorColor MethodsSetting the Current Graphics ColorA Color Demonstration ProgramSetting the Paint ModeWorking with FontsDetermining the Available FontsCreating and Selecting a FontObtaining Font InformationManaging Text Output Using FontMetrics
AWT Control FundamentalsAdding and Removing ControlsResponding to ControlsThe HeadlessExceptionLabelsUsing ButtonsHandling ButtonsApplying Check BoxesHandling Check BoxesCheckboxGroupChoice ControlsHandling Choice ListsUsing ListsHandling ListsManaging Scroll BarsHandling Scroll BarsUsing a TextFieldHandling a TextFieldUsing a TextAreaUnderstanding Layout ManagersFlowLayoutBorderLayoutUsing InsetsGridLayoutCardLayoutGridBagLayoutMenu Bars and MenusDialog BoxesA Word About Overriding paint( )
File FormatsImage Fundamentals: Creating, Loading, and DisplayingCreating an Image ObjectLoading an ImageDisplaying an ImageDouble BufferingImageProducerMemoryImageSourceImageConsumerPixelGrabberImageFilterCropImageFilterRGBImageFilterAdditional Imaging Classes
The Concurrent API Packagesjava.util.concurrentjava.util.concurrent.atomicjava.util.concurrent.locksUsing Synchronization ObjectsSemaphoreCountDownLatchCyclicBarrierExchangerPhaserUsing an ExecutorA Simple Executor ExampleUsing Callable and FutureThe TimeUnit EnumerationThe Concurrent CollectionsLocksAtomic OperationsParallel Programming via the Fork/Join FrameworkThe Main Fork/Join ClassesThe Divide-and-Conquer StrategyA Simple First Fork/Join ExampleUnderstanding the Impact of the Level of ParallelismAn Example that Uses RecursiveTask<V>Executing a Task AsynchronouslyCancelling a TaskDetermining a Task’s Completion StatusRestarting a TaskThings to ExploreSome Fork/Join TipsThe Concurrency Utilities Versus Java’s Traditional Approach
Stream BasicsStream InterfacesHow to Obtain a StreamA Simple Stream ExampleReduction OperationsUsing Parallel StreamsMappingCollectingIterators and StreamsUse an Iterator with a StreamUse SpliteratorMore to Explore in the Stream API
Regular Expression ProcessingPatternMatcherRegular Expression SyntaxDemonstrating Pattern MatchingTwo Pattern-Matching OptionsExploring Regular ExpressionsReflectionRemote Method Invocation (RMI)A Simple Client/Server Application Using RMIFormatting Date and Time with java.textDateFormat ClassSimpleDateFormat ClassThe java.time Time and Date APITime and Date FundamentalsFormatting Date and TimeParsing Date and Time StringsOther Things to Explore in java.time
The Origins of SwingSwing Is Built on the AWTTwo Key Swing FeaturesSwing Components Are LightweightSwing Supports a Pluggable Look and FeelThe MVC ConnectionComponents and ContainersComponentsContainersThe Top-Level Container PanesThe Swing PackagesA Simple Swing ApplicationEvent HandlingPainting in SwingPainting FundamentalsCompute the Paintable AreaA Paint Example
JLabel and ImageIconJTextFieldThe Swing ButtonsJButtonJToggleButtonCheck BoxesRadio ButtonsJTabbedPaneJScrollPaneJListJComboBoxTreesJTable
Menu BasicsAn Overview of JMenuBar, JMenu, and JMenuItemJMenuBarJMenuJMenuItemCreate a Main MenuAdd Mnemonics and Accelerators to Menu ItemsAdd Images and Tooltips to Menu ItemsUse JRadioButtonMenuItem and JCheckBoxMenuItemCreate a Popup MenuCreate a ToolbarUse ActionsPut the Entire MenuDemo Program TogetherContinuing Your Exploration of Swing
What Is a Java Bean?Advantages of BeansIntrospectionDesign Patterns for PropertiesDesign Patterns for EventsMethods and Design PatternsUsing the BeanInfo InterfaceBound and Constrained PropertiesPersistenceCustomizersThe JavaBeans APIIntrospectorPropertyDescriptorEventSetDescriptorMethodDescriptorA Bean Example
BackgroundThe Life Cycle of a ServletServlet Development OptionsUsing TomcatA Simple ServletCreate and Compile the Servlet Source CodeStart TomcatStart a Web Browser and Request the ServletThe Servlet APIThe jakarta.servlet PackageThe Servlet InterfaceThe ServletConfig InterfaceThe ServletContext InterfaceThe ServletRequest InterfaceThe ServletResponse InterfaceThe GenericServlet ClassThe ServletInputStream ClassThe ServletOutputStream ClassThe Servlet Exception ClassesReading Servlet ParametersThe jakarta.servlet.http PackageThe HttpServletRequest InterfaceThe HttpServletResponse InterfaceThe HttpSession InterfaceThe Cookie ClassThe HttpServlet ClassHandling HTTP Requests and ResponsesHandling HTTP GET RequestsHandling HTTP POST RequestsUsing CookiesSession Tracking
The javadoc Tags@author{@code}@deprecated{@docRoot}@exception@hidden{@index}{@inheritDoc}{@link}{@linkplain}{@literal}@param@provides@return@see@serial@serialData@serialField@since{@summary}{@systemProperty}@throws@uses{@value}@versionThe General Form of a Documentation CommentWhat javadoc OutputsAn Example that Uses Documentation Comments
JShell BasicsList, Edit, and Rerun CodeAdd a MethodCreate a ClassUse an InterfaceEvaluate Expressions and Use Built-in VariablesImporting PackagesExceptionsSome More JShell CommandsExploring JShell Further