On Java 8 Год издания: 2017 Автор: Bruce Eckel Жанр или тематика: Программирование Издательство: MindView LLC. ISBN: 978-0-9818725-2-0 Язык: Английский Формат: PDF|EPUB Качество: PDF: Конвертированные страницы, EPUB: Издательский макет или текст (eBook) Интерактивное оглавление: Да Количество страниц: 2255 PDF | 1042 EPUB Описание: "This book teaches the most modern form of Java programming using the features in the 8th version of that language. My previous Java book, Thinking in Java, 4th Edition (Prentice Hall 2006), is still useful for programming in Java 5, the version of the language used for Android programming. But especially with the advent of Java 8, the language has changed significantly enough that new Java code feels and reads differently. his justified the two-year effort of creating a new book. On Java 8 is designed for someone with a basic foundation in programming. For beginners, web sites like Code.org and Khan Academy can provide at least some of that background, along with the Thinking in C seminar freely available at the OnJava8 Site."
Document Outline On Java 8 Preface Goals Language Design Errors Tested Examples Popularity Android Programmers This is Only an eBook Colophon Thanks Dedication Introduction Prerequisites JDK HTML Documentation Thinking in C Source Code Coding Standards Bug Reports Mailing List What About User Interfaces? What is an Object? The Progress of Abstraction An Object Has an Interface Objects Provide Services The Hidden Implementation Reusing the Implementation Inheritance Interchangeable Objects with Polymorphism The Singly-Rooted Hierarchy Collections Object Creation & Lifetime Exception Handling: Dealing with Errors Summary Installing Java and the Book Examples Editors The Shell Installing Java Verify Your Installation Installing and Running the Book Examples Objects Everywhere You Manipulate Objects with References You Must Create All the Objects Comments You Never Need to Destroy an Object Creating New Data Types: class Methods, Arguments, and Return Values Writing a Java Program Your First Java Program Coding Style Summary Operators Using Java Operators Precedence Assignment Mathematical Operators Auto Increment and Decrement Relational Operators Logical Operators Literals Bitwise Operators Shift Operators Ternary if-else Operator String Operator + and += Common Pitfalls When Using Operators Casting Operators Java Has No sizeof A Compendium of Operators Summary Control Flow true and false if-else Iteration Statements For-in Syntax return break and continue The Infamous Goto switch Switching on Strings Summary Housekeeping Guaranteed Initialization with the Constructor Method Overloading No-arg Constructors The this Keyword Cleanup: Finalization and Garbage Collection Member Initialization Constructor Initialization Array Initialization Enumerated Types Summary Implementation Hiding package: the Library Unit Java Access Specifiers Interface and Implementation Class Access Summary Reuse Composition Syntax Inheritance Syntax Delegation Combining Composition and Inheritance Choosing Composition vs. Inheritance protected Upcasting The final Keyword Initialization and Class Loading Summary Polymorphism Upcasting Revisited The Twist Constructors and Polymorphism Covariant Return Types Designing with Inheritance Summary Interfaces Abstract Classes and Methods Interfaces Abstract Classes vs. Interfaces Complete Decoupling Combining Multiple Interfaces Extending an Interface with Inheritance Adapting to an Interface Fields in Interfaces Nesting Interfaces Interfaces and Factories Summary Inner Classes Creating Inner Classes The Link to the Outer Class Using .this and .new Inner Classes and Upcasting Inner Classes in Methods and Scopes Anonymous Inner Classes Nested Classes Why Inner Classes? Inheriting from Inner Classes Can Inner Classes Be Overridden? Local Inner Classes Inner-Class Identifiers Summary Collections Generics and Type-Safe Collections Basic Concepts Adding Groups of Elements Printing Collections List Iterators LinkedList Stack Set Map Queue Collection vs. Iterator for-in and Iterators Summary Functional Programming Old vs. New Lambda Expressions Method References Functional Interfaces Higher-Order Functions Closures Function Composition Currying and Partial Evaluation Pure Functional Programming Summary Streams Java 8 Stream Support Stream Creation Intermediate Operations Optional Terminal Operations Summary Exceptions Concepts Basic Exceptions Catching an Exception Creating Your Own Exceptions The Exception Specification Catching Any Exception Standard Java Exceptions Performing Cleanup with finally Exception Restrictions Constructors Try-With-Resources Exception Matching Alternative Approaches Exception Guidelines Summary Validating Your Code Testing Preconditions Test-Driven Development Logging Debugging Benchmarking Profiling and Optimizing Style Checking Static Error Analysis Code Reviews Pair Programming Refactoring Continuous Integration Summary Files File and Directory Paths Directories File Systems Watching a Path Finding Files Reading & Writing Files Summary Strings Immutable Strings Overloading + vs. StringBuilder Unintended Recursion Operations on Strings Formatting Output Regular Expressions Scanning Input StringTokenizer Summary Type Information The Need for RTTI The Class Object Checking Before a Cast Registered Factories Instanceof vs. Class Equivalence Reflection: Runtime Class Information Dynamic Proxies Using Optional Interfaces and Type Information Summary Generics Simple Generics Generic Interfaces Generic Methods Building Complex Models The Mystery of Erasure Compensating for Erasure Bounds Wildcards Issues Self-Bounded Types Dynamic Type Safety Exceptions Mixins Latent Typing Compensating for the Lack of (Direct) Latent Typing Assisted Latent Typing in Java 8 Summary: Is Casting Really So Bad? Arrays Why Arrays are Special Arrays are First-Class Objects Returning an Array Multidimensional Arrays Arrays and Generics Arrays.fill() Arrays.setAll() Incremental Generators Random Generators Generics and Primitive Arrays Modifying Existing Array Elements An Aside On Parallelism Arrays Utilities Copying an Array Comparing Arrays Streams and Arrays Sorting Arrays Searching with Arrays.binarySearch() Accumulating with parallelPrefix() Summary Enumerations Basic enum Features Adding Methods to an enum enums in switch Statements The Mystery of values() Implements, not Inherits Random Selection Using Interfaces for Organization Using EnumSet Instead of Flags Using EnumMap Constant-Specific Methods Multiple Dispatching Summary Annotations Basic Syntax Writing Annotation Processors Using javac to Process Annotations Annotation-Based Unit Testing Summary Concurrent Programming The Terminology Problem Concurrency Superpowers Concurrency is for Speed The Four Maxims of Java Concurrency The Brutal Truth The Rest of the Chapter Parallel Streams Creating and Running Tasks Terminating Long-Running Tasks CompletableFutures Deadlock Constructors are not Thread-Safe Effort, Complexity, Cost Summary Patterns The Pattern Concept Building Application Frameworks Fronting for an Implementation Factories: Encapsulating Object Creation Function Objects Changing the Interface Interpreter: Run-Time Flexibility Callbacks Multiple Dispatching Pattern Refactoring Abstracting Usage Multiple Dispatching The Visitor Pattern RTTI Considered Harmful? Summary Appendix: Supplements Downloadable Supplements Thinking in C: Foundations for Java Hands-On Java eSeminar Appendix: Programming Guidelines Design Implementation Appendix: Javadoc Appendix: Passing and Returning Objects Passing References Making Local Copies Controlling Cloneability Immutable Classes Summary Appendix: I/O Streams Types of InputStream Types of OutputStream Adding Attributes and Useful Interfaces Readers & Writers Off By Itself: RandomAccessFile Typical Uses of I/O Streams Summary Appendix: Standard I/O Process Control Appendix: New I/O ByteBuffers Converting Data Fetching Primitives View Buffers Data Manipulation with Buffers Memory-Mapped Files File Locking Appendix: Understanding equals() and hashCode() A Canonical equals() Hashing and Hash Codes Tuning a HashMap Appendix: Collection Topics Sample Data List Behavior Set Behavior Using Functional Operations with any Map Selecting Parts of a Map Filling Collections Custom Collection and Map using Flyweight Collection Functionality Optional Operations Sets and Storage Order Queues Understanding Maps Utilities Holding References Java 1.0/1.1 Collections Summary Appendix: Low-Level Concurrency What is a Thread? Catching Exceptions Sharing Resources The volatile Keyword Atomicity Critical Sections Library Components Summary Appendix: Data Compression Simple Compression with GZIP Multifile Storage with Zip Java Archives (Jars) Appendix: Object Serialization Finding the Class Controlling Serialization Using Persistence Appendix: Benefits and Costs of Static Type Checking Foreword Static Type Checking vs. Testing How to Argue about Typing The Cost of Productivity Static vs. Dynamic Appendix: The Positive Legacy of C++ and Java Appendix: Becoming a Programmer How I Got Started in Programming A Career in Computing The Mythical 5% Writing Software Is Like … Writing Programming as Typing Do What You Love
You cannot post new topics in this forum You cannot reply to topics in this forum You cannot edit your posts in this forum You cannot delete your posts in this forum You cannot vote in polls in this forum You cannot attach files in this forum You can download files in this forum