{"text_format":"2","workbook":"xls","n_sheets":1,"sheets":["report2"],"not_rendered":{"charts":0,"images":0,"macros":0,"external_links":1,"defined_names":1,"comments":0,"pivot_tables":0},"unopened":[],"bounds":{"document_bytes":16777216,"sheet_cells":100000,"run_cost":"one","rows_first":2000,"rows_last":500,"rows_between":2000,"halvings":0,"cell_chars":16384,"cell_head_chars":4096},"cells_cut":0,"cells_raw":0,"read":"whole","date_system":"1900","formulas":"cached_only"}

{"sheet":"report2","index":0,"n_rows":24,"n_cols":5,"rows_kept":24,"cut":false,"hidden":false,"merged":[[0,2,0,3],[0,4,0,5],[1,2,1,3],[1,4,1,5],[2,2,2,3],[2,4,2,5],[3,2,3,3],[5,2,5,3],[6,2,6,3],[7,2,7,3],[8,2,8,3],[9,2,9,3],[10,2,10,3],[11,2,11,3],[14,2,14,3]],"flags":["formulas_cached_only"]}
[null,"1.","Record Nr.",null,"UNINA9910523784603321"]
[null,null,"Autore",null,"Sharan Kishori (Software engineer)"]
[null,null,"Titolo",null,"Beginning Java 17 fundamentals : object-oriented programming in Java 17 / / Kishori Sharan, Adam L. Davis"]
[null,null,"Pubbl/distr/stampa",null,"New York : , : Apress Media LLC, , [2022]"]
[{"$nulls":4},"©2022"]
[null,null,"ISBN",null,"1-4842-7307-9"]
[null,null,"Edizione",null,"[Third edition.]"]
[null,null,"Descrizione fisica",null,"1 online resource (1023 pages)"]
[null,null,"Disciplina",null,"005.133"]
[null,null,"Soggetti",null,"Java (Computer program language)"]
[null,null,"Lingua di pubblicazione",null,"Inglese"]
[null,null,"Formato",null,"Materiale a stampa"]
[null,null,null,"Livello bibliografico","Monografia"]
[null,null,null,"Note generali","Includes index."]
[null,null,"Nota di contenuto",null,"Intro -- Table of Contents -- About the Authors -- About the Technical Reviewer -- Acknowledgments -- Introduction -- Chapter 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? -- The Object-Oriented Paradigm and Java -- Abstraction -- Abstraction for Hiding Complexities -- Data Abstraction -- Encapsulation and Information Hiding -- Inheritance -- Polymorphism -- Overloading Polymorphism -- Coercion Polymorphism -- Inclusion Polymorphism -- Parametric Polymorphism -- Summary -- Chapter 2: Setting Up the Environment -- System Requirements -- Installing JDK 17 -- The JDK Directory Structure -- Verifying the JDK Installation -- Starting the JShell Tool -- Installing NetBeans 12 -- Configuring NetBeans -- Summary -- Chapter 3: Writing Java Programs -- The Goal Statement -- Using the JShell Tool -- What Is a Java Program? -- Writing the Source Code -- Writing Comments -- Declaring a Module -- Declaring Types -- Package Declaration -- Import Declarations -- Class Declaration -- Types Have Two Names -- Compiling the Source Code -- Packaging the Compiled Code -- Running a Java Program -- Playing with Module Options -- Listing Observable Modules -- Limiting the Observable Modules -- Describing a Module -- Printing Module Resolution Details -- Dry-Running Your Program -- Enhancing a Module Descriptor -- Running Java Programs in Legacy Mode -- Duplicate Modules on a Module Path -- Syntax for Command-Line Options -- Writing Java Programs Using "]
[{"$nulls":4},"the NetBeans IDE -- Creating a Java Project -- Creating Modular JARs in NetBeans -- NetBeans Project Directory Structure -- Adding Classes to a Module -- Customizing NetBeans Project Properties."]
[{"$nulls":4},"Opening an Existing NetBeans Project -- Behind the Scenes -- Summary -- Chapter 4: Data Types -- What Is a Data Type -- What Is an Identifier? -- Keywords -- Data Types in Java -- Local Variable Type Inference -- Primitive Data Types in Java -- Integral Data Types -- The int Data Type -- The long Data Type -- The byte Data Type -- The short Data Type -- The char Data Type -- Character Literals in Single Quotes -- Character Escape Sequence -- Unicode Character Escape Sequence -- Octal Character Escape Sequence -- The boolean Data Type -- Floating-Point Data Types -- The float Data Type -- The double Data Type -- Underscores in Numeric Literals -- Java Compiler and Unicode Escape Sequence -- A Short Break -- Binary Representation of Integers -- Diminished Radix Complement -- Radix Complement -- Binary Representation of Floating-Point Numbers -- 32-Bit Single-Precision Floating-Point Format -- Sign -- Exponent -- Significand -- 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 -- Chapter 5: Operators -- What Is an Operator? -- Assignment Operator -- Declaration, Initialization, and Assignment -- Arithmetic Operators -- Addition Operator (+) -- Subtraction Operator (-) -- Multiplication Operator (*) -- Division Operator (/) -- Modulus Operator (%) -- Rule #1 -- Rule #2 -- Rule #1 -- Rule #2 -- Rule #3 -- Rule #4 -- Rule #5 -- Unary Plus Operator (+) -- Unary Minus Operator (-) -- Compound Arithmetic Assignment Operators."]
[{"$nulls":4},"Increment (++) and Decrement (--) Operators -- String Concatenation Operator (+) -- Relational Operators -- Equality Operator (==) -- Rule #1 -- Rule #2 -- Rule #3 -- Inequality Operator (!=) -- Greater Than Operator (&gt -- ) -- Greater Than or Equal to Operator (&gt -- =) -- Less Than Operator (&lt -- ) -- Less Than or Equal to Operator (&lt -- =) -- Boolean Logical Operators -- Logical NOT Operator (!) -- Logical Short-Circuit AND Operator (&amp -- &amp -- ) -- Logical AND Operator (&amp -- ) -- Logical Short-Circuit OR Operator (||) -- Logical OR Operator (|) -- Logical XOR Operator (^) -- Compound Boolean Logical Assignment Operators -- Ternary Operator (?:) -- Bitwise Operators -- Operator Precedence -- Summary -- Chapter 6: Statements -- What Is a Statement? -- Types of Statements -- Declaration Statement -- Expression Statement -- Control Flow Statement -- A Block Statement -- The if-else Statement -- The switch Statement -- The switch Expression -- The for Statement -- Initialization -- Condition Expression -- Expression List -- The for-each Statement -- The while Statement -- The do-while Statement -- The break Statement -- The continue Statement -- An Empty Statement -- Summary -- Chapter 7: Classes -- What Is a Class? -- Declaring a Class -- Declaring Fields in a Class -- Creating Instances of a Class -- The 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 -- Static Import Rule #1 -- Static Import Rule #2 -- Static "]
[{"$nulls":4},"Import Rule #3 -- Declaring a Record -- Summary -- Chapter 8: Methods -- What Is a Method? -- Declaring Methods of a Class."]
[{"$nulls":4},"Local Variables -- Rule #1 -- Rule #2 -- Rule #3 -- Rule #4 -- Instance Methods and Class Methods -- Invoking a Method -- The Special main() Method -- What Is this? -- Access Levels for Class Members -- Access Level: A Case Study -- What Is a Var-Args Method? -- Overloading a Var-Args Method -- Var-Args Methods and the main() Method -- 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 -- Summary -- Chapter 9: Constructors -- What Is a Constructor? -- 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 -- A static Constructor -- Instance Initialization Block -- Static Initialization Block -- The final Keyword -- final Local Variables -- final Parameters -- final Instance Variables -- final Class Variables -- final Reference Variables -- Compile-Time vs. Runtime final Variables -- Generic Classes -- Summary -- Chapter 10: Modules -- What Is a Module? -- Declaring Modules -- Declaring Module Dependence -- An Example of Module Dependence -- Troubleshooting -- Empty Package Error -- Module Not Found Error -- Package Does Not Exist Error -- Module Resolution Exception -- Implicit Dependence -- Optional Dependence -- Opening Modules and Packages -- Open Modules -- Opening Packages -- Splitting Packages Across Modules -- Restrictions in Module Declarations -- Types of Modules -- Normal Modules -- Open Modules -- Automatic Modules -- Unnamed Modules -- Aggregator Modules -- Knowing About Modules at Runtime -- Migration Path to Modules."]
[{"$nulls":4},"Java Class Dependency Analyzer -- Disassembling Module Definitions -- Summary -- Chapter 11: Object and Objects Classes -- The Object Class -- Rule #1 -- Rule #2 -- What Is the Class of an Object? -- Computing the Hash Code of an Object -- Comparing Objects for Equality -- String Representation of an Object -- Cloning Objects -- Finalizing an Object -- Immutable Objects -- The Objects Class -- Bounds Checks -- Comparing Objects -- Computing Hash Code -- Checking for Null -- Validating Arguments -- Obtaining String Representation of Objects -- Using the Objects Class -- Summary -- Chapter 12: Wrapper Classes -- Wrapper Classes -- Numeric Wrapper Classes -- The Character Wrapper Class -- The 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 -- Chapter 13: Exception Handling -- What Is an Exception? -- An Exception Is an Object -- Using a try-catch Block -- Transfer of Control -- Exception Class Hierarchy -- Arranging Multiple catch Blocks -- A Multi-catch Block -- Checked and Unchecked Exceptions -- Checked Exception: Catch or Declare -- Checked Exceptions and Initializers -- Throwing an Exception -- Creating an Exception Class -- The finally Block -- Rethrowing an Exception -- Analysis of Rethrown Exceptions -- Throwing Too Many Exceptions -- Accessing the Stack of a Thread -- The try-with-resources Block -- Summary -- Chapter 14: Assertions -- What Is an Assertion? -- Testing Assertions -- Enabling/Disabling Assertions -- Using Assertions -- Checking for Assertion Status -- Summary -- "]
[{"$nulls":4},"Chapter 15: Strings -- What Is a String? -- String Literals -- Escape Sequence Characters in String Literals -- Unicode Escapes in String Literals -- What Is a CharSequence?."]
[{"$nulls":4},"Creating String Objects."]
[null,null,null,"Sommario/riassunto","Learn the fundamentals of the Java 17 LTS or Java Standard Edition version 17 Long Term Support release, including basic programming concepts and the object-oriented fundamentals necessary at all levels of Java development. Authors Kishori Sharan and Adam L. Davis walk you through writing your first Java program step-by-step. Armed with that practical experience, you'll be ready to learn the core of the Java language. Beginning Java 17 Fundamentals provides over 90 diagrams and 240 complete programs to help you learn the topics faster. While this book teaches you the basics, it also has been revised to include the latest from Java 17 including the following: value types (records), immutable objects with an efficient memory layout; local variable type inference (var); pattern matching, a mechanism for testing and deconstructing values; sealed types, a mechanism for declaring all possible subclasses of a class; multiline text values; and switch expressions. The book continues with a series of foundation topics, including using data types, working with operators, and writing statements in Java. These basics lead onto the heart of the Java language: object-oriented programming. By learning topics such as classes, objects, interfaces, and inheritance you'll have a good understanding of Java's object-oriented model. The final collection of topics takes what you've learned and turns you into a real Java programmer. You'll see how to take the power of object-oriented programming and write programs that can handle errors and exceptions, process strings and dates, format data, and work with arrays to manipulate data. What You Will Learn Write your first Java programs with emphasis on learning object-oriented programming How to work with switch expressions, value types (records), local variable type inference, pattern matching switch and more from Java 17 Handle exceptions, assertions, strings and dates, and object formatting Learn about how to define and use modules Dive in depth into classes, interfaces, and inheritance in Java Use regular expressions Take advantage of the JShell REPL tool Who This Book Is For Those who are new to Java programming, who may have some or even no prior programming experience."]