Java
The Definitive Java Programming Guide Fully updated for Java SE 17, Java(tm): The Complete Reference, Twelfth Edition explains how to develop, compile, debug, and run Java programs.Best-selling programming author Herb Schildt covers the entire Java language, including its syntax, keywords, and funda...
Uloženo v:
| Hlavní autor: | |
|---|---|
| Médium: | E-kniha |
| Jazyk: | angličtina |
| Vydáno: |
New York
McGraw-Hill Education
2021
|
| Vydání: | 12 |
| Témata: | |
| ISBN: | 1260463419, 9781260463415 |
| On-line přístup: | Získat plný text |
| Tagy: |
Přidat tag
Žádné tagy, Buďte první, kdo vytvoří štítek k tomuto záznamu!
|
Obsah:
- Exporting to a Specific Module
- Using Command-Line Arguments -- Varargs: Variable-Length Arguments -- Overloading Vararg Methods -- Varargs and Ambiguity -- Local Variable Type Inference with Reference Types -- Chapter 8 Inheritance -- Inheritance Basics -- Member Access and Inheritance -- A More Practical Example -- A Superclass Variable Can Reference a Subclass Object -- Using super -- Using super to Call Superclass Constructors -- A Second Use for super -- Creating a Multilevel Hierarchy -- When Constructors Are Executed -- Method Overriding -- Dynamic Method Dispatch -- Why Overridden Methods? -- Applying Method Overriding -- Using Abstract Classes -- Using final with Inheritance -- Using final to Prevent Overriding -- Using final to Prevent Inheritance -- Local Variable Type Inference and Inheritance -- The Object Class -- Chapter 9 Packages and Interfaces -- Packages -- Defining a Package -- Finding Packages and CLASSPATH -- A Short Package Example -- Packages and Member Access -- An Access Example -- Importing Packages -- Interfaces -- Defining an Interface -- Implementing Interfaces -- Nested Interfaces -- Applying Interfaces -- Variables in Interfaces -- Interfaces Can Be Extended -- Default Interface Methods -- Default Method Fundamentals -- A More Practical Example -- Multiple Inheritance Issues -- Use static Methods in an Interface -- Private Interface Methods -- Final Thoughts on Packages and Interfaces -- Chapter 10 Exception Handling -- Exception-Handling Fundamentals -- Exception Types -- Uncaught Exceptions -- Using try and catch -- Displaying a Description of an Exception -- Multiple catch Clauses -- Nested try Statements -- throw -- throws -- finally -- Java's Built-in Exceptions -- Creating Your Own Exception Subclasses -- Chained Exceptions -- Three Additional Exception Features -- Using Exceptions -- Chapter 11 Multithreaded Programming
- The Java Thread Model -- Thread Priorities -- Synchronization -- Messaging -- The Thread Class and the Runnable Interface -- The Main Thread -- Creating a Thread -- Implementing Runnable -- Extending Thread -- Choosing an Approach -- Creating Multiple Threads -- Using isAlive( ) and join( ) -- Thread Priorities -- Synchronization -- Using Synchronized Methods -- The synchronized Statement -- Interthread Communication -- Deadlock -- Suspending, Resuming, and Stopping Threads -- Obtaining a Thread's State -- Using a Factory Method to Create and Start a Thread -- Using Multithreading -- Chapter 12 Enumerations, Autoboxing, and Annotations -- Enumerations -- Enumeration Fundamentals -- The values( ) and valueOf( ) Methods -- Java Enumerations Are Class Types -- Enumerations Inherit Enum -- Another Enumeration Example -- Type Wrappers -- Character -- Boolean -- The Numeric Type Wrappers -- Autoboxing -- Autoboxing and Methods -- Autoboxing/Unboxing Occurs in Expressions -- Autoboxing/Unboxing Boolean and Character Values -- Autoboxing/Unboxing Helps Prevent Errors -- A Word of Warning -- Annotations -- Annotation Basics -- Specifying a Retention Policy -- Obtaining Annotations at Run Time by Use of Reflection -- The AnnotatedElement Interface -- Using Default Values -- Marker Annotations -- Single-Member Annotations -- The Built-In Annotations -- Type Annotations -- Repeating Annotations -- Some Restrictions -- Chapter 13 I/O, Try-with-Resources, and Other Topics -- I/O Basics -- Streams -- Byte Streams and Character Streams -- The Predefined Streams -- Reading Console Input -- Reading Characters -- Reading Strings -- Writing Console Output -- The PrintWriter Class -- Reading and Writing Files -- Automatically Closing a File -- The transient and volatile Modifiers -- Introducing instanceof -- strictfp -- Native Methods -- Using assert
- Assertion Enabling and Disabling Options -- Static Import -- Invoking Overloaded Constructors Through this( ) -- A Word About Value-Based Classes -- Chapter 14 Generics -- What Are Generics? -- A Simple Generics Example -- Generics Work Only with Reference Types -- Generic Types Differ Based on Their Type Arguments -- How Generics Improve Type Safety -- A Generic Class with Two Type Parameters -- The General Form of a Generic Class -- Bounded Types -- Using Wildcard Arguments -- Bounded Wildcards -- Creating a Generic Method -- Generic Constructors -- Generic Interfaces -- Raw Types and Legacy Code -- Generic Class Hierarchies -- Using a Generic Superclass -- A Generic Subclass -- Run-Time Type Comparisons Within a Generic Hierarchy -- Casting -- Overriding Methods in a Generic Class -- Type Inference with Generics -- Local Variable Type Inference and Generics -- Erasure -- Bridge Methods -- Ambiguity Errors -- Some Generic Restrictions -- Type Parameters Can't Be Instantiated -- Restrictions on Static Members -- Generic Array Restrictions -- Generic Exception Restriction -- Chapter 15 Lambda Expressions -- Introducing Lambda Expressions -- Lambda Expression Fundamentals -- Functional Interfaces -- Some Lambda Expression Examples -- Block Lambda Expressions -- Generic Functional Interfaces -- Passing Lambda Expressions as Arguments -- Lambda Expressions and Exceptions -- Lambda Expressions and Variable Capture -- Method References -- Method References to static Methods -- Method References to Instance Methods -- Method References with Generics -- Constructor References -- Predefined Functional Interfaces -- Chapter 16 Modules -- Module Basics -- A Simple Module Example -- Compile and Run the First Module Example -- A Closer Look at requires and exports -- java.base and the Platform Modules -- Legacy Code and the Unnamed Module
- The Type Promotion Rules -- Arrays -- One-Dimensional Arrays -- Multidimensional Arrays -- Alternative Array Declaration Syntax -- Introducing Type Inference with Local Variables -- Some var Restrictions -- A Few Words About Strings -- Chapter 4 Operators -- Arithmetic Operators -- The Basic Arithmetic Operators -- The Modulus Operator -- Arithmetic Compound Assignment Operators -- Increment and Decrement -- The Bitwise Operators -- The Bitwise Logical Operators -- The Left Shift -- The Right Shift -- The Unsigned Right Shift -- Bitwise Operator Compound Assignments -- Relational Operators -- Boolean Logical Operators -- Short-Circuit Logical Operators -- The Assignment Operator -- The ? Operator -- Operator Precedence -- Using Parentheses -- Chapter 5 Control Statements -- Java's Selection Statements -- if -- The Traditional switch -- Iteration Statements -- while -- do-while -- for -- The For-Each Version of the for Loop -- Local Variable Type Inference in a for Loop -- Nested Loops -- Jump Statements -- Using break -- Using continue -- return -- Chapter 6 Introducing Classes -- Class Fundamentals -- The General Form of a Class -- A Simple Class -- Declaring Objects -- A Closer Look at new -- Assigning Object Reference Variables -- Introducing Methods -- Adding a Method to the Box Class -- Returning a Value -- Adding a Method That Takes Parameters -- Constructors -- Parameterized Constructors -- The this Keyword -- Instance Variable Hiding -- Garbage Collection -- A Stack Class -- Chapter 7 A Closer Look at Methods and Classes -- Overloading Methods -- Overloading Constructors -- Using Objects as Parameters -- A Closer Look at Argument Passing -- Returning Objects -- Recursion -- Introducing Access Control -- Understanding static -- Introducing final -- Arrays Revisited -- Introducing Nested and Inner Classes -- Exploring the String Class
- Cover -- About the Author -- Title Page -- Copyright Page -- Contents at a Glance -- Contents -- Preface -- For Further Study -- Part I The Java Language -- Chapter 1 The History and Evolution of Java -- Java's Lineage -- The Birth of Modern Programming: C -- C++: The Next Step -- The Stage Is Set for Java -- The Creation of Java -- The C# Connection -- How Java Impacted the Internet -- Java Applets -- Security -- Portability -- Java's Magic: The Bytecode -- Moving Beyond Applets -- A Faster Release Schedule -- Servlets: Java on the Server Side -- The Java Buzzwords -- Simple -- Object-Oriented -- Robust -- Multithreaded -- Architecture-Neutral -- Interpreted and High Performance -- Distributed -- Dynamic -- The Evolution of Java -- A Culture of Innovation -- Chapter 2 An Overview of Java -- Object-Oriented Programming -- Two Paradigms -- Abstraction -- The Three OOP Principles -- A First Simple Program -- Entering the Program -- Compiling the Program -- A Closer Look at the First Sample Program -- A Second Short Program -- Two Control Statements -- The if Statement -- The for Loop -- Using Blocks of Code -- Lexical Issues -- Whitespace -- Identifiers -- Literals -- Comments -- Separators -- The Java Keywords -- The Java Class Libraries -- Chapter 3 Data Types, Variables, and Arrays -- Java Is a Strongly Typed Language -- The Primitive Types -- Integers -- byte -- short -- int -- long -- Floating-Point Types -- float -- double -- Characters -- Booleans -- A Closer Look at Literals -- Integer Literals -- Floating-Point Literals -- Boolean Literals -- Character Literals -- String Literals -- Variables -- Declaring a Variable -- Dynamic Initialization -- The Scope and Lifetime of Variables -- Type Conversion and Casting -- Java's Automatic Conversions -- Casting Incompatible Types -- Automatic Type Promotion in Expressions