book

Learning Java, 5th Edition

by Marc Loy, Patrick Niemeyer, Daniel Leuck

March 2020

Beginner

515 pages

15h

English

O'Reilly Media, Inc.

Read now

Unlock full access

Who Should Read This BookNew DevelopmentsNew in This Edition (Java 11, 12, 13, 14)Using This BookOnline ResourcesConventions Used in This BookUsing Code ExamplesO’Reilly Online LearningHow to Contact UsAcknowledgments
Enter JavaJava’s OriginsGrowing UpA Virtual MachineJava Compared with Other LanguagesSafety of DesignSimplify, Simplify, Simplify…Type Safety and Method BindingIncremental DevelopmentDynamic Memory ManagementError HandlingThreadsScalabilitySafety of ImplementationThe VerifierClass LoadersSecurity ManagersApplication and User-Level SecurityA Java Road MapThe Past: Java 1.0–Java 11The Present: Java 14The FutureAvailability
Java Tools and EnvironmentInstalling the JDKInstalling OpenJDK on LinuxInstalling OpenJDK on macOSInstalling OpenJDK on WindowsConfiguring IntelliJ IDEA and Creating a ProjectRunning the ProjectGrabbing the Learning Java ExamplesHelloJavaClassesThe main() MethodClasses and ObjectsVariables and Class TypesHelloComponentInheritanceThe JComponent ClassRelationships and Finger-PointingPackage and ImportsThe paintComponent() MethodHelloJava2: The SequelInstance VariablesConstructorsEventsThe repaint() MethodInterfacesGoodbye and Hello Again
JDK EnvironmentThe Java VMRunning Java ApplicationsSystem PropertiesThe ClasspathjavapModulesThe Java CompilerTrying JavaJAR FilesFile CompressionThe jar UtilityThe pack200 UtilityBuilding Up
Text EncodingCommentsJavadoc CommentsVariables and ConstantsTypesPrimitive TypesReference TypesInferring TypesPassing ReferencesA Word About StringsStatements and ExpressionsStatementsExpressionsArraysArray TypesArray Creation and InitializationUsing ArraysAnonymous ArraysMultidimensional ArraysTypes and Classes and Arrays, Oh My!
ClassesDeclaring and Instantiating ClassesAccessing Fields and MethodsStatic MembersMethodsLocal VariablesShadowingStatic MethodsInitializing Local VariablesArgument Passing and ReferencesWrappers for Primitive TypesMethod OverloadingObject CreationConstructorsWorking with Overloaded ConstructorsObject DestructionGarbage CollectionPackagesImporting ClassesCustom PackagesMember Visibility and AccessCompiling with PackagesAdvanced Class DesignSubclassing and InheritanceInterfacesInner ClassesAnonymous Inner ClassesOrganizing Content and Planning for Failure
ExceptionsExceptions and Error ClassesException HandlingBubbling UpStack TracesChecked and Unchecked ExceptionsThrowing Exceptionstry CreepThe finally Clausetry with ResourcesPerformance IssuesAssertionsEnabling and Disabling AssertionsUsing AssertionsThe Logging APIOverviewLogging LevelsA Simple ExampleLogging Setup PropertiesThe LoggerPerformanceReal-World Exceptions
CollectionsThe Collection InterfaceCollection TypesThe Map InterfaceType LimitationsContainers: Building a Better MousetrapCan Containers Be Fixed?Enter GenericsTalking About Types“There Is No Spoon”ErasureRaw TypesParameterized Type RelationshipsWhy Isn’t a List<Date> a List<Object>?CastsConverting Between Collections and ArraysIteratorA Closer Look: The sort() MethodApplication: Trees on the FieldConclusion
StringsConstructing StringsStrings from ThingsComparing StringsSearchingString Method SummaryThings from StringsParsing Primitive NumbersTokenizing TextRegular ExpressionsRegex NotationThe java.util.regex APIMath UtilitiesThe java.lang.Math ClassBig/Precise NumbersDates and TimesLocal Dates and TimesComparing and Manipulating Dates and TimesTime ZonesParsing and Formatting Dates and TimesParsing ErrorsTimestampsOther Useful Utilities
Introducing ThreadsThe Thread Class and the Runnable InterfaceControlling ThreadsDeath of a ThreadSynchronizationSerializing Access to MethodsAccessing Class and Instance Variables from Multiple ThreadsScheduling and PriorityThread StateTime-SlicingPrioritiesYieldingThread PerformanceThe Cost of SynchronizationThread Resource ConsumptionConcurrency Utilities

Buttons and Sliders and Text Fields, Oh My!Component HierarchiesModel View Controller ArchitectureLabels and ButtonsText ComponentsOther ComponentsContainers and LayoutsFrames and WindowsJPanelLayout ManagersEventsMouse EventsAction EventsChange EventsOther EventsModals and Pop UpsMessage DialogsConfirmation DialogsInput DialogsThreading ConsiderationsSwingUtilities and Component UpdatesTimersNext StepsMenusPreferencesCustom Components and Java2DJavaFXUser Interface and User Experience
StreamsBasic I/OCharacter StreamsStream WrappersThe java.io.File ClassFile StreamsRandomAccessFileThe NIO File APIFileSystem and PathNIO File OperationsThe NIO PackageAsynchronous I/OPerformanceMapped and Locked FilesChannelsBuffersCharacter Encoders and DecodersFileChannelNetwork ProgrammingSocketsClients and ServersThe DateAtHost ClientA Distributed GameMore to Explore
Uniform Resource LocatorsThe URL ClassStream DataGetting the Content as an ObjectManaging ConnectionsHandlers in PracticeUseful Handler FrameworksTalking to Web ApplicationsUsing the GET MethodUsing the POST MethodThe HttpURLConnectionSSL and Secure Web CommunicationsJava Web ApplicationsThe Servlet Life CycleServletsThe HelloClient ServletThe Servlet ResponseServlet ParametersThe ShowParameters ServletUser Session ManagementThe ShowSession ServletServlet ContainersConfiguration with web.xml and AnnotationsURL Pattern MappingsDeploying HelloClientThe World Wide Web Is, Well, Wide
Java ReleasesJCP and JSRsLambda ExpressionsRetrofitting Your CodeExpanding Java Beyond the CoreFinal Wrap-Up and Next Steps
Grabbing the Main Code ExamplesInstalling IntelliJ IDEAInstalling on LinuxInstalling on a macOSInstalling on WindowsImporting the ExamplesRunning the ExamplesGrabbing the Web Code ExamplesWorking with Servlets

Content preview from Learning Java, 5th Edition

Glossary

abstract: The abstract keyword is used to declare abstract methods and classes. An abstract method has no implementation defined; it is declared with arguments and a return type as usual, but the body enclosed in curly braces is replaced with a semicolon. The implementation of an abstract method is provided by a subclass of the class in which it is defined. If an abstract method appears in a class, the class is also abstract. Attempting to instantiate an abstract class will fail at compile time.
annotations: Metadata added to Java source code using the @ tag syntax. Annotations can be used by the compiler or at runtime to augment classes, provide data or mappings, or flag additional services.
Ant: An older, XML-based build tool for Java applications. Ant builds can compile, package, and deploy Java source code as well as generate documentation and perform other activities through pluggable “targets.”
Application Programming Interface (API): An API consists of the methods and variables programmers use to work with a component or tool in their applications. The Java language APIs consist of the classes and methods of the java.lang, java.util, java.io, java.text, java.net packages and many others.
application: A Java program that runs standalone, as compared with an applet.
Annotation Processing Tool (APT): A frontend for the Java compiler that processes annotations via a pluggable factory architecture, allowing users to implement custom compile-time annotations. ...