book

Java: The Complete Reference, Ninth Edition, 9th Edition

Name: Java: The Complete Reference, Ninth Edition, 9th Edition
Author: Herbert Schildt
ISBN: 9780071823500

by Herbert Schildt

April 2014

Intermediate to advanced

1312 pages

34h 55m

English

McGraw Hill Computing

Read now

Unlock full access

Cover
About the Author
About the Technical Editor
Title Page
Copyright Page
Contents at a Glance
Contents
Preface
A Book for All ProgrammersWhat’s InsideDon’t Forget: Code on the WebSpecial Thanks
For Further Study
Part I: The Java Language
Chapter 1: The History and Evolution of Java
Java’s LineageThe Birth of Modern Programming: CC++: The Next StepThe Stage Is Set for JavaThe Creation of JavaThe C# ConnectionHow Java Changed the InternetJava AppletsSecurityPortabilityJava’s Magic: The BytecodeServlets: Java on the Server SideThe Java BuzzwordsSimpleObject-OrientedRobustMultithreadedArchitecture-NeutralInterpreted and High PerformanceDistributedDynamicThe Evolution of JavaJava SE 8A Culture of Innovation

Chapter 2: An Overview of Java
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
Chapter 3: Data Types, Variables, and Arrays
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 SyntaxA Few Words About StringsA Note to C/C++ Programmers About Pointers
Chapter 4: Operators
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
Chapter 5: Control Statements
Java’s Selection StatementsifswitchIteration Statementswhiledo-whileforThe For-Each Version of the for LoopNested LoopsJump StatementsUsing breakUsing continue
Chapter 6: Introducing Classes
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 CollectionThe finalize( ) MethodA Stack Class
Chapter 7: A Closer Look at Methods and Classes
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 Ambiguity
Chapter 8: Inheritance
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 InheritanceThe Object Class
Chapter 9: Packages and Interfaces
PackagesDefining a PackageFinding Packages and CLASSPATHA Short Package ExampleAccess ProtectionAn Access ExampleImporting PackagesInterfacesDefining an Inter faceImplementing InterfacesNested InterfacesApplying InterfacesVariables in InterfacesInterfaces Can Be ExtendedDefault Interface MethodsDefault Method FundamentalsA More Practical ExampleMultiple Inheritance IssuesUse static Methods in an InterfaceFinal Thoughts on Packages and Interfaces
Chapter 10: Exception Handling
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 Recently Added Exception FeaturesUsing Exceptions
Chapter 11: Multithreaded Programming
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 Multithreading
Chapter 12: Enumerations, Autoboxing, and Annotations (Metadata)
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 WarningAnnotations (Metadata)Annotation 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
Chapter 13: I/O, Applets, and Other Topics
I/O BasicsStreamsByte Streams and Character StreamsThe Predefined StreamsReading Console InputReading CharactersReading StringsWriting Console OutputThe PrintWriter ClassReading and Writing FilesAutomatically Closing a FileApplet FundamentalsThe transient and volatile ModifiersUsing instanceofstrictfpNative MethodsProblems with Native MethodsUsing assertAssertion Enabling and Disabling OptionsStatic ImportInvoking Overloaded Constructors Through this( )Compact API Profiles
Chapter 14: Generics
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 GenericsErasureBridge MethodsAmbiguity ErrorsSome Generic RestrictionsType Parameters Can’t Be InstantiatedRestrictions on Static MembersGeneric Array RestrictionsGeneric Exception Restriction
Chapter 15: Lambda Expressions
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
Part II: The Java Library
Chapter 16: String Handling
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( )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
Chapter 17: Exploring java.lang
Primitive Type WrappersNumberDouble and FloatUnderstanding isInfinite( ) and isNaN( )Byte, Short, Integer, and LongCharacterAdditions to Character for Unicode Code Point SupportBooleanVoidProcessRuntimeMemory ManagementExecuting Other ProgramsProcessBuilderSystemUsing currentTimeMillis( ) to Time Program Execution.Using arraycopy( )Environment PropertiesObjectUsing clone( ) and the Cloneable InterfaceClassClassLoaderMathTrigonometric FunctionsExponential FunctionsRounding FunctionsMiscellaneous Math MethodsStrictMathCompilerThread, ThreadGroup, and RunnableThe Runnable InterfaceThreadThreadGroupThreadLocal and InheritableThreadLocalPackageRuntimePermissionThrowableSecurityManagerStackTraceElementEnumClassValueThe CharSequence InterfaceThe Comparable InterfaceThe Appendable InterfaceThe Iterable InterfaceThe Readable InterfaceThe AutoCloseable InterfaceThe Thread.UncaughtExceptionHandler InterfaceThe java.lang Subpackagesjava.lang.annotationjava.lang.instrumentjava.lang.invokejava.lang.managementjava.lang.refjava.lang.reflect
Chapter 18: java.util Part 1: The Collections Framework
Collections OverviewJDK 5 Changed the Collections FrameworkGenerics Fundamentally Changed the Collections FrameworkAutoboxing Facilitates the Use of Primitive TypesThe For-Each Style for LoopThe 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
Chapter 19: java.util Part 2: More Utility Classes
StringTokenizerBitSetOptional, OptionalDouble, OptionalInt, and OptionalLongDateCalendarGregorianCalendarTimeZoneSimpleTimeZoneLocaleRandomObservableThe Observer InterfaceAn Observer ExampleTimer 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.regexjava.util.spijava.util.streamjava.util.zip
Chapter 20: Input/Output: Exploring java.io
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
Chapter 21: Exploring NIO
The NIO ClassesNIO FundamentalsBuffersChannelsCharsets and SelectorsEnhancements Added to NIO by JDK 7The 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 OperationsPre-JDK 7 Channel-Based ExamplesRead a File, Pre-JDK 7Write to a File, Pre-JDK 7
Chapter 22: Networking
Networking BasicsThe Networking Classes and InterfacesInetAddressFactory MethodsInstance MethodsInet4Address and Inet6AddressTCP/IP Client SocketsURLURLConnectionHttpURLConnectionThe URI ClassCookiesTCP/IP Server SocketsDatagramsDatagramSocketDatagramPacketA Datagram Example
Chapter 23: The Applet Class
Two Types of AppletsApplet BasicsThe Applet ClassApplet ArchitectureAn Applet SkeletonApplet Initialization and TerminationOverriding update( )Simple Applet Display MethodsRequesting RepaintingA Simple Banner AppletUsing the Status WindowThe HTML APPLET TagPassing Parameters to AppletsImproving the Banner AppletgetDocumentBase( ) and getCodeBase( )AppletContext and showDocument( )The AudioClip InterfaceThe AppletStub InterfaceOutputting to the Console
Chapter 24: Event Handling
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 ModelHandling Mouse EventsHandling Keyboard EventsAdapter ClassesInner ClassesAnonymous Inner Classes
Chapter 25: Introducing the AWT: Working with Windows, Graphics, and Text
AWT ClassesWindow FundamentalsComponentContainerPanelWindowFrameCanvasWorking with Frame WindowsSetting the Window’s DimensionsHiding and Showing a WindowSetting a Window’s TitleClosing a Frame WindowCreating a Frame Window in an AWT-Based AppletHandling Events in a Frame WindowCreating a Windowed ProgramDisplaying Information Within a WindowIntroducing GraphicsDrawing LinesDrawing RectanglesDrawing Ellipses and CirclesDrawing ArcsDrawing PolygonsDemonstrating the Drawing MethodsSizing GraphicsWorking with ColorColor MethodsSetting the Current Graphics ColorA Color Demonstration AppletSetting the Paint ModeWorking with FontsDetermining the Available FontsCreating and Selecting a FontObtaining Font InformationManaging Text Output Using FontMetricsDisplaying Multiple Lines of TextCentering TextMultiline Text Alignment
Chapter 26: Using AWT Controls, Layout Managers, and Menus
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 BoxesFileDialogA Word About Overriding paint( )
Chapter 27: Images
File FormatsImage Fundamentals: Creating, Loading, and DisplayingCreating an Image ObjectLoading an ImageDisplaying an ImageImageObserverDouble BufferingMediaTrackerImageProducerMemoryImageSourceImageConsumerPixelGrabberImageFilterCropImageFilterRGBImageFilterAdditional Imaging Classes
Chapter 28: The Concurrency Utilities
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
Chapter 29: The Stream API
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
Chapter 30: Regular Expressions and Other Packages
The Core Java API PackagesRegular 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 Time and Date API Added by JDK 8Time and Date FundamentalsFormatting Date and TimeParsing Date and Time StringsOther Things to Explore in java.time
Part III: Introducing GUI Programming with Swing
Chapter 31: Introducing Swing
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 HandlingCreate a Swing AppletPainting in SwingPainting FundamentalsCompute the Paintable AreaA Paint Example
Chapter 32: Exploring Swing
JLabel and ImageIconJTextFieldThe Swing ButtonsJButtonJToggleButtonCheck BoxesRadio ButtonsJTabbedPaneJScrollPaneJListJComboBoxTreesJTable
Chapter 33: Introducing Swing Menus
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
Part IV: Introducing GUI Programming with JavaFX
Chapter 34: Introducing JavaFX GUI Programming
JavaFX Basic ConceptsThe JavaFX PackagesThe Stage and Scene ClassesNodes and Scene GraphsLayoutsThe Application Class and the Lifecycle MethodsLaunching a JavaFX ApplicationA JavaFX Application SkeletonCompiling and Running a JavaFX ProgramThe Application ThreadA Simple JavaFX Control: LabelUsing Buttons and EventsEvent BasicsIntroducing the Button ControlDemonstrating Event Handling and the ButtonDrawing Directly on a Canvas
Chapter 35: Exploring JavaFX Controls
Using Image and ImageViewAdding an Image to a LabelUsing an Image with a ButtonToggleButtonRadioButtonHandling Change Events in a Toggle GroupAn Alternative Way to Handle Radio ButtonsCheckBoxListViewListView ScrollbarsEnabling Multiple SelectionsComboBoxTextFieldScrollPaneTreeViewIntroducing Effects and TransformsEffectsTransformsDemonstrating Effects and TransformsAdding TooltipsDisabling a Control
Chapter 36: Introducing JavaFX Menus
Menu BasicsAn Overview of MenuBar, Menu, and MenuItemMenuBarMenuMenuItemCreate a Main MenuAdd Mnemonics and Accelerators to Menu ItemsAdd Images to Menu ItemsUse RadioMenuItem and CheckMenuItemCreate a Context MenuCreate a ToolbarPut the Entire MenuDemo Program TogetherContinuing Your Exploration of JavaFX
Part V: Applying Java
Chapter 37: Java Beans
What Is a Java Bean?Advantages of Java BeansIntrospectionDesign Patterns for PropertiesDesign Patterns for EventsMethods and Design PatternsUsing the BeanInfo InterfaceBound and Constrained PropertiesPersistenceCustomizersThe Java Beans APIIntrospectorPropertyDescriptorEventSetDescriptorMethodDescriptorA Bean Example
Chapter 38: Introducing Servlets
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 javax.servlet PackageThe Servlet InterfaceThe ServletConfg InterfaceThe ServletContext InterfaceThe ServletRequest InterfaceThe ServletResponse InterfaceThe GenericServlet ClassThe ServletInputStream ClassThe ServletOutputStream ClassThe Servlet Exception ClassesReading Servlet ParametersThe javax.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
Appendix: Using Java’s Documentation Comments
The javadoc Tags@author{@code}@deprecated{@docRoot}@exception{@inheritDoc}{@link}{@linkplain}{@literal}@param@return@see@serial@serialData@serialField@since@throws{@value}@versionThe General Form of a Documentation CommentWhat javadoc OutputsAn Example that Uses Documentation Comments
Index

Content preview from Java: The Complete Reference, Ninth Edition, 9th Edition

CHAPTER
7	A Closer Look at Methods and Classes

This chapter continues the discussion of methods and classes begun in the preceding chapter. It examines several topics relating to methods, including overloading, parameter passing, and recursion. The chapter then returns to the class, discussing access control, the use of the keyword static, and one of Java’s most important built-in classes: String.

Overloading Methods

In Java, it is possible to define two or more methods within the same class that share the same name, as long as their parameter declarations are different. When this is the case, the methods are said to be overloaded, and the process is referred to as method overloading. Method overloading is one of the ways that Java ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Java The Complete Reference, 8th Edition, 8th Edition

Publisher Resources

ISBN: 9780071808552

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Java: The Complete Reference, Ninth Edition, 9th Edition

by Herbert Schildt

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.