Cantitate/Preț
Produs
Total produse
Vezi coșul
Java 5.0 Tiger de Brett Mclaughlin

Java 5.0 Tiger

Autor Brett Mclaughlin, David Flanagan
en Limba Engleză Paperback – 3 aug 2004
Java 5.0, code-named "Tiger," promises to be the most significant new version of Java since the introduction of the language. With over a hundred substantial changes to the core language, as well as numerous library and API additions, developers have a variety of new features, facilities, and techniques available.But with so many changes, where do you start? You could read through the lengthy, often boring language specification; you could wait for the latest 500 page tome on concepts and theory; you could even play around with the new JDK, hoping you figure things out--or you can get straight to work with "Java 5.0 Tiger: A Developer's Notebook."This no-nonsense, down-and-dirty guide by bestselling Java authors Brett McLaughlin and David Flanagan skips all the boring prose and lecture, and jumps right into Tiger. You'll have a handle on the important new features of the language by the end of the first chapter, and be neck-deep in code before you hit the halfway point. Using the task-oriented format of this new series, you'll get complete practical coverage of generics, learn how boxing and unboxing affects your type conversions, understand the power of varargs, learn how to write enumerated types and annotations, master Java's new formatting methods and the for/in loop, and even get a grip on concurrency in the JVM.Light on theory and long on practical application, "Java 5.0 Tiger: A Developer's Notebook" allows you to cut to the chase, getting straight to work with Tiger's new features. The new Developer's Notebooks series from O'Reilly covers important new tools for software developers. Emphasizing example over explanation and practice over theory, they focus on learning by doing--you'll get the goods straight from the masters, in an informal and code-intensive style that suits developers. If you've been curious about Tiger, but haven't known where to start, this no-fluff, lab-style guide is the solution.
Citește tot Restrânge

Preț: 16457 lei

Preț vechi: 20572 lei
-20%

Puncte Express: 247

Carte disponibilă

Livrare economică 28 septembrie-12 octombrie

Livrare prin curier în România Termenul estimat este afișat lângă disponibilitate.
Transport gratuit de la 40000 lei Plată online sau ramburs, în funcție de opțiunile comenzii.
Retur gratuit în 14 zile Comandă securizată și suport în română.
 Adaugă în coș

Wish list
Gift list
Am citit!
Adaugă în listă

Specificații

ISBN-13: 9780596007386
ISBN-10: 0596007388
Pagini: 177
Dimensiuni: 165 x 247 x 13 mm
Greutate: 0.33 kg
Editura: O'Reilly
Locul publicării:United States

Cuprins

Copyright;
The Developer's Notebook Series;
Notebooks Are...;
Notebooks Aren't...;
Organization;
Preface;
Organization;
How This Book Was Written;
About the Examples;
Conventions Used in This Book;
How to Contact Us;
Acknowledgments from Brett;
Acknowledgments from David;
Chapter 1: What's New?;
1.1 Working with Arrays;
1.2 Using Queues;
1.3 Ordering Queues Using Comparators;
1.4 Overriding Return Types;
1.5 Taking Advantage of Better Unicode;
1.6 Adding StringBuilder to the Mix;
Chapter 2: Generics;
2.1 Using Type-Safe Lists;
2.2 Using Type-Safe Maps;
2.3 Iterating Over Parameterized Types;
2.4 Accepting Parameterized Types as Arguments;
2.5 Returning Parameterized Types;
2.6 Using Parameterized Types as Type Parameters;
2.7 Checking for Lint;
2.8 Generics and Type Conversions;
2.9 Using Type Wildcards;
2.10 Writing Generic Types;
2.11 Restricting Type Parameters;
Chapter 3: Enumerated Types;
3.1 Creating an Enum;
3.2 Declaring Enums Inline;
3.3 Iterating Over Enums;
3.4 Switching on Enums;
3.5 Maps of Enums;
3.6 Sets of Enums;
3.7 Adding Methods to an Enum;
3.8 Implementing Interfaces with Enums;
3.9 Value-Specific Class Bodies;
3.10 Manually Defining an Enum;
3.11 Extending an Enum;
Chapter 4: Autoboxing and Unboxing;
4.1 Converting Primitives to Wrapper Types;
4.2 Converting Wrapper Types to Primitives;
4.3 Incrementing and Decrementing Wrapper Types;
4.4 Boolean Versus boolean;
4.5 Conditionals and Unboxing;
4.6 Control Statements and Unboxing;
4.7 Method Overload Resolution;
Chapter 5: varargs;
5.1 Creating a Variable-Length Argument List;
5.2 Iterating Over Variable-Length Argument Lists;
5.3 Allowing Zero-Length Argument Lists;
5.4 Specify Object Arguments Over Primitives;
5.5 Avoiding Automatic Array Conversion;
Chapter 6: Annotations;
6.1 Using Standard Annotation Types;
6.2 Annotating an Overriding Method;
6.3 Annotating a Deprecated Method;
6.4 Suppressing Warnings;
6.5 Creating Custom Annotation Types;
6.6 Annotating Annotations;
6.7 Defining an Annotation Type's Target;
6.8 Setting the Retention of an Annotation Type;
6.9 Documenting Annotation Types;
6.10 Setting Up Inheritance in Annotations;
6.11 Reflecting on Annotations;
Chapter 7: The for/in Statement;
7.1 Ditching Iterators;
7.2 Iterating over Arrays;
7.3 Iterating over Collections;
7.4 Avoiding Unnecessary Typecasts;
7.5 Making Your Classes Work with for/in;
7.6 Determining List Position and Variable Value;
7.7 Removing List Items in a for/in Loop;
Chapter 8: Static Imports;
8.1 Importing Static Members;
8.2 Using Wildcards in Static Imports;
8.3 Importing Enumerated Type Values;
8.4 Importing Multiple Members with the Same Name;
8.5 Shadowing Static Imports;
Chapter 9: Formatting;
9.1 Creating a Formatter;
9.2 Writing Formatted Output;
9.3 Using the format( ) Convenience Method;
9.4 Using the printf( ) Convenience Method;
Chapter 10: Threading;
10.1 Handling Uncaught Exceptions in Threads;
10.2 Using Thread-Safe Collections;
10.3 Using Blocking Queues;
10.4 Specifying Timeouts for Blocking;
10.5 Separating Thread Logic from Execution Logic;
10.6 Using Executor as a Service;
10.7 Using Callable Objects;
10.8 Executing Tasks Without an ExecutorService;
10.9 Scheduling Tasks;
10.10 Advanced Synchronizing;
10.11 Using Atomic Types;
10.12 Locking Versus Synchronization;
Colophon;