Beginning Java 8 fundamentals : language syntax, arrays, data types, objects, and regular expressions /

Mostrar otras versiones (1)

Provides a comprehensive approach to learning the Java programming language, especially the object-oriented fundamentals necessary at all levels of Java development. Provides over 90 diagrams and 240 complete programs to help beginners and intermediate level programmers learn the topics faster. Star...

Descripción completa

Detalles Bibliográficos
Clasificación:Libro Electrónico
Autor principal: Sharan, Kishori (Software engineer) (Autor)
Formato: Electrónico eBook
Idioma:Inglés
Publicado: [Berkeley, CA] : Apress, 2014.
Colección:Expert's voice in Java.
Temas:
Java (Computer program language)
Java (Langage de programmation)
COMPUTERS > Programming Languages > Java.
Acceso en línea:Texto completo (Requiere registro previo con correo institucional)
Tabla de Contenidos:
  • Machine generated contents note: ch. 1 Programming Concepts
  • What Is Programming?
  • Components of a Programming Language
  • Programming Paradigms
  • Imperative Paradigm
  • Procedural Paradigm
  • Declarative Paradigm
  • Functional Paradigm
  • Logic Paradigm
  • Object-Oriented Paradigm
  • What Is Java?
  • Object-Oriented Paradigm and Java
  • Abstraction
  • Encapsulation and Information Hiding
  • Inheritance
  • Polymorphism
  • Summary
  • ch. 2 Writing Java Programs
  • What is a Java Program?
  • System Requirements
  • Writing the Source Code
  • Package Declaration
  • Import Declarations
  • Class Declaration
  • Compiling the Source Code
  • Running the Compiled Code
  • Using NetBeans IDE
  • Creating a Java Project
  • Adding Classes to the Project
  • Customizing Project Properties
  • Opening an Existing NetBeans Project
  • Behind the Scenes
  • Summary
  • ch. 3 Data Types
  • What Is a Data Type?
  • What Is an Identifier?
  • Data Types in Java
  • Primitive Data Types in Java
  • Integral Data Types
  • Floating-Point Data Types
  • Underscores in Numeric Literals
  • Java Compiler and Unicode Escape Sequence
  • Short Break
  • Binary Representation of Integers
  • Diminished Radix Complement
  • Radix Complement
  • Binary Representation of Floating-Point Numbers
  • 32-bit Single-Precision Floating-Point Format
  • Special Floating-Point Numbers
  • Signed Zeros
  • Signed Infinities
  • NaN
  • Denormals
  • Rounding Modes
  • Rounding Toward Zero
  • Rounding Toward Positive Infinity
  • Rounding Toward Negative Infinity
  • Rounding Toward Nearest
  • IEEE Floating-Point Exceptions
  • Division by Zero Exception
  • Invalid Operation Exception
  • Overflow Exception
  • Underflow Exception
  • Inexact Exception
  • Java and IEEE Floating-Point Standards
  • Little-Endian and Big-Endian
  • Summary
  • ch. 4 Operators
  • What Is an Operator?
  • Assignment Operator (=)
  • Declaration, Initialization, and Assignment
  • Arithmetic Operators
  • Addition Operator (+)
  • Subtraction Operator (-)
  • Multiplication Operator (*)
  • Division Operator (/)
  • Modulus Operator (%)
  • Unary Plus Operator (+)
  • Unary Minus Operator (-)
  • Compound Arithmetic Assignment Operators
  • Increment (++) and Decrement (
  • ) Operators
  • String Concatenation Operator (+)
  • Relational Operators
  • Equality Operator (==)
  • Inequality Operator (!=)
  • Greater Than Operator (>)
  • Greater Than or Equal to Operator (>=)
  • Less Than Operator (<)
  • Less Than or Equal to Operator (<=)
  • Boolean Logical Operators
  • Logical NOT Operator (!)
  • Logical Short-Circuit AND Operator (&&)
  • Logical AND Operator (&)
  • Logical Short-Circuit OR Operator (II)
  • Logical OR Operator (I)
  • Logical XOR Operator ([ˆ])
  • Compound Boolean Logical Assignment Operators
  • Ternary Operator (? :)
  • Operator Precedence
  • Bitwise Operators
  • Summary
  • ch. 5 Statements
  • What Is a Statement?
  • Types of Statements
  • Declaration Statement
  • Expression Statement
  • Control Flow Statement
  • Block Statement
  • if-else Statement
  • switch Statement
  • for Statement
  • Initialization
  • Condition-expression
  • Expression-list
  • for-each Statement
  • while Statement
  • do-while Statement
  • break Statement
  • continue Statement
  • Empty Statement
  • Summary
  • ch. 6 Classes and Objects
  • What Is a Class?
  • Declaring a Class
  • Declaring Fields in a Class
  • Creating Instances of a Class
  • null Reference Type
  • Using Dot Notation to Access Fields of a Class
  • Default Initialization of Fields
  • Access Level Modifiers for a Class
  • Import Declarations
  • Single-Type Import Declaration
  • Import-on-Demand Declaration
  • Import Declarations and Type Search Order
  • Automatic Import Declarations
  • Static Import Declarations
  • Declaring Methods of a Class
  • Local Variables
  • Instance Method and Class Method
  • Invoking a Method
  • Special main() Method
  • What Is this?
  • Access Levels for Class Members
  • Access Level
  • A Case Study
  • Parameter Passing Mechanisms
  • Pass By Value
  • Pass By Constant Value
  • Pass By Reference
  • Pass By Reference Value
  • Pass by Constant Reference Value
  • Pass by Result
  • Pass by Value Result
  • Pass By Name
  • Pass by Need
  • Parameter Passing Mechanisms in Java
  • Constructors
  • Declaring a Constructor
  • Overloading a Constructor
  • Writing Code for a Constructor
  • Calling a Constructor from another Constructor
  • Using a return Statement Inside a Constructor
  • Access Level Modifier for a Constructor
  • Default Constructor
  • static Constructor
  • Instance Initialization Block
  • Static Initialization Block
  • final Keyword
  • Final Local Variables
  • Final Parameters
  • Final Instance Variables
  • Final Class Variables
  • Final Reference Variables
  • Compile-time vs. Runtime final Variables
  • What is a varargs Method?
  • Overloading a Varargs Method
  • Varargs Methods and the main() Method
  • Generic Classes
  • Summary
  • ch. 7 Object and Objects Classes
  • Object Class
  • Rule #1
  • Rule #2
  • What Is the Class of an Object?
  • Computing Hash Code of an Object
  • Comparing Objects for Equality
  • String Representation of an Object
  • Cloning Objects
  • Finalizing an Object
  • Immutable Objects
  • Objects Class
  • Summary
  • ch. 8 Wrapper Classes
  • Wrapper Classes
  • Numeric Wrapper Classes
  • Character Wrapper Class
  • Boolean Wrapper Class
  • Unsigned Numeric Operations
  • Autoboxing and Unboxing
  • Beware of Null Values
  • Overloaded Methods and Autoboxing/Unboxing
  • Comparison Operators and AutoBoxing/Unboxing
  • Collections and Autoboxing/Unboxing
  • Summary
  • ch. 9 Exception Handling
  • What Is an Exception?
  • Exception Is an Object
  • Using a try-catch Block
  • Transfer of Control
  • Exception Class Hierarchy
  • Arranging Multiple catch Blocks
  • Checked and Unchecked Exceptions
  • Checked Exception
  • Catch or Declare
  • Checked Exceptions and Initializers
  • Throwing an Exception
  • Creating an Exception Class
  • finally Block
  • Rethrowing an Exception
  • Analysis of Rethrown Exceptions
  • Throwing too Many Exceptions
  • Accessing the Stack of a Thread
  • try-with-resources Block
  • Multi-Catch Block
  • Summary
  • ch. 10 Assertions
  • What Is an Assertion?
  • Testing Assertions
  • Enabling/Disabling Assertions
  • Using Assertions
  • Checking for Assertion Status
  • Summary
  • ch. 11 Strings
  • What is a String?
  • String Literals
  • Escape Sequence Characters in String Literals
  • Unicode Escapes in String Literals
  • What is a CharSequence?
  • Creating String Objects
  • Length of a String
  • String Literals Are String Objects
  • String Objects Are Immutable
  • Comparing Two Strings
  • String Pool
  • String Operations
  • Getting the Character at an Index
  • Testing Strings for Equality
  • Testing a String to be Empty
  • Changing the Case
  • Searching for a String
  • Representing Values as Strings
  • Getting a Substring
  • Trimming a String
  • Replacing Part of a String
  • Matching Start and End of a String
  • Splitting and Joining Strings
  • Strings in a switch Statement
  • Testing a String for Palindrome
  • StringBuilder and StringBuffer
  • String Concatenation Operator (+)
  • Language-Sensitive String Comparison
  • Summary
  • ch.
  • 12 Dates and Times
  • Date-Time API
  • Design Principles
  • Quick Example
  • Evolution of Timekeeping
  • Time Zones and Daylight Saving Time
  • Calendar Systems
  • Julian Calendar
  • Gregorian Calendar
  • ISO-8601 Standards for Datetime
  • Exploring the New Date-Time API
  • of XXX() Methods
  • from() Methods
  • with XXX() Methods
  • getXXX() Methods
  • toXXX() Methods
  • atXXX() Methods
  • plusXXX() and minusXXX() Methods
  • multipliedBy(), dividedBy(), and negated() Methods
  • Instants and Durations
  • Human-Scale Time
  • ZoneOffset Class
  • Zoneld Class
  • Useful Datetime-Related Enums
  • Local Date, Time, and Datetime
  • Offset Time and Datetime
  • Zoned Datetime
  • Same Instant, Different Times
  • Clocks
  • Periods
  • Period Between Two Dates and Times
  • Partials
  • Adjusting Dates
  • Querying Datetime Objects
  • Non-ISO Calendar Systems
  • Formatting Dates and Times
  • Using Predefined Formatters
  • Using the format() Method of Datetime Classes
  • Using User-Defined Patterns
  • Using Locale Specific Formats
  • Using the Date Time Formatter Builder Class
  • Parsing Dates and Times
  • Legacy Datetime Classes
  • Date Class
  • Calendar Class
  • add() Method
  • roll() Method
  • Interoperability with Legacy Datetime Classes
  • Summary
  • ch. 13 Formatting Data
  • Formatting Dates
  • Formatting Numbers
  • Printf-style Formatting
  • Big Picture
  • Details
  • Referencing an Argument inside a Format Specifier
  • Using Flags in a Format Specifier
  • Conversion Characters
  • Summary
  • ch. 14 Regular Expressions
  • What Is a Regular Expression?
  • Metacharacters
  • Character Classes
  • Predefined Character Classes
  • More Powers to Regular Expressions
  • Compiling Regular Expressions
  • Creating a Matcher
  • Matching the Pattern
  • Beware of Backslashes
  • Quantifiers in Regular Expressions
  • Matching Boundaries
  • Groups and Back Referencing
  • Using Named Groups
  • Resetting the Matcher
  • Final Words on E-mail Validations
  • Find-and-Replace Using Regular Expressions
  • Summary
  • ch. 15 Arrays
  • What Is an Array?
  • Arrays Are Objects
  • Accessing Array Elements.
  • Note continued: Length of an Array
  • Initializing Array Elements
  • Beware of Reference Type Arrays
  • Explicit Array Initialization
  • Limitations of Using Arrays
  • Variable-Length Arrays
  • Passing an Array as a Parameter
  • Array Parameter Reference
  • Elements of the Array Parameter
  • Object Referred by the Array Parameter Elements
  • Command-Line Arguments
  • Multi-Dimensional Arrays
  • Accessing Elements of a Multi-Dimensional Array
  • Initializing Multi-Dimensional Arrays
  • Enhanced for Loop for Arrays
  • Array Declaration Syntax
  • Runtime Array Bounds Checks
  • What Is the Class of an Array Object
  • Array Assignment Compatibility
  • Converting an ArrayList/vector to an Array
  • Summary
  • ch. 16 Inheritance
  • What is Inheritance?
  • Object Class is the Default Superclass
  • Inheritance and Hierarchical Relationship
  • What Is Inherited by a Subclass?
  • Upcasting and Downcasting
  • instanceof Operator
  • Binding
  • Early Binding
  • Late Binding
  • Method Overriding
  • Method Overriding Rule #1
  • Method Overriding Rule #2
  • Method Overriding Rule #3
  • Method Overriding Rule #4
  • Method Overriding Rule #5
  • Method Overriding Rule #6
  • Accessing Overridden Method
  • Method Overloading
  • Inheritance and Constructors
  • Method Hiding
  • Field Hiding
  • Disabling Inheritance
  • Abstract Classes and Methods
  • Method Overriding and Generic Method Signatures
  • Typo Danger in Method Overriding
  • Is-a, has-a, and part-of Relationships
  • No Multiple Inheritance of Classes
  • Summary
  • ch. 17 Interfaces
  • What Is an Interface?
  • Proposed Solution #1
  • Proposed Solution #2
  • Proposed Solution #3
  • Ideal Solution
  • Declaring an Interface
  • Declaring Interface Members
  • Constant Fields Declarations
  • Methods Declarations
  • Nested Type Declarations
  • Interface Defines a New Type
  • Implementing an Interface
  • Implementing Interface Methods
  • Implementing Multiple Interfaces
  • Partially Implementing an Interface
  • Supertype-Subtype Relationship
  • Interface Inheritance
  • Superinterface-Subinterface Relationship
  • Inheriting Conflicting Implementations
  • Superclass Always Wins
  • Most Specific Superinterface Wins
  • Class Must Override the Conflicting Method
  • instanceof Operator
  • Marker Interfaces
  • Functional Interfaces
  • Comparing Objects
  • Using the Comparable Interface
  • Using the Comparator Interface
  • Polymorphism
  • One Object, Many Views
  • Dynamic Binding and Interfaces
  • Summary
  • ch. 18 Enum Types
  • What Is an Enum Type?
  • Superclass of an Enum Type
  • Using Enum Types in switch Statements
  • Associating Data and Methods to Enum Constants
  • Associating a Body to an Enum Constant
  • Comparing Two Enum Constants
  • Nested Enum Types
  • Implementing an Interface to an Enum Type
  • Reverse Lookup for Enum Constants
  • Range of Enum Constants
  • Summary
  • Appendix A Character Encodings
  • ASCII
  • 8-bit Character Sets
  • Universal Multiple-Octet Coded Character Set (UCS)
  • UCS-2
  • UCS-4
  • UTF-16 (UCS Transformation Format 16)
  • UTF-8 (UCS Transformation Format 8)
  • Java and Character Encodings
  • Appendix B Documentation Comments
  • Writing Documentation Comments
  • List of Block and Inline Tags
  • @author <author-name(s)>
  • @deprecated <explanation-text>
  • @exception <class-name> <description>
  • @param <parameter-name> <description>
  • @return <description>
  • @see <reference>
  • @serial <field-description or include/exclude>
  • @serialData <data-description>
  • @serialField <field-name> <field-type> <field-description>
  • @since <description>
  • @throws <class-name> <description>
  • @version <version-text>
  • {@code <text>}
  • {@docRoot}
  • {@inheritDoc}
  • {@link <package.class#member> <label>}
  • {@linkplain <package.class#member> <label>}
  • {@literal <text>}
  • {@value <package.class#field>}
  • Documenting Packages
  • com/jdojo/utility/package-info.java file
  • com/jdojo/utility/package.html file
  • Overview Documentation
  • Including Unprocessed Files in Documentation
  • Skipping Source Files Processing
  • Example of Documentation Comments
  • Running the javadoc Tool
  • Generated Documentation Files
  • Viewing Generated HTML Documentation
  • Summary
  • Appendix C Compact Profiles
  • Enhancement in the javac Command
  • Enhancement in Java API Documentation
  • Checking for Profile Dependencies
  • Creating Custom JREs Using the EJDK
  • Installing EJDK
  • Running the jrecreate Command
  • Deploying the Custom JRE
  • Running the Custom JRE.

Ejemplares similares