book

Learning Java

by Jonathan Knudsen, Patrick Niemeyer

May 2000

Beginner

726 pages

21h 42m

English

O'Reilly Media, Inc.

Read now

Unlock full access

New Developments
Enter JavaJava’s OriginsFuture Buzz?

Syntactic Sweet ‘n’ LowType Safety and Method BindingIncremental DevelopmentDynamic Memory ManagementError HandlingMultithreadingScalability
The VerifierClass LoadersSecurity Managers
Signing Classes
AppletsNew Kinds of MediaNew Software Development Models
The Past: Java 1.0 and Java 1.1The Present: Java 2The FutureAvailability
HelloJava1ClassesThe main( ) MethodClasses and ObjectsVariables and Class TypesInheritanceThe JComponent ClassRelationships and Finger PointingPackagesThe paintComponent( ) Method
The import StatementInstance VariablesConstructorsEventsThe repaint( ) MethodInterfaces
Method OverloadingGarbage CollectionComponentsContainersLayoutSubclassing and SubtypesMore Events and InterfacesColor CommentaryStatic MembersArraysUsing Color Methods
ThreadsThe Thread ClassThe Runnable InterfaceStarting the ThreadRunning Code in the ThreadExceptionsA Word About Synchronization
The Java Interpreter
The Default Security ManagerThe policytool UtilityUsing a Policy File with the Default Security Manager
File CompressionThe jar UtilityJAR manifests
Text Encoding
Javadoc Comments
Primitive TypesFloating-point precisionVariable declaration and initializationInteger literalsFloating-point literalsCharacter literalsReference TypesA Word About Strings
StatementsUnreachable statementsExpressionsOperatorsAssignmentThe null valueVariable accessMethod invocationObject creationThe instanceof operator
Exceptions and Error ClassesException HandlingBubbling UpChecked and Unchecked ExceptionsThrowing ExceptionsRe-throwing exceptionsTry CreepThe finally ClausePerformance Issues
Array TypesArray Creation and InitializationUsing ArraysAnonymous ArraysMultidimensional ArraysInside Arrays
ClassesAccessing Fields and MethodsStatic Members
Local VariablesShadowingThe “this” referenceStatic MethodsInitializing Local VariablesArgument Passing and ReferencesMethod Overloading
ConstructorsWorking with Overloaded ConstructorsStatic and Nonstatic Code Blocks
Garbage CollectionFinalization
Subclassing and InheritanceShadowed VariablesOverriding MethodsOverridden methods and dynamic bindingStatic method bindingDynamic method selection and performanceCompiler optimizationsMethod selection revisitedExceptions and overridden methodsSpecial References: this and superCastingUsing Superclass ConstructorsFull Disclosure: Constructors and InitializationAbstract Methods and Classes
Interfaces as CallbacksInterface VariablesEmpty interfacesSubinterfaces
Compilation UnitsPackage NamesClass VisibilityImporting ClassesThe Unnamed Package
Basic Access ModifiersSubclasses and VisibilityInterfaces and Visibility
Inner Classes Within MethodsLimitations on inner classesStatic inner classesAnonymous inner classesScoping of the “this” referenceHow do inner classes really work?Security implications
The Object ClassEquality and EquivalenceHashcodesCloning Objects
SecurityAccessing FieldsAccessing MethodsAccessing ConstructorsWhat About Arrays?Dynamic Interface AdaptersWhat Is Reflection Good for?The BeanShell application
Introducing ThreadsThe Thread Class and the Runnable InterfaceCreating and starting threadsA natural-born threadUsing an adapterControlling ThreadsDeprecated methodsThe sleep( ) methodThe join( ) methodA Thread’s Life
Serializing Access to MethodsAccessing instance variablesThe wait() and notify( ) MethodsPassing Messages
Time-SlicingPrioritiesUser-Controlled Time-SlicingYieldingNative Threads
Working with the ThreadGroup Class
StringsString ConstructorsStrings from ThingsThings from StringsComparisonsThe Collator classSearchingEditingString Method SummaryThe java.lang.StringBuffer ClassThe java.util.StringTokenizer Class
The java.lang.Math ClassThe java.math ClassWrappers for Primitive TypesRandom Numbers
The Collection InterfaceIteratorsCollection FlavorsThe Map InterfaceImplementationsHashcodes and key valuesSlam Dunking with CollectionsSorting for FreeA Thrilling ExampleThread Safety and IteratorsWeakHashMap: An Interesting Variation
Default ValuesLoading and StoringSystem PropertiesObservers and Observables
The java.util.Locale ClassResource BundlesThe java.text Class
StreamsTerminal I/OCharacter StreamsStream WrappersData streamsBuffered streamsPrint streamsPipesStrings to Streams and BackThe rot13InputStream Class
The java.io.File ClassFile constructorsPath localizationFile operationsFile StreamsThe java.io.RandomAccessFile ClassApplets and FilesLoading Application Resources
Compressing DataDecompressing Data
SocketsClients and ServersClientsServersSockets and securityThe DateAtHost ClientThe TinyHttpd ServerDo French web servers speak French?Taming the daemonRoom for improvementSocket OptionsSO_TIMEOUTTCP_NODELAYSO_LINGERTCP_KEEPALIVE“Half Close”Proxies and Firewalls
The HeartBeat AppletThe HeartBeat applet codeThe Pulse server code
A Simple Object-Based ServerLimitations
Remote and Non-Remote ObjectsStubs and skeletonsRemote interfacesThe UnicastRemoteObject classThe RMI registryAn RMI ExampleDynamic class loadingPassing remote object referencesRMI Object ActivationRMI and CORBA
Uniform Resource Locators (URLs)
Stream DataGetting the Content as an Object
Other Handler FrameworksWriting Content and Protocol Handlers
Using the GET MethodUsing the POST MethodSSL and Secure Web Communications
Why Servlets?The Servlet Life CycleHTTP (Web) ServletsThe HelloClient ServletContent TypesServlet ParametersGET, POST, and the “extra path”Which one to use?The ShowParameters ServletUser Session ManagementThe ShowSession servletThe ShoppingCart servletCookies
ComponentsPeersWhy the Move from AWT to Swing?The Model/View/Controller FrameworkPaintingEnabling and Disabling ComponentsFocus, PleaseOther Component Methods
Layout ManagersInsetsZ-Ordering (Stacking Components)The revalidate( ) and doLayout( ) MethodsManaging ComponentsListening for ComponentsWindows and FramesOther Methods for Controlling FramesUsing Content Panes
Event Receivers and Listener InterfacesEvent SourcesEvent DeliveryEvent TypesThe java.awt.event.InputEvent ClassMouse and Key Modifiers on InputEvents
Adapter ClassesDummy AdaptersOld-Style and New-Style Event ProcessingprocessEvent( )Enabling new-style events explicitly
Buttons and Labels
File Selection DialogThe Color Chooser
Text ComponentsThe TextEntryBox ApplicationSay the Magic WordSharing a Data ModelHTML and RTF for FreeManaging Text Yourself
Nodes and ModelsSave a TreeTree EventsA Complete Example
A First Stab: FreeloadingRound Two: Creating a Table ModelRound Three: A Simple Spreadsheet
Generating EventsA Dial ComponentModel and View Separation
FlowLayout
The GridBagConstraints ClassGrid CoordinatesThe fill ConstraintSpanning Rows and ColumnsWeightingCalculating the weights of rows and columnsAnchoringPadding and InsetsRelative PositioningComposite Layouts
The Big Picture
Filling ShapesDrawing Shape OutlinesConvenience MethodsDrawing TextDrawing ImagesGo CrazyThe Whole Iguana
Solid ColorsColor GradientsTexturesDesktop Colors
Font Metrics
The Image ClassImage ObserversScaling and Size
Limited RedrawingDouble BufferingOffscreen Drawing
Implementing an ImageObserver
Drawing AnimationsBufferedImage AnatomyColor ModelsCreating an ImageUpdating a BufferedImage
How ImageProcessor WorksConverting an Image to a BufferedImageUsing the RescaleOp ClassUsing the AffineTransformOp Class
What’s a Bean?How Big Is a Bean?The BeanBox ApplicationRunning the BeanBox applicationProperties and CustomizersEvents Hookups and AdaptersBound PropertiesConstrained Properties
Creating a Component with Bindable PropertiesDesign patterns for propertiesA (Slightly) More Realistic ExampleA Bean for displaying textA Bean for validating numeric dataAn invisible multiplierPutting them togetherCustomizing with BeanInfoGetting Properties informationGetting Events informationSupplying iconsCreating customizers and property editors
Bean Instantiation and Type ManagementWorking with Serialized Beans
Safety ImplicationsRuntime Event Hookups with Reflection
The JApplet ClassApplet ControlThe Applet Security SandboxTrusted appletsGetting Applet ResourcesApplet parametersApplet resourcesDriving the browserInter-applet communicationApplets versus standalone applications
AttributesParameters¿Habla Applet?The Complete <APPLET> TagLoading Class FilesPackagesViewing Applets
What Is the Java Plug-in?Messy TagsViewing Plug-in Applets
CertificatesCertificate authority (CA) certificatesSite certificatesUser (signer) certificatesSigned JAR Files: The keytool and jarsigner UtilitiesWhat about Netscape and Internet Explorer?The TestWrite exampleKeystores, Keys, and CertificatesPublic and private keysCertificatesSigning JARsWhere We’ve Been
Writing a Content HandlerLocating Content HandlersThe application/x-tar HandlerThe ContentHandler classThe URLConnectionConstructing the objectUsing our new handler
Locating Protocol HandlersURLs, Stream Handlers, and ConnectionsThe crypt HandlerThe Encryption classThe URLStreamHandlerThe URLConnectionTrying it out
Running BeanShell

Overview

Part of O'Reilly's definitive set of Java documentation, Learning Java introduces the basics of Java, the object-oriented programming language for networked applications from Sun Microsystems. This book provides a broad survey of the Java 2 Standard Edition and contains everything necessary to get up to speed quickly. It covers the essentials of hot topics like Swing and JFC; describes new tools for signing applets and other Java classes; and shows how to write networked clients and servers, servlets, JavaBeans, and state-of-the-art user interfaces. Java started out as a tool for creating animated web pages, but it's proven to be much more. Java is now used for everything from sophisticated web clients to mission-critical enterprise applications. In the future, Java will become the basis for a new generation of distributed software that runs on devices ranging from cell phones to supercomputers. In the practical, hands-on approach characteristic of O'Reilly, Learning Java demonstrates why Java is now the language of choice for building the next generation of computer software. Includes a CD-ROM containing the example code and JBuilder for Windows and Solaris. Learning Java covers: