Categories

Kamami.pl - Official Raspberry Pi distributor

New products


Reduced price! Java. Advanced techniques. Edition VIII View larger

Java. Advanced techniques. Edition VIII

Cay S. Horstmann, Gary Cornell

More details

ID: 55875

22,24€ gross (5% VAT)
21,18€ net

Add to wishlist

More info

  • How to use streams?
  • How to create an effective user interface?
  • How to ensure security in created applications?

What made the Java programming language become so popular? There are several reasons for this: the ability to transfer code between programs, performance and what developers like the most - automatic memory cleansing mechanism. It is also important that Java is an object-oriented language, provides support for distributed programming and excellent documentation. In addition, numerous publications and a helpful community make Java a prominent place among other programming languages.

The next edition of the book, Java Advanced Techniques, Edition VIII, has been updated with all the elements that appeared in the sixth version of the Java Standard Edition platform. With this book, you'll learn how to use streams, how to parse XML documents, and how to create web applications. You will learn the JDBC interface, how to use transactions and execute SQL queries. The authors will show you in detail how to create applications using the Swing library. In addition, they will present how to ensure security in the applications you create. All these - and many more - issues will be presented in an accessible and proven way!

  • The use of streams
  • XML documents and their use in Java
  • Programming of network applications
  • Using the JDBC interface
  • Creating multilingual applications
  • The possibilities of the Swing package
  • The use of the AWT library
  • Security in applications
  • Application of a digital signature
  • Ways of using distributed objects (RMI)

Use the advanced Java capabilities in your projects!

Table of Contents

Foreword (11)
Thanks (15)
Chapter 1. Streams and files (17)
  • Streams (17)
    • Read and write bytes (18)
    • A zoo full of streams (20)
    • Connecting stream filters (24)
  • Text streams (27)
    • Saving text (28)
    • Loading text (31)
    • Saving objects in text format (31)
    • Character sets (35)
  • Reading and writing binary data (40)
    • Streams of random access files (43)
  • Streams of ZIP files (48)
  • Streams of objects and serialization (55)
    • Object serialization file format (61)
    • Modifying the default serialization mechanism (67)
    • Serialization of singletons and calculations (70)
    • Versions (71)
    • Serialization as cloning (73)
  • File management (75)
  • Improved input and output support (82)
    • Mapping files in memory (82)
    • Data buffer structure (89)
    • Blocking files (91)
  • Regular expressions (93)
Chapter 2. XML language (103)
  • Introduction to XML (104)
    • The structure of the XML document (106)
  • Parsing XML documents (109)
  • Validation of XML documents (120)
    • Definitions of document types (122)
    • XML Schema (129)
    • A practical example (131)
  • Information search and XPath (145)
  • Namespaces (151)
  • Streaming parsers (154)
    • Using the SAX parser (154)
    • Using the StAX parser (159)
  • Creating XML documents (163)
    • Creating an XML document using the StAX parser (167)
  • XSL transformations (174)
Chapter 3. Programming network applications (185)
  • Connections to the server (185)
    • Timeouts of sockets (190)
    • Internet addresses (191)
  • Server implementation (193)
    • Multiple customer support (196)
    • Partly closed connections (200)
    • Interrupting network sockets (201)
  • Sending an e-mail (207)
  • URL connections (212)
    • URL and URI (212)
    • Using the URLConnection class to retrieve information (214)
    • Sending data to forms (224)
Chapter 4. Connections to databases: JDBC (233)
  • JDBC Architecture (234)
    • Types of JDBC drivers (235)
    • Typical JDBC applications (236)
  • SQL language (237)
  • JDBC installation (243)
    • Database URLs (243)
    • JAR files containing the driver (244)
    • Starting the database (244)
    • Controller class registration (245)
    • Connecting to a database (246)
    • Executing SQL commands (248)
    • Managing connections, commands and result sets (251)
    • Analysis of SQL exceptions (252)
    • Completing the database (255)
  • Performing queries (258)
    • Prepared commands (259)
    • Reading and writing large objects (267)
    • Control sequences (269)
    • Queries about multiple result sets (270)
    • Retrieving the value of automatically generated keys (271)
  • Scrollable and updatable query result sets (272)
    • Scrollable result sets (272)
    • Updateable recordsets (274)
  • Recordsets (279)
    • Cached recordsets (279)
  • Metadata (282)
  • Transactions (292)
    • Checkpoints (293)
    • Batch updates (293)
    • Advanced SQL Types (295)
  • Advanced connection management (297)
  • Introduction to LDAP (298)
    • LDAP server configuration (299)
    • Access LDAP directory information (303)
Chapter 5. Internationalization (315)
  • Locator (316)
  • Number formats (321)
    • Currency (326)
  • Date and time (328)
  • Alphabetical order (335)
    • Stacking power (337)
    • Distribution (337)
  • Formatting messages (343)
    • Formatting with variants (345)
  • Text files and character sets (347)
    • Internationalization and program source files (347)
  • Sets of resources (348)
    • Resource location (349)
    • Property files (350)
    • Asset resource classes (351)
  • A complete example (353)
Chapter 6. Advanced Swing options (367)
  • Letters (367)
    • JList component (368)
    • List models (374)
    • Inserting and deleting (379)
    • Redrawing the contents of the list (381)
  • Tables (386)
    • The simplest tables (386)
    • Table Models (390)
    • Rows and columns (394)
  • Trees (421)
    • The simplest trees (422)
    • Browsing the nodes (438)
    • Drawing nodes (440)
    • Listening to events in trees (443)
    • Own tree models (450)
  • Text components (458)
    • Tracking changes in the content of text components (459)
    • Formatted input fields (463)
    • JSpinner component (479)
    • HTML presentation with JEditorPane (487)
  • Progress indicators (494)
    • Progress bars (494)
    • Progress monitors (498)
    • Monitoring the progress of input streams (501)
  • Component organizers (507)
    • Split panels (507)
    • Tabbed panels (511)
    • Dashboard panels and internal frames (518)
    • Cascade and neighboring arrangement (521)
    • Reporting a veto to change properties (529)
Chapter 7. Advanced capabilities of the AWT library (537)
  • Powered creation of graphics (538)
  • Figures (540)
    • Using graphic object classes (542)
  • Fields (555)
  • Brush trail (556)
  • Fillings (564)
  • Coordinate system transformations (566)
  • Trimming (571)
  • Image transparency and folding (573)
  • Tips for graphic operations (581)
  • Reading and saving graphic files (587)
    • Using objects to write and read image files (588)
    • Reading and writing files containing image sequences (592)
  • Operations on images (598)
    • Access image data (598)
    • Image filtering (604)
  • Printing (613)
    • Graphic printing (614)
    • Printing multiple pages (623)
    • Print preview (624)
    • Printing services (633)
    • Printing services through streams (637)
    • Printing attributes (638)
  • Clipboard (644)
    • Classes and interfaces that allow data transfer (645)
    • Text forwarding (646)
    • Transferable interface and data formats (650)
    • Uploading images using the clipboard (652)
    • Using the local clipboard to pass object references (657)
    • Using the system clipboard to upload Java objects (657)
    • Using a local clipboard to pass object references (661)
  • Drag and drop mechanism (662)
    • Data transfer between Swing components (664)
    • Sources of data being pulled (667)
    • Purposes of dropped data (670)
  • Integration with the native platform (678)
    • Welcome screen (678)
    • Running native desktop applications (683)
    • System tray (688)
Chapter 8. JavaBeans (693)
  • Why grains? (694)
  • The process of creating JavaBeans (696)
  • Application of grains for application development (698)
    • Placing grains in JAR files (699)
    • Using beans (700)
  • Patterns of names of grains and events (705)
  • Types of grain properties (709)
    • Simple Properties (709)
    • Indexed properties (710)
    • Related properties (710)
    • Limited Properties (712)
  • Information class of the seed (719)
  • Property editors (722)
    • Implementation of the property editor (726)
  • Individualisation of grain (733)
    • Implementation of the class of individualization (735)
  • Durability of JavaBeans (742)
    • Application of the JavaBeans persistence mechanism for any data (746)
    • A complete example of JavaBeans durability (752)
Chapter 9. Security (763)
  • Loading classes (764)
    • Hierarchy of loading classes (766)
    • Using load procedures as a namespace (768)
    • Implementation of own loading procedure (769)
  • Virtual machine code verification (774)
  • Security and authorization managers (779)
    • Security on the Java platform (781)
    • Security policy files (784)
    • Creating your own permission classes (790)
    • Implementation of the permission class (792)
    • User authentication (798)
    • JAAS modules (804)
  • Digital signature (813)
    • Message shortcuts (814)
    • Signing messages (820)
    • X.509 Certificates (822)
    • Signature verification (823)
    • Authentication problem (825)
    • Signing certificates (827)
    • Certificate Requests (829)
  • Code signing (830)
    • Signing JAR files (830)
    • Software Developer Certificates (835)
  • Encryption (837)
    • Symmetric encryption (837)
    • Generating a key (839)
    • Encryption streams (843)
    • Public key encryption (844)
Chapter 10. Distributed objects (851)
  • Client and server roles (852)
  • Calling remote methods (854)
    • Substitute and parameter scheduling (854)
  • RMI programming model (856)
    • Interfaces and implementations (856)
    • The RMI registry (858)
    • Preparation of implementation (861)
    • Recording RMI activity (864)
  • Parameters of remote methods and return values (866)
    • Forwarding remote objects (866)
    • Forwarding objects that are not remote (866)
    • Dynamic class loading (868)
    • Remote reference for objects with multiple interfaces (873)
    • Remote objects and methods equals, hashCode and clone (874)
  • Activation of remote objects (874)
  • Network services and JAX-WS (880)
    • Applying JAX-WS (881)
    • Web service client (884)
    • Amazon service (886)
Chapter 11. Scripts, compilation and annotations (893)
  • Scripts on the Java platform (893)
    • Selection of the script engine (894)
    • Entry and exit redirection (897)
    • Invoking functions and methods of scripts (898)
    • Script compilation (900)
    • Example: scripts and graphical user interface (901)
  • The compiler interface (905)
    • Compilation in the simplest way (906)
    • Applying compilation tasks (906)
    • Example: dynamic code creation in Java (911)
  • Using annotations (916)
  • Example - event handling annotations (918)
  • Syntax annotation (922)
  • Standard annotations (926)
    • Annotate compilation (927)
    • Annotations on resource management (928)
    • Meta-notes (928)
  • Processing annotations in the source code (931)
  • Byte code engineering (937)
    • Modification of the byte code during loading (943)
Chapter 12. Mother methods (947)
  • C language functions calls from Java programs (948)
  • Numeric method parameters and return values (954)
    • Using the printf function to format numbers (955)
  • Character strings as parameters (956)
  • Access to object components (961)
    • Accessing the instance fields (962)
    • Access to static fields (965)
  • Signatures (966)
  • Invoking Java methods (967)
    • Invoking object methods (968)
    • Invoking static methods (972)
    • Constructors (973)
    • Alternative ways to call methods (973)
  • Boards (975)
  • Error handling (978)
  • Software interface for Java calls (983)
  • A complete example: access to the Windows registry (988)
    • Windows registry (988)
    • Registry access interface on the Java platform (990)
    • Implementation of registry access using native methods (990)
Index (1005)