%{search_type} search results

• Cover
• Title Page
• Copyright and Credits
• Contributors
• About the reviewers
• Table of Contents
• Preface
• Part 1: The Java Development Environment
• Chapter 1: Understanding Java Distributions
• Technical requirements
• A little history
• What makes Java special?
• Why are there many distributions of Java?
• Which Java should you get?
• How is Java licensed?
• Why are there so many versions of Java?
• Installing Java
• As an admin
• As a non-admin
• What is in the box?
• Compiling and executing a Java program
• Assembling and packaging a Java application

• Documenting Java classes
• REPL
• Summary
• Further reading
• Chapter 2: Code, Compile, and Execute
• Technical requirements
• The first program
• JShell
• REPL in Java
• The two-step compile and execute process
• javac and java/javaw
• Launch Single-File Source-Code Programs
• For Windows, macOS, and Linux
• For macOS and Linux
• Shebang files
• Integrated development environments
• Eclipse Foundation
• Eclipse
• Apache NetBeans
• Microsoft Visual Studio Code
• JetBrains IntelliJ IDEA
• Which IDE should you use?
• Summary
• Further reading
• Chapter 3: The Maven Build Tool

• Technical requirements
• Installing Maven
• Windows
• Linux
• macOS
• Overview of Maven functionality
• Dependency management
• Maven plugins
• Maven project layout
• Java source code packages
• The pom.xml configuration file
• jar
• Java archive
• War
• web archive
• ear
• enterprise archive
• pom
• POM
• The build section
• Running Maven
• Command-line Maven
• Running Maven in an IDE
• Summary
• Further reading
• Part 2: Language Fundamentals
• Chapter 4: Language Fundamentals
• Data Types and Variables
• Technical requirements
• Primitive data types
• Type safety

• Literal values
• Integers
• Floating point
• Boolean
• char
• A special case
• String
• Naming identifiers
• Constants
• Operators
• Casting
• Overflow and underflow
• Wrapper classes
• The math library
• Summary
• Further reading
• Chapter 5: Language Fundamentals
• Classes
• Technical requirements
• Class fields
• Understanding access control
• Packages
• The public specifier
• The private specifier
• The protected specifier
• The package specifier
• Understanding classes
• constructor and finalize methods
• Revising the compound interest program

• Class organization based on functionality
• Summary
• Further reading
• Chapter 6: Methods, Interfaces, Records, and Their Relationships
• Technical requirements
• Understanding methods
• Access control designation
• Static or non-static designation and the this reference
• Override permission
• final
• Override required
• abstract
• Return type
• Method name
• Parameter variables
• Annotations
• Exception handling
• throws
• Thread setting
• Generic parameters
• Understanding inheritance
• The superclass of all objects, the Object class
• Understanding the class interface

Develop your Java coding skills by exploring object-oriented methodologies, functional programming, software design patterns, and more Purchase of the print or Kindle book includes a free PDF eBook Key Features Get started with programming in Java with this step-by-step guide for experienced programmers Re-enforce your knowledge of object-oriented methodologies applied in Java Develop the range of skills necessary for you to become a successful Java developer Book Description This comprehensive guide will help non-Java developers already using different languages transition from their current language to all things Java. The chapters are designed in a way that re-enforces a developer's existing knowledge of object-oriented methodologies as they apply to Java. This book has been divided into four sections, with each section touching upon different aspects that'll enable your effective transition. The first section helps you get to grips with the Java development environment and the Maven build tool for modern Java applications. In the second section, you'll learn about Java language fundamentals, along with exploring object-oriented programming (OOP) methodologies and functional programming and discovering how to implement software design patterns in Java. The third section shows you how to code in Java on different platforms and helps you get familiar with the challenges faced on these platforms. In the fourth section, you'll find out how you can manage and package your Java code. By the end of this Java programming book, you'll have learned the core concepts of Java that'll help you successfully transition from a different language to Java. What you will learn Gain a solid understanding of the syntax in Java Explore the object-oriented programming basics of the Java language Discover how to implement functions in Java Understand which Java frameworks would be best for solving various problems Explore creational, structural, and behavioral patterns in Java Get to grips with server-side coding in Java Who this book is for This book is for anyone who is currently working with other programming languages and wishes to add Java to their skillset. Prior working experience as a developer using languages other than Java is expected, although no prior knowledge of Java is required.

• Preface xxiii Acknowledgments xxv About the Author xxvii
• Chapter 1: Fundamental Programming Structures 1 1.1 Our First Program 2 1.2 Primitive Types 11 1.3 Variables 14 1.4 Arithmetic Operations 17 1.5 Strings 25 1.6 Input and Output 35 1.7 Control Flow 38 1.8 Arrays and Array Lists 46 1.9 Functional Decomposition 56 Exercises 58
• Chapter 2: Object-Oriented Programming 61 2.1 Working with Objects 62 2.2 Implementing Classes 67 2.3 Object Construction 71 2.4 Records 76 2.5 Static Variables and Methods 79 2.6 Packages 83 2.7 Nested Classes 90 2.8 Documentation Comments 95 Exercises 100
• Chapter 3: Interfaces and Lambda Expressions 105 3.1 Interfaces 106 3.2 Static, Default, and Private Methods 113 3.3 Examples of Interfaces 117 3.4 Lambda Expressions 121 3.5 Method and Constructor References 124 3.6 Processing Lambda Expressions 127 3.7 Lambda Expressions and Variable Scope 131 3.8 Higher-Order Functions 135 3.9 Local and Anonymous Classes 137 Exercises 139
• Chapter 4: Inheritance and Reflection 143 4.1 Extending a Class 144 4.2 Inheritance Hierarchies 150 4.3 Object: The Cosmic Superclass 157 4.4 Enumerations 166 4.5 Runtime Type Information and Resources 170 4.6 Reflection 179 Exercises 188
• Chapter 5: Exceptions, Assertions, and Logging 191 5.1 Exception Handling 192 5.2 Assertions 204 5.3 Logging 206 Exercises 214
• Chapter 6: Generic Programming 219 6.1 Generic Classes 220 6.2 Generic Methods 221 6.3 Type Bounds 222 6.4 Type Variance and Wildcards 223 6.5 Generics in the Java Virtual Machine 228 6.6 Restrictions on Generics 231 6.7 Reflection and Generics 238 Exercises 241
• Chapter 7: Collections 247 7.1 An Overview of the Collections Framework 248 7.2 Iterators 252 7.3 Sets 254 7.4 Maps 255 7.5 Other Collections 259 7.6 Views 264 Exercises 267
• Chapter 8: Streams 271 8.1 From Iterating to Stream Operations 272 8.2 Stream Creation 273 8.3 The filter, map, and flatMap Methods 276 8.4 Extracting Substreams and Combining Streams 278 8.5 Other Stream Transformations 279 8.6 Simple Reductions 280 8.7 The Optional Type 281 8.8 Collecting Results 286 8.9 Collecting into Maps 287 8.10 Grouping and Partitioning 289 8.11 Downstream Collectors 289 8.12 Reduction Operations 292 8.13 Primitive Type Streams 294 8.14 Parallel Streams 295 Exercises 298
• Chapter 9: Processing Input and Output 301 9.1 Input/Output Streams, Readers, and Writers 302 9.2 Paths, Files, and Directories 312 9.3 HTTP Connections 320 9.4 Regular Expressions 323 9.5 Serialization 333 Exercises 344
• Chapter 10: Concurrent Programming 347 10.1 Concurrent Tasks 348 10.2 Asynchronous Computations 353 10.3 Thread Safety 360 10.4 Parallel Algorithms 366 10.5 Threadsafe Data Structures 368 10.6 Atomic Counters and Accumulators 373 10.7 Locks and Conditions 375 10.8 Threads 381 10.9 Processes 386 Exercises 390
• Chapter 11: Annotations 397 11.1 Using Annotations 398 11.2 Defining Annotations 403 11.3 Standard Annotations 406 11.4 Processing Annotations at Runtime 410 11.5 Source-Level Annotation Processing 413 Exercises 417
• Chapter 12: The Date and Time API 421 12.1 The Time Line 422 12.2 Local Dates 424 12.3 Date Adjusters 428 12.4 Local Time 429 12.5 Zoned Time 430 12.6 Formatting and Parsing 433 12.7 Interoperating with Legacy Code 436 Exercises 437
• Chapter 13: Internationalization 441 13.1 Locales 442 13.2 Number Formats 447 13.3 Currencies 448 13.4 Date and Time Formatting 449 13.5 Collation and Normalization 451 13.6 Message Formatting 453 13.7 Resource Bundles 455 13.8 Character Encodings 458 13.9 Preferences 459 Exercises 461
• Chapter 14: Compiling and Scripting 463 14.1 The Compiler API 463 14.2 The Scripting API 467 Exercises 472
• Chapter 15: The Java Platform Module System 475 15.1 The Module Concept 476 15.2 Naming Modules 478 15.3 The Modular "Hello, World!" Program 478 15.4 Requiring Modules 480 15.5 Exporting Packages 482 15.6 Modules and Reflective Access 485 15.7 Modular JARs 488 15.8 Automatic Modules 489 15.9 The Unnamed Module 491 15.10 Command-Line Flags for Migration 491 15.11 Transitive and Static Requirements 493 15.12 Qualified Exporting and Opening 495 15.13 Service Loading 496 15.14 Tools for Working with Modules 497 Exercises 499 Index 501.
• (source: Nielsen Book Data)

Clear, Concise Guide to the Core Language and Libraries--Updated through Java 17 Modern Java introduces major enhancements that impact the core Java technologies and APIs at the heart of the Java platform. Many old Java idioms are no longer needed, and new features and programming paradigms can make you far more effective. However, navigating these changes can be challenging. Core Java for the Impatient, Third Edition, is a complete yet concise guide that reflects all changes through Java SE 17, Oracle's latest Long-Term Support (LTS) release. Written by Cay S. Horstmann--author of the classic two-volume Core Java--this indispensable tutorial offers a faster, easier pathway for learning modern Java. Horstmann covers everything working developers need to know, including the powerful concepts of lambda expressions and streams, modern constructs such as records and sealed classes, and sophisticated concurrent programming techniques. Given the size and scope of Java 17, there's plenty to cover, but it's presented in small chunks organized for quick access and easy understanding, with plenty of practical insights and sample code to help you quickly apply all that's new. Test code as you create it with JShell Improve your object-oriented design with records and sealed classes Effectively use text blocks, switch expressions, and pattern matching Understand functional programming with lambda expressions Streamline and optimize data management with the Streams API Use modern library features and threadsafe data structures to implement concurrency reliably Work with the modularized Java API and third-party modules Take advantage of API improvements for working with collections, input/output, regular expressions, and processes Learn the APIs for date/time processing and internationalization Whether you're an experienced developer just getting started with modern Java, or have been programming with Java for years, this guide will help you write more robust, efficient, and secure Java code. Register your book for convenient access to downloads, updates, and/or corrections as they become available. See inside book for details.
(source: Nielsen Book Data)

• Intro
• Table of Contents
• About the Authors
• About the Technical Reviewer
• Acknowledgments
• Introduction
• Chapter 1: Jakarta Servlets
• 1-1. Setting Up a Jakarta EE Application Server
• Problem
• Solution
• How It Works
• 1-2. Developing a Servlet
• Problem
• Solution
• How It Works
• 1-3. Packaging, Compiling, and Deploying a Servlet
• Problem
• Solution
• Quick Start
• How It Works
• 1-4. Registering a Servlet Without web.xml
• Problem
• Solution
• How It Works
• 1-5. Displaying Dynamic Content with a Servlet
• Problem
• Solution
• How It Works

• 1-6. Handling Requests and Responses
• Problem
• Solution
• How It Works
• 1-7. Listening for Servlet Container Events
• Problem
• Solution
• How It Works
• 1-8. Setting Initialization Parameters
• Problem
• Solution #1
• Solution #2
• How It Works
• 1-9. Filtering Web Requests
• Problem
• Solution
• How It Works
• 1-10. Listening for Attribute Changes
• Problem
• Solution
• How It Works
• 1-11. Applying a Listener to a Session
• Problem
• Solution
• How It Works
• 1-12. Managing Session Attributes
• Problem
• Solution
• How It Works
• 1-13. Downloading a File

• Problem
• Solution
• How It Works
• 1-14. Dispatching Requests
• Problem
• Solution
• How It Works
• 1-15. Redirecting to a Different Site
• Problem
• Solution
• How It Works
• 1-16. Securely Maintaining State Within the Browser
• Problem
• Solution
• How It Works
• 1-17. Finalizing Servlet Tasks
• Problem
• Solution
• How It Works
• 1-18. Reading and Writing with Nonblocking I/O
• Problem
• Solution
• How It Works
• 1-19. Pushing Resources from a Server to a Client
• Problem
• Solution
• How It Works
• Chapter 2: Jakarta Server Pages

• 2-1. Creating a Simple Jakarta Server Page
• Problem
• Solution
• How It Works
• 2-2. Embedding Java into a Jakarta Server Page
• Problem
• Solution
• How It Works
• 2-3. Separating Business Logic from View Code
• Problem
• Solution
• How It Works
• 2-4. Yielding or Setting Values
• Problem
• Solution
• How It Works
• 2-5. Invoking a Function in a Conditional Expression
• Problem
• Solution
• How It Works
• 2-6. Creating a Jakarta Server Page Document
• Problem
• Solution
• How It Works
• 2-7. Embedding Expressions in Jakarta Expression Language
• Problem
• Solution

• How It Works
• 2-8. Accessing Parameters in Multiple Pages
• Problem
• Solution
• How It Works
• 2-9. Creating a Custom Jakarta Server Tag
• Problem
• Solution
• How It Works
• 2-10. Including Other Jakarta Server Pages into a Page
• Problem
• Solution
• How It Works
• 2-11. Creating an Input Form for a Database Record
• Problem
• Solution
• How It Works
• 2-12. Looping Through Database Records Within a Page
• Problem
• Solution
• How It Works
• 2-13. Handling Errors in Jakarta Server Pages
• Problem
• Solution
• How It Works
• 2-14. Disabling Scriptlets in Pages

Take a problem-solution approach for programming enterprise Java or Java EE applications and microservices for cloud-based solutions, enterprise database applications, and even small business web applications. Java EE to Jakarta EE 10 Recipes provides effective, practical, and proven code snippets that you can immediately use to accomplish just about any task that you may encounter. You can feel confident using the reliable solutions that are demonstrated in this book in your personal or corporate environment. Java EE was made open source under the Eclipse Foundation, and Jakarta EE is the new name for what used to be termed the Java Platform, Enterprise Edition. This book helps you rejuvenate your Java expertise and put the platform’s latest capabilities to use for quickly developing robust applications. If you are new to Jakarta EE, this book will help you learn the features of the platform and benefit from one of the most widely used and powerful technologies available for cloud-native enterprise application development today. Examples in this book highlight Jakarta EE’s capabilities, helping you to build streamlined and reliable applications using the latest in Java technologies. The book takes a problem-solution approach in which each section introduces a common programming problem, showing you how to solve that problem in the best possible way using the latest features in Jakarta EE. Solutions in the form of working code examples are presented that you can download and use immediately in your own projects. Clear descriptions are provided to help you understand and learn to build further on the solutions provided.

Detailed summary in vernacular field only
Java性能优化越来越难。曾经，通过引入即时编 译器，就能实现8倍的性能飞跃。而今，你可能会 有疑问：Java性能还有多大的优化空间？本书直面 这一问题，证明对于工程师而言，仍有很多工作 可做！作为曾在Java性能工程小组深耕多年的老牌 工程师，本书作者透彻解释了JVM和Java平台特性对 应用程序性能的影响。 应用程序开发人员和性能优化工程师将了解针对J ava 8和Java 11的性能优化措施、工具和方法，也会了解提前 编译和一些实验性的垃圾回收器。Java的调优标志 数以百计。读完本书，你不必再盲目测试这些标 志的效果，而是能够从根本上理解应用程序性能 欠佳的原因，并熟练地运用恰当的标志提升性能 。 理解Java平台特性和编译器如何影响性能 掌握Java垃圾回收机制 通过遵循4项原则来优化性能测试结果 使用JDK等工具了解Java应用程序的性能情况 通过编程实践来尽量降低垃圾回收器的不良影响 解决Java API的各种性能难题 改善数据库应用程序的性能.

Java is one of the most preferred languages among developers. It is used in everything right from smartphones and game consoles to even supercomputers, and its new features simply add to the richness of the language. This book on Java programming begins by helping you learn how to install the Java Development Kit. You'll then focus on understanding object-oriented programming (OOP), with exclusive insights into concepts such as abstraction, encapsulation, inheritance, and polymorphism, which will help you when programming for real-world apps. Next, you'll cover fundamental programming structures of Java such as data structures and algorithms that will serve as the building blocks for your apps with the help of sample programs and practice examples. You'll also delve into core programming topics that will assist you with error handling, debugging, and testing your apps. As you progress, you'll move on to advanced topics such as Java libraries, database management, and network programming and also build a sample project to help you understand the applications of these concepts. By the end of this Java book, you'll not only have become well-versed with Java 17 but also gained a perspective into the future of this language and have the skills to code efficiently with best practices.

• Table of Contents Introduction to Java Variables, Data Types, and Operators Control Flow Object-Oriented Programming OOP in Depth Data Structures, Arrays, and Strings The Java Collections Framework and Generics Advanced Data Structures in Java Exception Handling.
• (source: Nielsen Book Data)

Enhance your career options with this well-crafted object-oriented programming language that enjoys the support of an enormous ecosystem of tools and libraries Key Features Get introduced to Java, its features, and its ecosystem Understand how Java uses object-oriented programming Become an expert Java exception handler Book DescriptionSince its inception, Java has stormed the programming world. Its features and functionalities provide developers with the tools needed to write robust cross-platform applications. Java Fundamentals introduces you to these tools and functionalities that will enable you to create Java programs. The book begins with an introduction to the language, its philosophy, and evolution over time, until the latest release. You'll learn how the javac/java tools work and what Java packages are - the way a Java program is usually organized. Once you are comfortable with this, you'll be introduced to advanced concepts of the language, such as control flow keywords. You'll explore object-oriented programming and the part it plays in making Java what it is. In the concluding chapters, you'll get to grips with classes, typecasting, and interfaces, and understand the use of data structures, arrays, strings, handling exceptions, and creating generics. By the end of this book, you will have learned to write programs, automate tasks, and follow advanced courses on algorithms and data structures or explore more advanced Java courses. What you will learn Create and run Java programs Use data types, data structures, and control flow in your code Implement best practices while creating objects Work with constructors and inheritance Understand advanced data structures to organize and store data Employ generics for stronger check-types during compilation Learn to handle exceptions in your code Who this book is forJava Fundamentals is designed for tech enthusiasts who are familiar with some programming languages and want a quick introduction to the most important principles of Java.
(source: Nielsen Book Data)

• Cover
• Title Page
• Copyright
• Credits
• About the Authors
• About the Reviewer
• www.PacktPub.com
• Customer Feedback
• Table of Contents
• Preface
• Chapter 1: Learning Java 9 Underlying Performance Improvements
• Introducing the new features of Java 9
• Modular development and its impact
• Quick introduction to modules
• String operations performance
• Compact string
• The world of heap
• Why bother compressing strings?
• What did they do?
• What is the escape route?
• What is the performance gain?

• Indify String ConcatenationInvokedynamic
• Storing interned strings in CDS archives
• Concurrency performance
• Compiler improvements
• Tiered Attribution
• Ahead-of-Time compilation
• Security manager improvements
• Graphics rasterizers
• Summary
• Chapter 2: Identifying Performance Bottlenecks
• CPU infrastructure
• Memory utilization
• Java heap
• Java stack
• Java heap versus stack memory
• Escape analysis
• Common memory problems
• OutOfMemory
• Mismanagement of object life cycle: java.lang. OutOfMemoryError: Java heap space

• Java.lang. OutOfMemoryError: GC Overhead limit exceededjava.lang. OutOfMemoryError: Permgen space
• java.lang. OutOfMemoryError: Metaspace
• java.lang. OutOfMemoryError: Unable to create new native thread
• java.lang. OutOfMemoryError: request size bytes for reason
• java.lang. OutOfMemoryError: Requested array size exceeds VM limit
• Out of memory: kill process or sacrifice child
• StackOverFlow
• Database operations
• I/O operations
• Network operations
• WebSocket Client API
• Summary
• Chapter 3: Learning How to Troubleshoot Code

• Measuring performancePerformance checklist
• Basic principles of troubleshooting
• Why some developers find troubleshooting difficult?
• Setting up the environment for troubleshooting
• Importance of error handling
• A basic try-catch-finally block and its usages
• What are try-catch-finally blocks?
• Usage of try-catch-finally blocks
• Mistakes programmers make when using error handling
• Why swallowing exception is bad?
• Use of logging
• Logging vs Debugging
• What are the main components?
• How to do logging?

• What logging frameworks are available?Java Util Logging
• Log4j 2
• Logback
• Performance
• Support
• Ease of Use
• Best use case for logging
• Analyzing thread dump
• What is a thread dump?
• Benefits of thread dump analysis
• How to collect a thread dump
• How to analyze a thread dump
• Best practices
• Analyzing heap dump
• What is a heap dump
• Benefits of analyzing heap dumps
• When do you analyze a heap dump
• How to collect heap dump
• How to analyze heap dump
• Best practices
• Summary

Best practices to adapt and bottlenecks to avoid About This Book * Tackle all kinds of performance-related issues and streamline your development * Master the new features and new APIs of Java 9 to implement highly efficient and reliable codes * Gain an in-depth knowledge of Java application performance and obtain best results from performance testing Who This Book Is For This book is for Java developers who would like to build reliable and high-performance applications. Prior Java programming knowledge is assumed. What You Will Learn * Work with JIT compilers * Understand the usage of profiling tools * Generate JSON with code examples * Leverage the command-line tools to speed up application development * Build microservices in Java 9 * Explore the use of APIs to improve application code * Speed up your application with reactive programming and concurrency In Detail Finally, a book that focuses on the practicalities rather than theory of Java application performance tuning. This book will be your one-stop guide to optimize the performance of your Java applications. We will begin by understanding the new features and APIs of Java 9. You will then be taught the practicalities of Java application performance tuning, how to make the best use of garbage collector, and find out how to optimize code with microbenchmarking. Moving ahead, you will be introduced to multithreading and learning about concurrent programming with Java 9 to build highly concurrent and efficient applications. You will learn how to fine tune your Java code for best results. You will discover techniques on how to benchmark performance and reduce various bottlenecks in your applications. We'll also cover best practices of Java programming that will help you improve the quality of your codebase. By the end of the book, you will be armed with the knowledge to build and deploy efficient, scalable, and concurrent applications in Java. Style and approach This step-by-step guide provides real-world examples to give you a hands-on experience.
(source: Nielsen Book Data)

• Variables, Input/Output and Arithmetic Objects: An Introduction Selection Structures Iteration Structures Objects: Revisited Strings Arrays Recursion Objects: Inheritance and Polymorphism Elementary File Input and Output Simple Graphical Input and Output Exceptions Java doc Comments Glossary Answers to Selected Exercises.
• (source: Nielsen Book Data)

This book presents a focused and accessible primer on the fundamentals of Java programming, with extensive use of examples and hands-on exercises. Topics and features: provides an introduction to variables, input/output and arithmetic operations; describes objects and contour diagrams, explains selection structures, and demonstrates how iteration structures work; discusses object-oriented concepts such as overloading and classes methods, and introduces string variables and processing; illustrates arrays and array processing and examines recursion; explores inheritance and polymorphism and investigates elementary files; presents a primer on graphical input/output, discusses elementary exception processing, and presents the basics of Javadoc; includes exercises at the end of each chapter, with selected answers in an appendix and a glossary of key terms; provides additional supplementary information at an associated website.
(source: Nielsen Book Data)

• Preface to the Java SE 8 Edition xxi
• Chapter 1: Introduction 1 1.1 Organization of the Specification 2 1.2 Example Programs 6 1.3 Notation 6 1.4 Relationship to Predefined Classes and Interfaces 7 1.5 Feedback 7 1.6 References 7
• Chapter 2: Grammars 9 2.1 Context-Free Grammars 9 2.2 The Lexical Grammar 9 2.3 The Syntactic Grammar 10 2.4 Grammar Notation 10
• Chapter 3: Lexical Structure 15 3.1 Unicode 15 3.2 Lexical Translations 16 3.3 Unicode Escapes 17 3.4 Line Terminators 19 3.5 Input Elements and Tokens 19 3.6 White Space 20 3.7 Comments 21 3.8 Identifiers 22 3.9 Keywords 24 3.10 Literals 24 3.11 Separators 38 3.12 Operators 38
• Chapter 4: Types, Values, and Variables 41 4.1 The Kinds of Types and Values 41 4.2 Primitive Types and Values 42 4.3 Reference Types and Values 52 4.4 Type Variables 57 4.5 Parameterized Types 59 4.6 Type Erasure 64 4.7 Reifiable Types 64 4.8 Raw Types 66 4.9 Intersection Types 70 4.10 Subtyping 71 4.11 Where Types Are Used 75 4.12 Variables 80
• Chapter 5: Conversions and Contexts 91 5.1 Kinds of Conversion 94 5.2 Assignment Contexts 107 5.3 Invocation Contexts 112 5.4 String Contexts 114 5.5 Casting Contexts 114 5.6 Numeric Contexts 124
• Chapter 6: Names 129 6.1 Declarations 130 6.2 Names and Identifiers 137 6.3 Scope of a Declaration 139 6.4 Shadowing and Obscuring 142 6.5 Determining the Meaning of a Name 148 6.6 Access Control 161 6.7 Fully Qualified Names and Canonical Names 169
• Chapter 7: Packages 173 7.1 Package Members 173 7.3 Compilation Units 177 7.4 Package Declarations 178 7.5 Import Declarations 180 7.6 Top Level Type Declarations 185
• Chapter 8: Classes 189 8.1 Class Declarations 191 8.2 Class Members 206 8.3 Field Declarations 211 8.4 Method Declarations 225 8.5 Member Type Declarations 254 8.6 Instance Initializers 255 8.7 Static Initializers 255 8.8 Constructor Declarations 256 8.9 Enum Types 266
• Chapter 9: Interfaces 277 9.1 Interface Declarations 278 9.2 Interface Members 282 9.3 Field (Constant) Declarations 283 9.4 Method Declarations 286 9.5 Member Type Declarations 291 9.6 Annotation Types 292 9.7 Annotations 308 9.8 Functional Interfaces 319 9.9 Function Types 323
• Chapter 10: Arrays 329 10.1 Array Types 330 10.2 Array Variables 330 10.3 Array Creation 332 10.4 Array Access 332 10.5 Array Store Exception 333 10.6 Array Initializers 335 10.7 Array Members 336 10.8 Class Objects for Arrays 338 10.9 An Array of Characters Is Not a String 339
• Chapter 11: Exceptions 341 11.1 The Kinds and Causes of Exceptions 342 11.2 Compile-Time Checking of Exceptions 344 11.3 Run-Time Handling of an Exception 349
• Chapter 12: Execution 353 12.1 Java Virtual Machine Startup 353 12.2 Loading of Classes and Interfaces 356 12.3 Linking of Classes and Interfaces 358 12.4 Initialization of Classes and Interfaces 360 12.5 Creation of New Class Instances 365 12.6 Finalization of Class Instances 369 12.7 Unloading of Classes and Interfaces 373 12.8 Program Exit 374
• Chapter 13: Binary Compatibility 375 13.1 The Form of a Binary 376 13.2 What Binary Compatibility Is and Is Not 382 13.3 Evolution of Packages 383 13.4 Evolution of Classes 383 13.5 Evolution of Interfaces 400
• Chapter 14: Blocks and Statements 405 14.1 Normal and Abrupt Completion of Statements 405 14.2 Blocks 407 14.3 Local Class Declarations 407 14.4 Local Variable Declaration Statements 408 14.5 Statements 410 14.6 The Empty Statement 412 14.7 Labeled Statements 413 14.8 Expression Statements 414 14.9 The if Statement 415 14.10 The assert Statement 416 14.11 The switch Statement 419 14.12 The while Statement 423 14.13 The do Statement 424 14.14 The for Statement 426 14.15 The break Statement 432 14.16 The continue Statement 434 14.17 The return Statement 436 14.18 The throw Statement 437 14.19 The synchronized Statement 439 14.20 The try statement 440 14.21 Unreachable Statements 452
• Chapter 15: Expressions 459 15.1 Evaluation, Denotation, and Result 459 15.2 Forms of Expressions 460 15.3 Type of an Expression 461 15.4 FP-strict Expressions 462 15.5 Expressions and Run-Time Checks 462 15.6 Normal and Abrupt Completion of Evaluation 464 15.7 Evaluation Order 466 15.8 Primary Expressions 471 15.9 Class Instance Creation Expressions 476 15.10 Array Creation and Access Expressions 487 15.11 Field Access Expressions 494 15.12 Method Invocation Expressions 499 15.13 Method Reference Expressions 529 15.14 Postfix Expressions 542 15.15 Unary Operators 544 15.16 Cast Expressions 549 15.17 Multiplicative Operators 550 15.18 Additive Operators 556 15.19 Shift Operators 561 15.20 Relational Operators 562 15.21 Equality Operators 565 15.22 Bitwise and Logical Operators 568 15.23 Conditional-And Operator && 570 15.24 Conditional-Or Operator
• (source: Nielsen Book Data)

Written by the inventors of the technology, The Java(R) Language Specification, Java SE 8 Edition is the definitive technical reference for the Java programming language. The book provides complete, accurate, and detailed coverage of the Java programming language. It fully describes the new features added in Java SE 8, including lambda expressions, method references, default methods, type annotations, and repeating annotations. The book also includes many explanatory notes and carefully distinguishes the formal rules of the language from the practical behavior of compilers.
(source: Nielsen Book Data)

• Getting Started with Java Discovering Classes and Objects Exploring Advanced Language Features Touring Language and Utility APIs Collecting Objects Touring Additional Utility APIs Creating and Enriching Graphical User Interfaces Interacting with Filesystems Interacting with Networks and Databases Parsing, Creating, and Transforming XML Documents Working with Web Services Java 7 Meets Android.
• (source: Nielsen Book Data)

Beginning Java 7 guides you through version 7 of the Java language and a wide assortment of platform APIs. New Java 7 language features that are discussed include switch-on-string and try-with-resources. APIs that are discussed include Threading, the Collections Framework, the Concurrency Utilities, Swing, Java 2D, networking, JDBC, SAX, DOM, StAX, XPath, JAX-WS, and SAAJ. This book also presents an introduction to Android app development so that you can apply some of its knowledge to the exciting world of Android app development. This book presents the following table of contents: Chapter 1 introduces you to Java and begins to cover the Java language by focusing on fundamental concepts such as comments, identifiers, variables, expressions, and statements. Chapter 2 continues to explore this language by presenting all of its features for working with classes and objects. You learn about features related to class declaration and object creation, encapsulation, information hiding, inheritance, polymorphism, interfaces, and garbage collection. Chapter 3 focuses on the more advanced language features related to nested classes, packages, static imports, exceptions, assertions, annotations, generics, and enums. Additional chapters introduce you to the few features not covered in Chapters 1 through 3. Chapter 4 largely moves away from covering language features (although it does introduce class literals and strictfp) while focusing on language-oriented APIs. You learn about Math, StrictMath, Package, Primitive Type Wrapper Classes, Reference, Reflection, String, StringBuffer and StringBuilder, Threading, BigDecimal, and BigInteger in this chapter. Chapter 5 begins to explore Java's utility APIs by focusing largely on the Collections Framework. However, it also discusses legacy collection-oriented APIs and how to create your own collections. Chapter 6 continues to focus on utility APIs by presenting the concurrency utilities along with the Objects and Random classes. Chapter 7 moves you away from the command-line user interfaces that appear in previous chapters and toward graphical user interfaces. You first learn about the Abstract Window Toolkit foundation, and then explore the Java Foundation Classes in terms of Swing and Java 2D. Appendix C explores Accessibility and Drag and Drop. Chapter 8 explores filesystem-oriented I/O in terms of the File, RandomAccessFile, stream, and writer/reader classes. Chapter 9 introduces you to Java's network APIs (e.g., sockets). It also introduces you to the JDBC API for interacting with databases along with the Java DB database product. Chapter 10 dives into Java's XML support by first presenting an introduction to XML (including DTDs and schemas). It next explores the SAX, DOM, StAX, XPath, and XSLT APIs. It even briefly touches on the Validation API. While exploring XPath, you encounter namespace contexts, extension functions and function resolvers, and variables and variable resolvers. Chapter 11 introduces you to Java's support for SOAP-based and RESTful web services. As well as providing you with the basics of these web service categories, Chapter 11 presents some advanced topics, such as working with the SAAJ API to communicate with a SOAP-based web service without having to rely on JAX-WS. You will appreciate having learned about XML in Chapter 10 before diving into this chapter. Chapter 12 helps you put to use some of the knowledge you've gathered in previous chapters by showing you how to use Java to write an Android app's source code. This chapter introduces you to Android, discusses its architecture, shows you how to install necessary tools, and develops a simple app. Appendix A presents the solutions to the programming exercises that appear near the end of Chapters 1 through 12. Appendix B introduces you to Java's Scripting API along with Java 7's support for dynamically typed languages. Appendix C introduces you to additional APIs and architecture topics. Examples include Accessibility, classloaders, Console, Drag and Drop, Java Native Interface, and System Tray. Appendix D presents a gallery of significant applications that demonstrate various aspects of Java. Unfortunately, there are limits to how much knowledge can be crammed into a print book. For this reason, Appendixes A, B, C, and D are not included in this book's pages. Instead, these appendixes are freely distributed as PDF files. Appendixes A and B are bundled with the book's associated code file at the Apress website (http://www.apress.com/9781430239093). Appendixes C and D are bundled with their respective code files at my TutorTutor.ca website (http://tutortutor.ca/cgi-bin/makepage.cgi?/books/bj7).
(source: Nielsen Book Data)

• A table of contents is not available for this title.
• (source: Nielsen Book Data)

Spring and OSGi's features are a natural fit; they are orthogonal to each other. The Open Services Gateway initiative (OSGi) is about packaging, deployment, and versioning issues, while Spring is about providing the necessary foundation to wire up Java classes in their most basic form using dependency injection and aspect orientation to fulfill an application's purpose. Pro Spring Dynamic Modules for OSGi (TM) Service Platforms by Daniel Rubio is the first book to cover OSGi as practically implemented by the world's most popular, agile, and open-source enterprise Java framework, Spring. Covers the ease at which OSGi is used with the Spring Framework in development, packaging, versioning, and deployment. Enterprises are trusting Spring more and more, and this book leverages OSGi in a way that can "complete" the use of Spring in the enterprise, as OSGi is already being trusted and adopted by IBM, BEA, and others. The text discusses how Spring OSGi makes your Spring applications trusted SOA applications.
(source: Nielsen Book Data)

• The Art of Building Modern Software The Motivation to Create an API Determining What Makes a Good API Ever-Changing Targets Do Not Expose More Than You Want Code Against Interfaces, Not Implementations Use Modular Architecture Separate APIs for Clients and Providers Keep Testability in Mind Cooperating with Other APIs Runtime Aspects of APIs Declarative Programming Extreme Advice Considered Harmful Paradoxes of API Design Evolving the API Universe Teamwork Using Games to Improve API Design Skills Extensible Visitor Pattern Case Study End-of-Life Procedures.
• (source: Nielsen Book Data)

You might think more than enough design books exist in the programming world already. In fact, there are so many that it makes sense to ask why you would read yet another. Is there really a need for yet another design book? In fact, there is a greater need than ever before, and Practical API Design: Confessions of a Java Framework Architect fills that need! Teaches you how to write an API that will stand the test of time Written by the designer of the NetBeans API at Sun Technologies Based on best practices, scalability, and API design patterns.
(source: Nielsen Book Data)

• A table of contents is not available for this title.
• (source: Nielsen Book Data)

This book covers the JavaOne award winning JasperReports tool at length. Written by JasperForge's Teodor Danciu, Founder and Architect JasperReport, this authoritative book: Shows the power that this open source Java reporting tool has and its ability to deliver rich content onto the screen, to the printer, or into PDF, HTML, XLS, CSV and XML files Demonstrates how JasperReports can be used in a variety of Java-enabled applications, including Java EE or web applications, to generate dynamic content Teaches you how to create page-oriented, ready-to-print documents in a simple and flexible manner.
(source: Nielsen Book Data)

• Chapter 1: Groovy
• Chapter 2: Numbers and Expressions
• Chapter 3: Strings and Regular Expressions
• Chapter 4: Lists, Maps, and Ranges
• Chapter 5: Simple Input and Output
• Chapter 6: Case study
• Chapter 7: Methods
• Chapter 8: Flow of Control
• Chapter 9: Closures
• Chapter 10: Files
• Chapter 11: Case study
• Chapter 12: Classes
• Chapter 13: Case study
• Chapter 14: Inheritance
• Chapter 15: Unit testing (junit)
• Chapter 16: Case study
• Chapter 17: Persistence
• Chapter 18: Case study
• Chapter 19: XML Builders and Parsers
• Chapter 20: GUI Builders
• Chapter 21: Template Engines
• Chapter 22: Case study
• Chapter 23: Server-side Programming
• Chapter 24: Case study
• Chapter 25: Epilogue Software Distribution Groovy More on Numbers and Expressions More on Strings and Regular Expressions More on Lists, Maps, and Ranges More on Simple Input and Output More on Methods More on Closures More on Classes Advanced Closures More on Builders More on GUI Builders Bibliography Index.
• (source: Nielsen Book Data)

Groovy Programming is an introduction to the Java-based scripting language Groovy. Groovy has much in common with popular scripting languages such as Perl, Python, and Ruby, but is written in a Java-like syntax. And, unlike these other languages, Groovy is sanctioned by the Java community for use on the Java platform. Since it is based on Java, applications written in Groovy can make full use of the Java Application Programmer Interfaces (APIs). This means Groovy can integrate seamlessly with applications written in Java, while avoiding the complexities of the full Java language. This bare-bones structure also means Groovy can be used as an introduction to Java and to programming in general. Its simpler constructions and modern origins make it ideal as a first language and for introducing principles such as object-oriented programming. This book introduces all the major aspects of Groovy development and emphasizes Groovy's potential as a learning tool. Case studies and exercises are included, along with numerous programming examples. The book begins assuming only a general familiarity with Java programming, and progresses to discuss advanced topics such as GUI builders, Groovlets, Unit Testing, and Groovy SQL.
(source: Nielsen Book Data)

• Chapter 1 provides an overview of Glassfish, including how to install it, configure it, and verify the installation. Chapter 2 covers how to develop server-side web applications using the Servlet API.
• Chapter 3 explains how to develop web applications using JavaServer Pages (JSPs), including how to develop and use JSP custom tags. Chapter 4 discusses how to develop Java EE applications that interact with a relational database system through the Java Persistence API (JPA) and through the Java Database Connectivity API (JDBC). Chapter 5 explains how to use the JSP Standard Tag Library (JSTL) when developing JavaServer Pages. Chapter 6 covers how to develop applications using the JavaServer Faces (JSF) component framework to build web applications. Chapter 7 explains how to develop messaging applications though the Java Messaging Service (JMS) API. Chapter 8 covers securing J2EE applications through the Java Authentication and Authorization Service (JAAS). Chapter 9 discusses how to develop Enterprise Java Beans that adhere to the EJB 3 specification. Chapter 10 explains how to develop and deploy web services that conform to the JAX-WS 2.1 specification. Chapter 11 covers frameworks that build on top of the Java EE 5 specification, including Seam, Facelets, and Ajax4Jsf. The appendices cover some of the advanced features of the GlassFish server.
• (source: Nielsen Book Data)

The book combines a clear factual information with easy-to-use step-by-step instructions. There are chapters with background information on the architecture and features of the BlackBerry Enterprise Server, and chapters with specific installation and configuration instructions. This combined approach gives you the knowledge to make the best implementation decisions for your environment. This book is written for IT professionals and network administrators who need to implement a BlackBerry Enterprise Server. The text assumes basic familiarity with Microsoft Windows Server administration, but provides detailed instructions for administrators with varying levels of experience.
(source: Nielsen Book Data)

• Acknowledgments. Introduction. PART I: THINKING LIKE A JAVA DEVELOOPER.
• Chapter 1. Key Java Language Features and Libraries.
• Chapter 2. Tools and techniques for Developing Java Solutions.
• Chapter 3. Exploiting Patterns in Java. PART II: A BRAOD UNDERSTANDING OF JAVA APIs, TOOLS, AND TECHNIQUES.
• Chapter 4. Developing Effective User Interfaces with JFC.
• Chapter 5. Persisting Your Application Using Files.
• Chapter 6. Persisting Your Application Using Databases.
• Chapter 7. Developing Web Applications Using the Model 1 Architecture.
• Chapter 8. Developing Web Applications Using the Model 2 Architecture.
• Chapter 9. Interacting with C / C++ Using Java Native Interface.
• Chapter 10. EJB 3 and the Java Persistence API.
• Chapter 11. Communicating Between Java Components and Components of Other Platforms.
• Chapter 12. Service Oriented Integration.
• Chapter 13. Java Security.
• Chapter 14. Packaging and Deploying Your Java Applications. Index.
• (source: Nielsen Book Data)

Working as an effective professional Java developer requires you to know Java APIs, tools, and techniques to solve a wide variety of Java problems. Building upon Ivor Horton's Beginning Java 2, this resource shows you how to use the core features of the latest JDK as well as powerful open source tools such as Ant, JUnit, and Hibernate. It will arm you with a well-rounded understanding of the professional Java development landscape. The expert author team begins by uncovering the sophisticated Java language features, the methodology for developing solutions, and steps for exploiting patterns. They then provide you with a collection of real-world examples that will become an essential part of your developer's toolkit. With this approach, you'll gain the skills to build advanced solutions by utilizing the more complex and nuanced parts of Java JDK 6. What you will learn from this book* How to use tools to make your work easier and more productive* Methods to develop effective user interfaces with Java Foundation Classes (JFC)* Steps to build web applications using the Model 1 and Model 2 architectures* Ways to interact with the databases and XML using JDBC and JAXB* Techniques for developing enterprise applications using EJB 3.0 and web services* How to package and deploy Java applications Who this book is for This book is for Java developers who are looking for an all-purpose resource, are ready for more advanced Java solutions and language features, and need assistance when tackling new Java problems that may be outside their technological experience. Wrox Professional guides are planned and written by working programmers to meet the real-world needs of programmers, developers, and IT professionals. Focused and relevant, they address the issues technology professionals face every day. They provide examples, practical solutions, and expert education in new technologies, all designed to help programmers do a better job.
(source: Nielsen Book Data)

• Preface 1 Introduction 13 Prerequisites 14 Learning Java 14 Goals 15 Teaching from this book 16 JDK HTML documentation 17 Exercises 17 Foundations for Java 18 Source code 18 Errors 21 Introduction to Objects 23 The progress of abstraction 24 An object has an interface 26 An object provides services 29 The hidden implementation 30 Reusing the implementation 32 Inheritance 33 Interchangeable objects with polymorphism 38 The singly rooted hierarchy 43 Containers 44 Object creation & lifetime 46 Exception handling: dealing with errors 49 Concurrent programming 50 Java and the Internet 51 Summary 60 Everything Is an Object 61 You manipulate objects with references 61 You must create all the objects 63 You never need to destroy an object 67 Creating new data types: class 69 Methods, arguments, and return values 72 Building a Java program 74 Your first Java program 78 Comments and embedded documentation 81 Coding style 88 Summary 89 Exercises 89 Operators 93 Simpler print statements 93 Using Java operators 94 Precedence 95 Assignment 95 Mathematical operators 98 Auto increment and decrement 101 Relational operators 103 Logical operators 105 Literals 108 Bitwise operators 111 Shift operators 112 Ternary if-else operator 116 String operator + and += 118 Common pitfalls when using operators 119 Casting operators 120 Java has no "sizeof" 122 A compendium of operators 123 Summary 133 Controlling Execution 135 true and false 135 if-else 135 Iteration 137 Foreach syntax 140 return 143 break and continue 144 The infamous "goto" 146 switch 151 Summary 154 Initialization & Cleanup 155 Guaranteed initialization with the constructor 155 Method overloading 158 Default constructors 166 The this keyword 167 Cleanup: finalization and garbage collection 173 Member initialization 181 Constructor initialization 185 Array initialization 193 Enumerated types 204 Summary 207 Access Control 209 package: the library unit 210 Java access specifiers 221 Interface and implementation 228 Class access 229 Summary 233 Reusing Classes 237 Composition syntax 237 Inheritance syntax 241 Delegation 246 Combining composition and inheritance 249 Choosing composition vs. inheritance 256 protected 258 Upcasting 260 The final keyword 262 Initialization and class loading 272 Summary 274 Polymorphism 277 Upcasting revisited 278 The twist 281 Constructors and polymorphism 293 Covariant return types 303 Designing with inheritance 304 Summary 310 Interfaces 311 Abstract classes and methods 311 Interfaces 316 Complete decoupling 320 "Multiple in heritance" in Java 326 Extending an interface with inheritance 329 Adapting to an interface 331 Fields in interfaces 335 Nesting interfaces 336 Interfaces and factories 339 Summary 343 Inner Classes 345 Creating inner classes 345 The link to the outer class 347 Using .this and .new 350 Inner classes and upcasting 352 Inner classes in methods and scopes 354 Anonymous inner classes 356 Nested classes 364 Why inner classes? 369 Inheriting from inner classes 382 Can inner classes be overridden? 383 Local inner classes 385 Inner-class identifiers 387 Summary 388 Holding Your Objects 389 Generics and type-safe containers 390 Basic concepts 394 Adding groups of elements 396 Printing containers 398 List 401 Iterator 406 LinkedList 410 Stack 412 Set 415 Map 419 Queue 423 Collection vs. Iterator 427 Foreach and iterators 431 Summary 437 Error Handling with Exceptions 443 Concepts 444 Basic exceptions 445 Catching an exception 447 Creating your own exceptions 449 The exception specification 457 Catching any exception 458 Standard Java exceptions 468 Performing cleanup with finally 471 Exception restrictions 479 Constructors 483 Exception matching 489 Alternative approaches 490 Exception guidelines 500 Summary 501 Strings 503 Immutable Strings 503 Overloading &8216--+' vs. StringBuilder 504 Unintended recursion 509 Operations on Strings 511 Formatting output 514 Regular expressions 523 Scanning input 546 StringTokenizer 551 Summary 552 Type Information 553 The need for RTTI 553 The Class object 556 Checking before a cast 569 Registered factories 582 instanceof vs. Class equivalence 586 Reflection: runtime class information 588 Dynamic proxies 593 Null Objects 598 Interfaces and type information 607 Summary 613 Generics 617 Comparison with C++ 618 Simple generics 619 Generic interfaces 627 Generic methods 631 Anonymous inner classes 645 Building complex models 647 The mystery of erasure 650 Compensating for erasure 662 Bounds 673 Wildcards 677 Issues 694 Self-bounded types 701 Dynamic type safety 710 Exceptions 711 Mixins 713 Latent typing 721 Compensating for the lack of latent typing 726 Using function objects as strategies 737 Summary: Is casting really so bad? 743 Arrays 747 Why arrays are special 747 Arrays are first-class objects 749 Returning an array 753 Multidimensional arrays 754 Arrays and generics 759 Creating test data 762 Arrays utilities 775 Summary 786 Containers in Depth 791 Full container taxonomy 791 Filling containers 793 Collection functionality 809 Optional operations 813 List functionality 817 Sets and storage order 821 Queues 827 Understanding Maps 831 Hashing and hash codes 839 Choosing an implementation 858 Utilities 879 Holding references 889 Java 1.0/1.1 containers 893 Summary 900 I/O 901 The File class 901 Input and output 914 Adding attributes and useful interfaces 918 Readers & Writers 922 Off by itself: RandomAccessFile 926 Typical uses of I/O streams 927 File reading & writing utilities 936 Standard I/O 941 Process control 944 New I/O 946 Compression 973 Object serialization 980 XML 1003 Preferences 1006 Summary 1008 Enumerated Types 1011 Basic enum features 1011 Adding methods to an enum 1014 enums in switch statements 1016 The mystery of values() 1017 Implements, not inherits 1020 Random selection 1021 Using interfaces for organization 1022 Using EnumSet instead of flags 1028 Using EnumMap 1030 Constant-specific methods 1032 Multiple dispatching 1047 Summary 1057 Annotations 1059 Basic syntax 1060 Writing annotation processors 1064 Using apt to process annotations 1074 Using the Visitor pattern with apt 1079 Annotation-based unit testing 1083 Summary 1106 Concurrency 1109 The many faces of concurrency 1111 Basic threading 1116 Sharing resources 1150 Terminating tasks 1179 Cooperation between tasks 1197 Deadlock 1223 New Library components 1229 Simulation 1253 Performance tuning 1270 Active objects 1295 Summary 1300 Graphical User Interfaces 1303 Applets 1306 Swing basics 1307 Making a button 1311 Capturing an event 1312 Text areas 1315 Controlling layout 1317 The Swing event model 1321 A selection of Swing components 1332 JNLP and Java Web Start 1376 Concurrency & Swing 1382 Visual programming and JavaBeans 1393 Alternatives to Swing 1415 Building Flash Web clients with Flex 1416 Creating SWT applications 1430 Summary 1447 A: Supplements 1449 Downloadable supplements 1449 Thinking in C: Foundations for Java 1449 Thinking in Java seminar 1450 Hands-On Java seminar-on-CD 1450 Thinking in Objects seminar 1450 Thinking in Enterprise Java 1451 Thinking in Patterns (with Java) 1452 Thinking in Patterns seminar 1452 Design consulting and reviews 1453 B: Resources 1455 Software 1455 Editors & IDEs 1455 Books 1456 Index 1463.
• (source: Nielsen Book Data)

"Thinking in Java should be read cover to cover by every Java programmer, then kept close at hand for frequent reference. The exercises are challenging, and the chapter on Collections is superb! Not only did this book help me to pass the Sun Certified Java Programmer exam; it's also the first book I turn to whenever I have a Java question." --Jim Pleger, Loudoun County (Virginia) Government"Much better than any other Java book I've seen. Make that 'by an order of magnitude'...Very complete, with excellent right-to-the-point examples and intelligent, not dumbed-down, explanations...In contrast to many other Java books I found it to be unusually mature, consistent, intellectually honest, well-written, and precise. IMHO, an ideal book for studying Java." --Anatoly Vorobey, Technion University, Haifa, Israel"Absolutely one of the best programming tutorials I've seen for any language." --Joakim Ziegler, FIX sysop"Thank you again for your awesome book. I was really floundering (being a non-C programmer), but your book has brought me up to speed as fast as I could read it. It's really cool to be able to understand the underlying principles and concepts from the start, rather than having to try to build that conceptual model through trial and error. Hopefully I will be able to attend your seminar in the not-too-distant future." --Randall R. Hawley, automation technician, Eli Lilly & Co."This is one of the best books I've read about a programming language...The best book ever written on Java." --Ravindra Pai, Oracle Corporation, SUNOS product line"Bruce, your book is wonderful! Your explanations are clear and direct. Through your fantastic book I have gained a tremendous amount of Java knowledge. The exercises are also fantastic and do an excellent job reinforcing the ideas explained throughout the chapters. I look forward to reading more books written by you. Thank you for the tremendous service that you are providing by writing such great books. My code will be much better after reading Thinking in Java. I thank you and I'm sure any programmers who will have to maintain my code are also grateful to you." --Yvonne Watkins, Java artisan, Discover Technologies, Inc." Other books cover the what of Java (describing the syntax and the libraries) or the how of Java (practical programming examples). Thinking in Java is the only book I know that explains the why of Java: Why it was designed the way it was, why it works the way it does, why it sometimes doesn't work, why it's better than C++, why it's not. Although it also does a good job of teaching the what and how of the language, Thinking in Java is definitely the thinking person's choice in a Java book." --Robert S. StephensonAwards for Thinking in Java2003 Software Development Magazine Jolt Award for Best Book 2003 Java Developer's Journal Reader's Choice Award for Best Book 2001 JavaWorld Editor's Choice Award for Best Book 2000 JavaWorld Reader's Choice Award for Best Book 1999 Software Development Magazine Productivity Award 1998 Java Developer's Journal Editor's Choice Award for Best Book Thinking in Java has earned raves from programmers worldwide for its extraordinary clarity, careful organization, and small, direct programming examples. From the fundamentals of Java syntax to its most advanced features, Thinking in Java is designed to teach, one simple step at a time. *The classic object-oriented introduction for beginners and experts alike, fully updated for Java SE5/6 with many new examples and chapters! *Test framework shows program output. *Design patterns are shown with multiple examples throughout: Adapter, Bridge, Chain of Responsibility, Command, Decorator, Facade, Factory Method, Flyweight, Iterator, Data Transfer Object, Null Object, Proxy, Singleton, State, Strategy, Template Method, and Visitor. *Introduction to XML for data transfer; SWT, Flash for user interfaces. *Completely rewritten concurrency chapter gives you a solid grasp of threading fundamentals. *500+ working Java programs in 700+ compiling files, rewritten for this edition and Java SE5/6. *Companion web site includes all source code, annotated solution guide, weblog, and multimedia seminars. *Thorough coverage of fundamentals; demonstrates advanced topics. *Explains sound object-oriented principles. *Hands-On Java Seminar CD available online, with full multimedia seminar by Bruce Eckel. *Live seminars, consulting, and reviews available. See www.MindView.net Download seven free sample chapters from Thinking in Java, Fourth Edition. Visit http://mindview.net/Books/TIJ4.
(source: Nielsen Book Data)

• List of Code Example. Preface. Acknowledgments. 1. Multithreading.
• What Are Threads?
• Interrupting Threads.
• Thread States.
• Thread Properties.
• Synchronization.
• Blocking Queues.
• Thread-Safe Collections.
• Callables and Futures.
• Executors.
• Synchronizers.
• Threads and Swing. 2. Collections.
• Collection Interfaces.
• Concrete Collections.
• The Collections Framework.
• Algorithms.
• Legacy Collections. 3. Networking.
• Connecting to a Server.
• Implementing Servers.
• Sending E-Mail.
• Making URL Connections.
• Advanced Socket Programming. 4. Database Programming.
• The Design of JDBC.
• The Structured Query Language.
• JDBC Installation.
• Basic JDBC Programming Concepts.
• Query Execution.
• Scrollable and Updatable Result Sets.
• Metadata.
• Row Sets.
• Transactions.
• Advanced Connection Management.
• Introduction to LDAP. 5. Distributed Objects.
• The Roles of Client and Server.
• Remote Method Invocations.
• Setup for Remote Method Invocation.
• Parameter Passing in Remote Methods.
• Server Object Activation.
• Java IDL and CORBA.
• Remote Method Calls with SOAP. 6. Advanced Swing.
• Lists.
• Trees.
• Tables.
• Styled Text Components.
• Progress Indicators.
• Component Organizers. 7. Advanced AWT.
• The Rendering Pipeline.
• Shapes.
• Areas.
• Strokes.
• Paint.
• Coordinate Transformations.
• Clipping.
• Transparency and Composition.
• Rendering Hints.
• Readers and Writers for Images.
• Image Manipulation.
• Printing.
• The Clipboard.
• Drag and Drop. 8. JavaBeans Components.
• Why Beans?
• The Bean-Writing Process.
• Using Beans to Build an Application.
• Naming Patterns for Bean Properties and Events.
• Bean Property Types.
• BeanInfo Classes.
• Property Editors.
• Customizers.
• JavaBeans Persistence. 9. Security.
• Class Loaders.
• Bytecode Verification.
• Security Managers and Permissions.
• Digital Signatures.
• Code Signing.
• Encryption. 10. Internationalization.
• Locales.
• Number Formats.
• Date and Time.
• Collation.
• Message Formatting.
• Text Files and Character Sets.
• Resource Bundles.
• A Complete Example. 11. Native Methods.
• Calling a C Function from the Java Programming Language.
• Numeric Parameters and Return Values.
• String Parameters.
• Accessing Fields.
• Encoding Signatures.
• Calling Java Methods.
• Accessing Array Elements.
• Handling Errors.
• Using the Invocation API.
• A Complete Example: Accessing the Windows Registry. 12. XML.
• Introducing XML.
• Parsing an XML Document.
• Validating XML Documents.
• Locating Information with XPath.
• Using Namespaces.
• Using the SAX Parser.
• Generating XML Documents.
• XSL Transformations. 13. Annotations.
• Addition of Metadata to Programs.
• An Example: Annotating Event Handlers.
• Annotation Syntax.
• Standard Annotations.
• The apt Tool for Source-Level Annotation Processing.
• Bytecode Engineering. Index.
• (source: Nielsen Book Data)

A new edition of this title is available, ISBN-10: 0132354799 ISBN-13: 9780132354790 Completely revised and up-to-date coverage of Multithreading-including the java.util.concurrent library, locks, condition objects, futures, thread pools, thread-safe collections, threads and Swing Collection classes-collections framework, concrete collections, and generic utility methods Annotations and metadata-using annotations to automate programming tasks, JDK (TM) 5.0 standard annotations, the apt tool for source-level annotation processing, and bytecode engineering Advanced Swing and AWT-lists, trees, tables, and other advanced components; image processing and printing JavaBeans (TM)-including property editors, customizers, and long-term persistence XML-DOM and SAX parsers, XPath, and XSL transformations The seventh edition of Core Java (TM) 2, Volume II, covers advanced user-interface programming and the enterprise features of the Java 2 Platform, Standard Edition (J2SE (TM)). Like Volume I (which covers the most important language and library features), this book has been completely updated and revised for J2SE 5.0. All of the sample programs have been updated and carefully crafted to illustrate practical solutions to the type of real-world problems professional developers encounter. Volume II includes new sections on annotations and other J2SE 5.0 enhancements, along with complete coverage of Multithreading Distributed objects Databases JNDI and LDAP Advanced GUI components Native methods XML processing Network programming Collection classes Advanced graphics Internationalization JavaBeans Annotations .
(source: Nielsen Book Data)

• Intro
• 1 Breaking the Surface: a quick dip
• 2 A Trip to Objectville: yes, there will be objects
• 3 Know Your Variables: primitives and references
• 4 How Objects Behave: object state affects method behavior
• 5 Extra-Strength Methods: flow control, operations, and more
• 6 Using the Java Library: so you don?t have to write it all yourself
• 7 Better Living in Objectville: planning for the future
• 8 Serious Polymorphism: exploiting abstract classes and interfaces
• 9 Life and Death of an Object: constructors and memory management
• 10 Numbers Matter: math, formatting, wrappers, and statics
• 11 Risky Behavior: exception handling
• 12 A Very Graphic Story: intro to GUI, event handling, and inner classes
• 13 Work on Your Swing: layout managers and components
• 14 Saving Objects: serialization and I/O
• 15 Make a Connection: networking sockets and multithreading
• 16 Data Structures: collections and generics 17 Release Your Code: packaging and deployment
• 18 Distributed Computing: RMI with a dash of servlets, EJB, and Jini
• A Appendix A: Final code kitchen
• B Appendix B: Top Ten Things that didn?t make it into the rest of the book
• Index.
• (source: Nielsen Book Data)

Learning a complex new language is no easy task especially when it s an object-oriented computer programming language like Java. You might think the problem is your brain. It seems to have a mind of its own, a mind that doesn't always want to take in the dry, technical stuff you're forced to study. The fact is your brain craves novelty. It's constantly searching, scanning, waiting for something unusual to happen. After all, that's the way it was built to help you stay alive. It takes all the routine, ordinary, dull stuff and filters it to the background so it won't interfere with your brain's real work--recording things that matter. How does your brain know what matters? It's like the creators of the Head First approach say, suppose you're out for a hike and a tiger jumps in front of you, what happens in your brain? Neurons fire. Emotions crank up. Chemicals surge. That's how your brain knows. And that's how your brain will learn Java. Head First Java combines puzzles, strong visuals, mysteries, and soul-searching interviews with famous Java objects to engage you in many different ways. It's fast, it's fun, and its effective. And, despite its playful appearance, Head First Java is serious stuff: a complete introduction to object-oriented programming and Java. You'll learn everything from the fundamentals to advanced topics, including threads, network sockets, and distributed programming with RMI. And the new. second edition focuses on Java 5.0, the latest version of the Java language and development platform. Because Java 5.0 is a major update to the platform, with deep, code-level changes, even more careful study and implementation is required. So learning the Head First way is more important than ever. If you've read a Head First book, you know what to expect--a visually rich format designed for the way your brain works. If you haven't, you're in for a treat. You'll see why people say it's unlike any other Java book you've ever read. By exploiting how your brain works, Head First Java compresses the time it takes to learn and retain--complex information. Its unique approach not only shows you what you need to know about Java syntax, it teaches you to think like a Java programmer. If you want to be bored, buy some other book. But if you want to understand Java, this book's for you.
(source: Nielsen Book Data)