Java the complete reference
Fully updated for Java SE 17, Java: 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 fundamental programming principles. You'l...
| Otros Autores: | |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
New York, New York :
McGraw Hill
[2022]
|
| Edición: | Twelfth edition |
| Colección: | McGraw-Hill's AccessEngineeringLibrary
|
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009635720606719 |
Tabla de Contenidos:
- 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.
- 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.
- 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.
- Exporting to a Specific Module.
