Beginning Java 9 Fundamentals: Arrays, Objects, Modules, JShell, and Regular Expressions

🔙 Quay lại trang tải sách pdf ebook Beginning Java 9 Fundamentals: Arrays, Objects, Modules, JShell, and Regular Expressions Ebooks Nhóm Zalo Beginning Java 9 Fundamentals Arrays, Objects, Modules, JShell, and Regular Expressions — Second Edition — Kishori Sharan Beginning Java 9 Fundamentals Arrays, Objects, Modules, JShell, and Regular Expressions Second Edition Kishori Sharan Beginning Java 9 Fundamentals: Arrays, Objects, Modules, JShell, and Regular Expressions Kishori Sharan Montgomery, Alabama, USA ISBN-13 (pbk): 978-1-4842-2843-2 ISBN-13 (electronic): 978-1-4842-2902-6 https://doi.org/10.1007/978-1-4842-2902-6 Library of Congress Control Number: 2017958824 Copyright © 2017 by Kishori Sharan This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed. Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark. The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights. While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made. The publisher makes no warranty, express or implied, with respect to the material contained herein. Cover image by Freepik (www.freepik.com) Managing Director: Welmoed Spahr Editorial Director: Todd Green Acquisitions Editor: Steve Anglin Development Editor: Matthew Moodie Technical Reviewer: Wallace Jackson Coordinating Editor: Mark Powers Copy Editor: Kezia Endsley Distributed to the book trade worldwide by Springer Science+Business Media New York, 233 Spring Street, 6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail [email protected], or visit www.springeronline.com. Apress Media, LLC is a California LLC and the sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware corporation. For information on translations, please e-mail [email protected], or visit http://www.apress.com/ rights-permissions. Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook versions and licenses are also available for most titles. For more information, reference our Print and eBook Bulk Sales web page at http://www.apress.com/bulk-sales. Any source code or other supplementary material referenced by the author in this book is available to readers on GitHub via the book’s product page, located at www.apress.com/9781484228432. For more detailed information, please visit http://www.apress.com/source-code. Printed on acid-free paper Contents at a Glance About the Author ��xxvii About the Technical Reviewer ��xxix Acknowledgments��xxxi Introduction��xxxiii ■Chapter 1: Programming Concepts �� 1 ■Chapter 2: Setting Up the Environment �� 33 ■Chapter 3: Writing Java Programs �� 45 ■Chapter 4: Data Types�� 99 ■Chapter 5: Operators �� 145 ■Chapter 6: Statements�� 191 ■Chapter 7: Classes�� 223 ■Chapter 8: Methods �� 255 ■Chapter 9: Constructors �� 323 ■Chapter 10: Modules �� 355 ■Chapter 11: Object and Objects Classes�� 395 ■Chapter 12: Wrapper Classes �� 439 ■Chapter 13: Exception Handling �� 461 ■Chapter 14: Assertions �� 511 ■Chapter 15: Strings�� 521 iii ■ Contents at a Glance ■Chapter 16: Dates and Times�� 549 ■Chapter 17: Formatting Data �� 631 ■Chapter 18: Regular Expressions �� 669 ■Chapter 19: Arrays �� 701 ■Chapter 20: Inheritance�� 755 ■Chapter 21: Interfaces�� 823 ■Chapter 22: Enum Types�� 895 ■Chapter 23: Java Shell�� 921 ■Appendix A: Character Encodings �� 985 ■Appendix B: Documentation Comments �� 997 Index�� 1023 iv Contents About the Author ��xxvii About the Technical Reviewer ��xxix Acknowledgments��xxxi Introduction��xxxiii ■Chapter 1: Programming Concepts �� 1 What Is Programming?�� 1 Components of a Programming Language�� 4 Programming Paradigms�� 4 Imperative Paradigm �� 6 Procedural Paradigm�� 6 Declarative Paradigm �� 7 Functional Paradigm�� 8 Logic Paradigm�� 8 Object-Oriented Paradigm�� 9 What Is Java? �� 12 The Object-Oriented Paradigm and Java�� 13 Abstraction �� 14 Encapsulation and Information Hiding�� 23 Inheritance�� 25 Polymorphism�� 26 Summary�� 31 ■Chapter 2: Setting Up the Environment �� 33 System Requirements �� 33 Installing JDK 9 �� 33 v ■ Contents The JDK Directory Structure�� 34 Verifying the JDK Installation �� 37 Starting the JShell Tool �� 38 Installing NetBeans 9 �� 38 Configuring NetBeans �� 39 Summary�� 43 ■Chapter 3: Writing Java Programs �� 45 The Goal Statement�� 45 Using the JShell Tool �� 46 What Is a Java Program? �� 46 Writing the Source Code�� 47 Writing Comments�� 48 Declaring a Module �� 49 Declaring Types �� 51 Package Declaration�� 52 Import Declarations �� 53 Class Declaration�� 54 Types Have Two Names �� 59 Compiling the Source Code�� 60 Packaging the Compiled Code�� 62 Running a Java Program�� 64 Playing with Module Options�� 69 Listing Observable Modules �� 69 Limiting the Observable Modules �� 70 Describing a Module�� 71 Printing Module Resolution Details�� 72 Dry Running Your Program ��73 Enhancing a Module Descriptor �� 73 Running Java Programs in Legacy Mode �� 75 vi ■ Contents Duplicate Modules on Module Path�� 78 Syntax for Command-Line Options�� 80 Writing Java Programs Using the NetBeans IDE �� 81 Creating a Java Project�� 81 Creating Modular JARs in NetBeans�� 88 NetBeans Project Directory Structure�� 89 Adding Classes to a Module �� 89 Customizing NetBeans Project Properties�� 89 Opening an Existing NetBeans Project �� 91 Behind the Scenes �� 91 Summary�� 95 ■Chapter 4: Data Types�� 99 What Is a Data Type?�� 99 What Is an Identifier? �� 100 Keywords�� 102 Data Types in Java�� 102 Primitive Data Types in Java �� 107 Integral Data Types �� 108 Floating-Point Data Types�� 118 Underscores in Numeric Literals �� 123 Java Compiler and Unicode Escape Sequence �� 123 A Short Break �� 125 Binary Representation of Integers�� 126 Diminished Radix Complement�� 127 Radix Complement �� 128 Binary Representation of Floating-Point Numbers�� 129 32-bit Single-Precision Floating-Point Format�� 131 Special Floating-Point Numbers�� 134 Signed Zeros�� 134 Signed Infinities�� 134 vii ■ Contents NaN�� 135 Denormals �� 136 Rounding Modes �� 136 Rounding Toward Zero�� 137 Rounding Toward Positive Infinity�� 137 Rounding Toward Negative Infinity �� 137 Rounding Toward Nearest�� 138 IEEE Floating-Point Exceptions�� 138 Division by Zero Exception�� 138 Invalid Operation Exception�� 138 Overflow Exception�� 139 Underflow Exception�� 139 Inexact Exception �� 139 Java and IEEE Floating-Point Standards �� 140 Little-Endian and Big-Endian�� 140 Summary�� 141 ■Chapter 5: Operators �� 145 What Is an Operator?�� 145 Assignment Operator�� 147 Declaration, Initialization, and Assignment �� 149 Arithmetic Operators �� 150 Addition Operator (+)�� 151 Subtraction Operator (-)�� 153 Multiplication Operator (*) �� 154 Division Operator (/)�� 155 Modulus Operator (%)�� 157 Unary Plus Operator (+)�� 159 Unary Minus Operator (-)�� 159 Compound Arithmetic Assignment Operators�� 160 Increment (++) and Decrement (--) Operators �� 161 viii ■ Contents String Concatenation Operator (+) �� 164 Relational Operators�� 169 Equality Operator (==)�� 169 Inequality Operator (!=) ��172 Greater Than Operator (>)�� 172 Greater Than or Equal to Operator (>=)�� 173 Less Than Operator (<)�� 173 Less Than or Equal to Operator (<=) �� 174 Boolean Logical Operators �� 174 Logical NOT Operator (!) �� 175 Logical Short-Circuit AND Operator (&&) �� 175 Logical AND Operator (&)�� 177 Logical Short-Circuit OR Operator (||) �� 178 Logical OR Operator (|)�� 178 Logical XOR Operator (^)�� 178 Compound Boolean Logical Assignment Operators�� 179 Ternary Operator (? :) �� 180 Bitwise Operators�� 180 Operators Precedence�� 184 Summary�� 186 ■Chapter 6: Statements�� 191 What Is a Statement?�� 191 Types of Statements�� 192 Declaration Statement�� 192 Expression Statement�� 192 Control Flow Statement��193 A Block Statement�� 194 The if-else Statement�� 195 The switch Statement �� 200 ix ■ Contents The for Statement �� 204 Initialization �� 205 Condition-Expression�� 206 Expression-List�� 207 The for-each Statement�� 209 The while Statement �� 210 The do-while Statement�� 212 The break Statement�� 214 The continue Statement�� 217 An Empty Statement�� 218 Summary�� 219 ■Chapter 7: Classes�� 223 What Is a Class?�� 223 Declaring a Class�� 224 Declaring Fields in a Class �� 225 Creating Instances of a Class�� 226 The null Reference Type �� 228 Using Dot Notation to Access Fields of a Class �� 229 Default Initialization of Fields�� 232 Access Level Modifiers for a Class�� 233 Import Declarations�� 236 Single-Type Import Declaration �� 237 Import-on-Demand Declaration�� 239 Import Declarations and Type Search Order�� 241 Automatic Import Declarations�� 247 Static Import Declarations �� 248 Summary�� 251 x ■ Contents ■Chapter 8: Methods �� 255 What Is a Method? �� 255 Declaring Methods of a Class�� 255 Local Variables �� 260 Rule #1 �� 260 Rule #2 �� 261 Rule #3 �� 261 Rule #4 �� 261 Instance Methods and Class Methods�� 264 Invoking a Method�� 265 The Special main() Method�� 267 What Is this?�� 269 Access Levels for Class Members�� 275 Access Level: A Case Study�� 282 What Is a Var-Args Method?�� 288 Overloading a Var-Args Method�� 293 Var-Args Methods and the main() Method�� 294 Parameter-Passing Mechanisms�� 295 Pass By Value �� 296 Pass By Constant Value �� 299 Pass By Reference�� 299 Pass By Reference Value �� 303 Pass by Constant Reference Value �� 304 Pass by Result �� 304 Pass by Value Result�� 304 Pass By Name�� 305 Pass by Need�� 306 Parameter-Passing Mechanisms in Java �� 306 Summary�� 318 xi ■ Contents ■Chapter 9: Constructors �� 323 What Is a Constructor?�� 323 Declaring a Constructor�� 323 Overloading a Constructor�� 326 Writing Code for a Constructor�� 327 Calling a Constructor from Another Constructor �� 330 Using a return Statement Inside a Constructor�� 332 Access Level Modifier for a Constructor �� 333 Default Constructor �� 337 A static Constructor�� 338 Instance Initialization Block �� 338 static Initialization Block �� 339 The final Keyword�� 341 final Local Variables�� 342 final Parameters �� 343 final Instance Variables�� 343 final Class Variables�� 346 final Reference Variables�� 346 Compile-Time vs. Runtime final Variables �� 347 Generic Classes�� 347 Summary�� 350 ■Chapter 10: Modules �� 355 What Is a Module?�� 355 Declaring Modules �� 356 Declaring Module Dependence �� 358 An Example of Module Dependence�� 360 Troubleshooting �� 366 Implicit Dependence�� 368 Optional Dependence �� 373 xii ■ Contents Opening Modules and Packages �� 373 Open Modules�� 375 Opening Packages�� 375 Splitting Packages Across Modules �� 376 Restrictions in Module Declarations�� 377 Types of Modules �� 377 Normal Modules �� 379 Open Modules�� 379 Automatic Modules�� 379 Unnamed Modules�� 383 Aggregator Modules�� 384 Knowing about Modules at Runtime �� 384 Migration Path to JDK 9 �� 386 Disassembling Module Definitions �� 388 Summary�� 391 ■Chapter 11: Object and Objects Classes�� 395 The Object Class�� 395 Rule #1 �� 396 Rule #2 �� 397 What Is the Class of an Object?�� 399 Computing the Hash Code of an Object�� 400 Comparing Objects for Equality�� 404 String Representation of an Object �� 410 Cloning Objects �� 414 Finalizing an Object�� 422 Immutable Objects �� 424 The Objects Class�� 429 Bounds Checks�� 430 Comparing Objects �� 430 xiii ■ Contents Computing Hash Code �� 431 Checking for Null �� 432 Validating Arguments�� 432 Obtaining String Representation of Objects �� 433 Using the Objects Class�� 433 Summary�� 435 ■Chapter 12: Wrapper Classes �� 439 Wrapper Classes �� 439 Numeric Wrapper Classes �� 442 The Character Wrapper Class �� 445 The Boolean Wrapper Class�� 447 Unsigned Numeric Operations�� 447 Autoboxing and Unboxing�� 449 Beware of Null Values �� 452 Overloaded Methods and Autoboxing/Unboxing�� 452 Comparison Operators and Autoboxing/Unboxing�� 455 Collections and Autoboxing/Unboxing�� 457 Summary�� 458 ■Chapter 13: Exception Handling �� 461 What Is an Exception?�� 461 An Exception Is an Object�� 464 Using a try-catch Block�� 464 Transfer of Control�� 467 Exception Class Hierarchy�� 469 Arranging Multiple catch Blocks �� 470 A Multi-catch Block�� 473 Checked and Unchecked Exceptions�� 474 Checked Exception: Catch or Declare�� 477 Checked Exceptions and Initializers�� 484 xiv ■ Contents Throwing an Exception�� 485 Creating an Exception Class�� 486 The finally Block�� 490 Rethrowing an Exception �� 494 Analysis of Rethrown Exceptions �� 497 Throwing Too Many Exceptions�� 497 Accessing the Stack of a Thread�� 499 The try-with-resources Block�� 502 Summary�� 509 ■Chapter 14: Assertions �� 511 What Is an Assertion?�� 511 Testing Assertions �� 513 Enabling/Disabling Assertions�� 515 Using Assertions�� 517 Checking for Assertion Status �� 518 Summary�� 519 ■Chapter 15: Strings�� 521 What Is a String?�� 521 String Literals�� 522 Escape Sequence Characters in String Literals �� 522 Unicode Escapes in String Literals�� 523 What Is a CharSequence? �� 523 Creating String Objects �� 523 Length of a String�� 524 String Literals Are String Objects �� 524 String Objects Are Immutable �� 525 Comparing Strings�� 526 String Pool�� 528 xv ■ Contents String Operations �� 530 Getting the Character at an Index�� 530 Testing Strings for Equality��531 Testing a String to be Empty�� 531 Changing the Case�� 532 Searching for a String�� 532 Representing Values as Strings�� 532 Getting a Substring�� 533 Trimming a String �� 533 Replacing Part of a String�� 533 Matching the Start and End of a String �� 534 Splitting and Joining Strings �� 535 Strings in a switch Statement�� 536 Testing a String for Palindrome�� 538 StringBuilder and StringBuffer�� 539 String Concatenation Operator (+) �� 543 Language-Sensitive String Comparison�� 543 Summary�� 544 ■Chapter 16: Dates and Times�� 549 The Date-Time API�� 549 Design Principles�� 550 A Quick Example �� 551 Evolution of Timekeeping �� 552 Time Zones and Daylight Savings Time�� 555 Calendar Systems �� 556 The Julian Calendar�� 556 The Gregorian Calendar��557 ISO-8601 Standards for Datetime �� 558 Exploring the New Date-Time API �� 560 The ofXxx() Methods �� 560 xvi ■ Contents The from() Methods �� 560 The withXxx() Methods �� 561 The getXxx() Methods �� 561 The toXxx() Methods ��561 The atXxx() Methods ��562 The plusXxx() and minusXxx() Methods�� 562 The multipliedBy(), dividedBy(), and negated() Methods �� 562 Instants and Durations �� 563 Dividing a Duration by Another Duration�� 566 Converting and Retrieving Duration Parts �� 566 Truncating Duration �� 567 Human-Scale Time�� 568 The ZoneOffset Class��568 The ZoneId Class �� 570 Useful Datetime-Related Enums�� 572 Local Date, Time, and Datetime �� 577 Offset Time and Datetime �� 582 Zoned Datetime �� 583 Same Instant, Different Times �� 587 Clocks�� 587 Periods �� 589 Period Between Two Dates and Times �� 591 Partials �� 593 Adjusting Dates �� 595 Querying Datetime Objects�� 600 Non-ISO Calendar Systems �� 605 Formatting Dates and Times �� 607 Using Predefined Formatters�� 607 Using the format() Method of Datetime Classes�� 609 Using User-Defined Patterns �� 610 xvii ■ Contents Using Locale Specific Formats �� 615 Using the DateTimeFormatterBuilder Class�� 617 Parsing Dates and Times�� 618 Legacy Datetime Classes �� 621 The Date Class�� 621 The Calendar Class�� 622 The add() Method��623 The roll() Method ��624 Interoperability with Legacy Datetime Classes �� 625 Summary�� 629 ■Chapter 17: Formatting Data �� 631 Formatting Dates�� 631 Using Predefined Date Formats�� 632 Using Custom Date Formats �� 635 Parsing Dates �� 637 Formatting Numbers �� 639 Using Predefined Number Formats �� 640 Using Custom Number Formats�� 641 Parsing Numbers ��642 printf-Style Formatting�� 643 The Big Picture �� 643 The Details�� 646 Referencing an Argument Inside a Format Specifier�� 648 Using Flags in a Format Specifier�� 652 Conversion Characters ��653 Summary�� 667 ■Chapter 18: Regular Expressions �� 669 What Is a Regular Expression?�� 669 Metacharacters �� 672 Character Classes �� 673 Predefined Character Classes �� 674 xviii ■ Contents More Powers to Regular Expressions�� 674 Compiling Regular Expressions �� 674 Creating a Matcher�� 676 Matching the Pattern�� 676 Querying a Match�� 679 Beware of Backslashes �� 679 Quantifiers in Regular Expressions �� 680 Matching Boundaries �� 681 Groups and Back Referencing�� 682 Using Named Groups�� 688 Resetting the Matcher�� 690 Final Words on E-Mail Validations �� 691 Find-and-Replace Using Regular Expressions �� 691 Streams of Matched Results �� 695 Summary�� 697 ■Chapter 19: Arrays �� 701 What Is an Array? �� 701 Arrays Are Objects�� 703 Accessing Array Elements�� 704 Length of an Array�� 705 Initializing Array Elements�� 706 Beware of Reference Type Arrays�� 708 Explicit Array Initialization�� 709 Limitations of Using Arrays �� 710 Simulating Variable-Length Arrays�� 714 Passing an Array as a Parameter �� 717 Array Parameter Reference �� 722 Elements of the Array Parameter�� 723 The Object Referred by the Array Parameter Elements �� 724 xix ■ Contents Command-Line Arguments�� 726 Multi-Dimensional Arrays�� 730 Accessing Elements of a Multi-Dimensional Array�� 734 Initializing Multi-Dimensional Arrays�� 734 Enhanced for Loop for Arrays�� 735 Array Declaration Syntax�� 736 Runtime Array Bounds Checks �� 737 What Is the Class of an Array Object? �� 738 Array Assignment Compatibility �� 740 Converting an ArrayList/Vector to an Array �� 742 Performing Array Operations�� 743 Converting Arrays to Another Type�� 745 Searching an Array �� 746 Comparing Arrays �� 746 Copying Arrays�� 748 Filling Arrays�� 748 Computing Hash Code �� 749 Performing Parallel Accumulation �� 749 Sorting Arrays�� 750 Summary�� 750 ■Chapter 20: Inheritance�� 755 What Is Inheritance? �� 755 Inheriting Classes�� 756 The Object Class Is the Default Superclass�� 759 Inheritance and Hierarchical Relationship �� 759 What Is Inherited by a Subclass? �� 760 Upcasting and Downcasting�� 762 The instanceof Operator�� 766 xx ■ Contents Binding �� 768 Early Binding �� 769 Late Binding�� 772 Method Overriding�� 775 Method Overriding Rule #1�� 777 Method Overriding Rule #2�� 777 Method Overriding Rule #3��777 Method Overriding Rule #4�� 777 Method Overriding Rule #5�� 778 Method Overriding Rule #6�� 779 Accessing Overridden Method �� 782 Method Overloading �� 784 Inheritance and Constructors�� 788 Method Hiding�� 796 Field Hiding �� 798 Disabling Inheritance �� 802 Abstract Classes and Methods�� 803 Method Overriding and Generic Method Signatures �� 811 Typo Danger in Method Overriding�� 813 Is-a, has-a, and part-of Relationships�� 814 No Multiple Inheritance of Classes�� 817 Summary�� 817 ■Chapter 21: Interfaces�� 823 What Is an Interface? �� 823 Proposed Solution #1�� 826 Proposed Solution #2�� 827 Proposed Solution #3�� 828 An Ideal Solution�� 828 xxi ■ Contents Declaring an Interface�� 833 Declaring Interface Members�� 834 Constant Fields Declarations�� 834 Methods Declarations�� 836 Nested Type Declarations �� 846 An Interface Defines a New Type�� 848 Implementing an Interface �� 851 Implementing Interface Methods �� 855 Implementing Multiple Interfaces �� 858 Implementing an Interface Partially �� 861 The Supertype-Subtype Relationship�� 863 Interface Inheritance �� 864 The Superinterface-Subinterface Relationship �� 870 Inheriting Conflicting Implementations �� 870 The Superclass Always Wins �� 871 The Most Specific Superinterface Wins�� 873 The Class Must Override the Conflicting Method �� 874 The instanceof Operator�� 875 Marker Interfaces�� 879 Functional Interfaces�� 880 Comparing Objects�� 880 Using the Comparable Interface �� 880 Using the Comparator Interface�� 883 Polymorphism—One Object, Many Views�� 887 Dynamic Binding and Interfaces �� 889 Summary�� 890 ■Chapter 22: Enum Types�� 895 What Is an Enum Type? �� 895 The Superclass of an Enum Type �� 899 xxii ■ Contents Using Enum Types in switch Statements �� 903 Associating Data and Methods to Enum Constants�� 903 Associating a Body to an Enum Constant�� 905 Comparing Two Enum Constants�� 910 Nested Enum Types �� 911 Implementing an Interface to an Enum Type�� 913 Reverse Lookup for Enum Constants �� 914 Range of Enum Constants �� 914 Summary�� 916 ■Chapter 23: Java Shell�� 921 What Is the Java Shell?�� 922 The JShell Architecture �� 923 Starting the JShell Tool �� 924 Exiting the JShell Tool �� 927 What Are Snippets and Commands? �� 927 Evaluating Expressions �� 929 Listing Snippets�� 931 Editing Snippets �� 935 Rerunning Previous Snippets �� 937 Declaring Variables�� 937 Import Statements�� 940 Method Declarations �� 944 Type Declarations�� 945 Setting the Execution Environment�� 948 No Checked Exceptions�� 950 Auto-Completion �� 950 Snippets and Commands History �� 954 Reading JShell Stack Trace�� 955 xxiii ■ Contents Reusing JShell Sessions �� 956 Resetting the JShell State�� 958 Reloading the JShell State �� 958 Configuring JShell�� 961 Setting the Snippet Editor�� 961 Setting Feedback Mode�� 962 Creating Custom feedback Modes�� 965 Setting Up Startup Snippets �� 969 Using JShell Documentation �� 972 The JShell API�� 974 Creating a JShell �� 975 Working with Snippets�� 976 Handling Snippet Events�� 978 An Example�� 978 Summary�� 982 ■Appendix A: Character Encodings �� 985 ASCII�� 986 8-Bit Character Sets�� 990 Universal Multiple-Octet Coded Character Set (UCS) �� 991 UCS-2�� 992 UCS-4�� 992 UTF-16 (UCS Transformation Format 16)�� 992 UTF-8 (UCS Transformation Format 8)�� 993 Java and Character Encodings�� 994 ■Appendix B: Documentation Comments �� 997 Writing Documentation Comments �� 998 List of Block and Inline Tags�� 1000 @author �� 1001 @deprecated �� 1001 @exception �� 1001 @param �� 1002 xxiv ■ Contents @return �� 1002 @see �� 1002 @serial �� 1003 @serialData �� 1004 @serialField

�� 1004 @since �� 1005 @throws �� 1005 @version �� 1006 {@code } �� 1006 {@docRoot}�� 1006 {@inheritDoc}�� 1006 {@link } �� 1008 {@linkplain }�� 1008 {@literal }�� 1008 {@value }�� 1008 @hidden �� 1009 {@index }�� 1009 @provides �� 1010 @uses �� 1010 Documenting Packages�� 1010 com/jdojo/utility/package-info.java file�� 1011 com/jdojo/utility/package.html file�� 1011 Overview Documentation �� 1012 Including Unprocessed Files in Documentation �� 1012 Skipping Source Files Processing �� 1012 An Example of Documentation Comments �� 1012 Running the javadoc Tool �� 1015 Generated Documentation Files �� 1017 Viewing Generated HTML Documentation�� 1017 Searching Javadoc�� 1019 Summary�� 1020 Index�� 1023 xxv About the Author Kishori Sharan works as a senior software engineer lead at IndraSoft, Inc. He earned a master’s of science degree in computer information systems from Troy State University, Alabama. He is a Sun-certified Java 2 programmer and has over 20 years of experience in developing enterprise applications and providing training to professional developers using the Java platform. xxvii About the Technical Reviewer Wallace Jackson has been writing for leading multimedia publications about his work in new media content development since the advent of Multimedia Producer Magazine nearly two decades ago. He has authored a half-dozen Android book titles for Apress, including four titles in the popular Pro Android series. Wallace received his undergraduate degree in business economics from the University of California at Los Angeles and a graduate degree in MIS design and implementation from the University of Southern California. He is currently the CEO of Mind Taffy Design, a new media content production and digital campaign design and development agency. xxix Acknowledgments I would like to thank my family members and friends for their encouragement and support: my mom Pratima Devi; my elder brothers, Janki Sharan and Dr. Sita Sharan; my nephews, Gaurav and Saurav; my sister Ratna; my friends Karthikeya Venkatesan, Rahul Nagpal, Ravi Datla, Mahbub Choudhury, Richard Castillo; and many more friends not mentioned here. My wife, Ellen, was always patient when I spent long hours at my computer desk working on this book. I want to thank her for all of her support in writing this book. My special thanks to my friend Preethi Vasudev for offering her valuable time for providing solutions to the exercises in this book. She likes programming challenges—particularly Google Code Jam. I bet she enjoyed solving the exercises in each chapter of this book. My sincere thanks are due to the wonderful team at Apress for their support during the publication of this book. Thanks to Mark Powers, the Editorial Operations Manager, for providing excellent support. Last but not least, my sincere thanks to Steve Anglin, the Lead Editor at Apress, for taking the initiative for the publication of this book. xxxi Introduction How This Book Came About My first encounter with the Java programming language was during a one-week Java training session in 1997. I did not get a chance to use Java in a project until 1999. I read two Java books and took a Java 2 Programmer certification examination. I did very well on the test, scoring 95 percent. The three questions that I missed on the test made me realize that the books that I had read did not adequately cover details of all the topics necessary about Java. I made up my mind to write a book on the Java programming language. So, I formulated a plan to cover most of the topics that a Java developer needs to use the Java programming language effectively in a project, as well as to get a certification. I initially planned to cover all essential topics in Java in 700 to 800 pages. As I progressed, I realized that a book covering most of the Java topics in detail could not be written in 700 to 800 pages. One chapter alone that covered data types, operators, and statements spanned 90 pages. I was then faced with the question, “Should I shorten the content of the book or include all the details that I think a Java developer needs?” I opted for including all the details in the book, rather than shortening its content to keep the number of pages low. It has never been my intent to make lots of money from this book. I was never in a hurry to finish this book because that rush could have compromised the quality and the coverage of its contents. In short, I wrote this book to help the Java community understand and use the Java programming language effectively, without having to read many books on the same subject. I wrote this book with the plan that it would be a comprehensive one-stop reference for everyone who wants to learn and grasp the intricacies of the Java programming language. One of my high school teachers used to tell us that if one wanted to understand a building, one must first understand the bricks, steel, and mortar that make up the building. The same logic applies to most of the things that we want to understand in our lives. It certainly applies to an understanding of the Java programming language. If you want to master the Java programming language, you must start by understanding its basic building blocks. I have used this approach throughout this book, endeavoring to build each topic by describing the basics first. In the book, you will rarely find a topic described without first learning its background. Wherever possible, I have tried to correlate the programming practices with activities in our daily life. Most of the books about the Java programming language available in the market either do not include any pictures at all or have only a few. I believe in the adage, “A picture is worth a thousand words.” To a reader, a picture makes a topic easier to understand and remember. I have included plenty of illustrations in the book to aid readers in understanding and visualizing the contents. Developers who have little or no programming experience have difficulty in putting things together to make it a complete program. Keeping them in mind, the book contains over 290 complete Java programs that are ready to be compiled and run. I spent countless hours doing research for writing this book. My main source of research was the Java Language Specification, whitepapers, and articles on Java topics, and Java Specification Requests (JSRs). I also spent quite a bit of time reading the Java source code to learn more about some of the Java topics. Sometimes, it took a few months researching a topic before I could write the first sentence on the topic. Finally, it was always fun to play with Java programs, sometimes for hours, to add them to the book. xxxiii ■ Introduction Introduction to the Second Edition I am pleased to present the second edition of the Beginning Java 9 Fundamentals book. It is the first book in the three-volume "Beginning Java 9" series. It was not possible to include all JDK 9 changes in this volume. I have included JDK9-specific changes at appropriate places in three volumes. If you are interested in learning only JDK9-specific topics, I suggest you read my Java 9 Revealed book (ISBN: 978-1484225912), which contains only JDK9-specific topics. There are several changes in this edition and they are as follows. I have added a separate chapter (Chapter 2) on setting up your environment, such as downloading and installing JDK and verifying the JDK version, etc. The most notable change is the introduction to the Module System, which is a new topic in JDK 9. Chapter 3 provides a comprehensive introduction to the Module System. I provide a step-by-step process on how to write, compile, package, and run your first Java program using a command prompt and the NetBeans Integrated Development Environment (NetBeans IDE). Chapter 10 contains an in-depth coverage of the Module System. The second volume in this series delves deeper into the Module System to cover the Module API, Module Layers, etc. JDK 9 ships with a very valuable and exciting tool call the JShell tool (short for Java Shell). It lets you explore the Java programming language interactively by entering chunks for code, rather than writing a full fledged program. I strongly encourage you to use this tool to play with snippets of Java code when you are writing a Java program. I introduced this tool in Chapter 2 and I have covered it extensively in Chapter 23. The reason I did not cover it in one of the first few chapters of the book is because, as a beginner, you need to know the basics of Java programming first. The first edition contained a chapter entitled "Classes and Objects", which was over 120 pages long. This edition has divided this chapter into three chapters titled “Classes,” “Methods,” and “Constructors” (Chapters 7-9). I have added a new section in Chapter 19 that deals with performing operations on arrays. They include how to sort, search, compare, etc., arrays. This section contains all new API changes in JDK 9 dealing with arrays. The previous edition of this book had three appendixes. This edition retains the first two appendixes. I have updated Appendix B to cover new Javadoc features in JDK 9. In the previous edition, Appendix C covered compact profiles, which were introduced in JDK 8. Now you can create a custom runtime image in JDK 9, which makes compact profiles kind of redundant. This made me drop Appendix C in this edition. I cover creating custom runtime uimages in JDK 9 in the third volume of this series. I received several emails from the readers about the fact that the books in this series do not include questions and exercises, which are needed mainly for students and beginners. Students use this book in their Java classes as a Java text book and many beginners use it to learn Java. Based on this popular demand, I spent over 60 hours preparing questions and exercises at the end of each chapter of this book. I still needed a lot more hours to provide the solutions to these exercises. My friend Preethi offered her help and provided the solutions. Apart from these changes, I have updated all chapters, which were part of the first edition. I have edited the contents to make them flow better, changed or added new examples, and updated the contents to include JDK9-specific features. It is my sincere hope that this edition of the book will help you learn Java better. Structure of the Book This book contains 23 chapters and two appendixes. The chapters contain fundamental topics of Java such as syntax, data types, operators, classes, objects, etc. The chapters are arranged in an order that aids learning the Java programming language faster. The first chapter, "Programming Concepts," explains basic concepts related to programming in general, without going into too many technical details; it introduces Java and its features. xxxiv ■ Introduction The third chapter, "Writing Java Programs," introduces the first program using Java; this chapter is especially written for those learning Java for the first time. Subsequent chapters introduce Java topics in an increasing order of complexity. The new features of Java 9 are included wherever they fit in the chapter. After finishing this book, to take your Java knowledge to the next level, two companion books are available by the author: Beginning Java 9 Language Features and Beginning Java 9 APIs, Extensions, and Libraries. At the end of each chapter, you can find questions and exercises that challenge you with the knowledge you gain in the chapter. Questions and exercises are geared toward students taking Java classes and beginners. Answers to all questions and solution to all exercises are available at www.apress.com. Audience This book is designed to be useful to anyone who wants to learn the Java programming language. If you are a beginner, with little or no programming background, you need to read the first chapter to the last, in order. The book contains topics of various degrees of complexity. As a beginner, if you find yourself overwhelmed while reading a section in a chapter, you can skip to the next section or the next chapter and revisit it later when you gain more experience. If you are a Java developer with an intermediate or advanced level of experience, you can jump to a chapter or to a section in a chapter directly. If a section uses an unfamiliar topic, you need to visit that topic before continuing the current one. If you are reading this book to get a certification in the Java programming language, you need to read almost all of the chapters, paying attention to all the detailed descriptions and rules. Most of the certification programs test your fundamental knowledge of the language, not the advanced knowledge. You need to read only those topics that are part of your certification test. Compiling and running over 290 complete Java programs will help you prepare for your certification. If you are a student who is attending a class in the Java programming language, you need to read the first 10 chapters of this book thoroughly. These chapters cover the basics of the Java programming languages in detail. You cannot do well in a Java class unless you first master the basics. After covering the basics, you need to read only those chapters that are covered in your class syllabus. I am sure, you, as a Java student, do not need to read the entire book page-by-page. How to Use This Book This book is the beginning, not the end, for you to gain the knowledge of the Java programming language. If you are reading this book, it means you are heading in the right direction to learn the Java programming language that will enable you to excel in your academic and professional career. However, there is always a higher goal for you to achieve and you must constantly work harder to achieve it. The following quotations from some great thinkers may help you understand the importance of working hard and constantly looking for knowledge with both your eyes and mind open. The learning and knowledge that we have, is, at the most, but little compared with that of which we are ignorant. —Plato True knowledge exists in knowing that you know nothing. And in knowing that you know nothing, that makes you the smartest of all. —Socrates xxxv ■ Introduction Readers are advised to use the API documentation for the Java programming language, as much as possible, while using this book. The Java API documentation is the place where you will find a complete list of documentation for everything available in the Java class library. You can download (or view) the Java API documentation from the official web site of Oracle Corporation at www.oracle.com. While you read this book, you need to practice writing Java programs yourself. You can also practice by tweaking the programs provided in the book. It does not help much in your learning process if you just read this book and do not practice by writing your own programs. Remember that “practice makes perfect,” which is also true in learning how to program in Java. Source Code Source code for this book can be accessed by clicking the Download Source Code button located at www.apress.com/9781484228432. Questions and Comments Please direct all your questions and comments for the author to [email protected]. xxxvi CHAPTER 1 Programming Concepts In this chapter, you will learn: • The general concept of programming • Different components of programming • Major programming paradigms • What the object-oriented paradigm is and how it is used in Java What Is Programming? The term “programming” is used in many contexts. We discuss its meaning in the context of human-to computer interaction. In the simplest terms, programming is the way of writing a sequence of instructions to tell a computer to perform a specific task. The sequence of instructions for a computer is known as a program. A set of well-defined notations is used to write a program. The set of notations used to write a program is called a programming language. The person who writes a program is called a programmer. A programmer uses a programming language to write a program. How does a person tell a computer to perform a task? Can a person tell a computer to perform any task or does a computer have a predefined set of tasks that it can perform? Before we look at human-to-computer communication, let’s look at human-to-human communication. How does a human communicate with another human? You would say that human-to-human communication is accomplished using a spoken language, for example, English, German, Hindi, etc. However, spoken language is not the only means of communication between humans. We also communicate using written languages or using gestures without uttering any words. Some people can even communicate sitting miles away from each other without using any words or gestures; they can communicate at the thought level. To have a successful communication, it is not enough just to use a medium of communication like a spoken or written language. The main requirement for a successful communication between two parties is the ability of both parties to understand what is communicated from the other party. For example, suppose there are two people. One person knows how to speak English and the other one knows how to speak German. Can they communicate with each other? The answer is no, because they cannot understand each other’s language. What happens if we add an English-German translator between them? We would agree that they would be able to communicate with the help of a translator even though they do not understand each other directly? Computers understand instructions only in binary format, which is a sequence of 0s and 1s. The sequence of 0s and 1s, which all computers understand, is called machine language or machine code. A computer has a fixed set of basic instructions that it understands. Each computer has its own set of instructions. For example, one computer may use 0010 as an instruction to add two numbers, whereas another computer may use 0101 for the same purpose. Therefore, programs written in machine language © Kishori Sharan 2017 1 K. Sharan, Beginning Java 9 Fundamentals, https://doi.org/10.1007/978-1-4842-2902-6_1 Chapter 1 ■ Programming Concepts are machine-dependent. Sometimes machine code is referred to as native code as it is native to the machine for which it is written. Programs written in machine language are very difficult, if not impossible, to write, read, understand, and modify. Suppose you want to write a program that adds two numbers, 15 and 12. The program to add two numbers in machine language will look similar to the one shown here. You do not need to understand the sample code written in this section. It is only for the purpose of discussion and illustration. 0010010010 10010100000100110 0001000100 01010010001001010 These instructions are to add two numbers. How difficult will it be to write a program in machine language to perform a complex task? Based on this code, you may now realize that it is very difficult to write, read, and understand a program written in a machine language. But aren’t computers supposed to make our jobs easier, not more difficult? We needed to represent the instructions for computers in some notations that were easier to write, read, and understand, so computer scientists came up with another language called an assembly language. An assembly language provides different notations to write instructions. It is little easier to write, read, and understand than its predecessor, machine language. An assembly language uses mnemonics to represent instructions as opposed to the binary (0s and 1s) used in machine language. A program written in an assembly language to add two numbers looks similar to the following: li $t1, 15 add $t0, $t1, 12 If you compare the two programs written in the two different languages to perform the same task, you can see that assembly language is easier to write, read, and understand than machine code. There is one to-one correspondence between an instruction in machine language and assembly language for a given computer architecture. Recall that a computer understands instructions only in machine language. The instructions that are written in an assembly language must be translated into machine language before the computer can execute them. A program that translates the instructions written in an assembly language into machine language is called an assembler. Figure 1-1 shows the relationship between assembly code, an assembler, and machine code. A program in assembly language A program in machine language Input Assembler Output Figure 1-1. The relationship between assembly code, assembler, and machine code Machine and assembly languages are also known as low-level languages because a programmer must understand the low-level details of the computer to write a program using these languages. For example, if you were writing programs in these languages, you would need to know what memory location you are writing to or reading from, which register to use to store a specific value, etc. Soon programmers realized a need for a higher-level programming language that could hide the low-level details of computers from them. The need gave rise to the development of high-level programming languages like COBOL, Pascal, FORTRAN, C, C++, Java, C#, etc. The high-level programming languages use English-like words, mathematical notation, and punctuation to write programs. A program written in a high-level programming language is also called 2 Chapter 1 ■ Programming Concepts source code. They are closer to the written languages that humans are familiar with. The instructions to add two numbers can be written in a high-level programming language, for example, Java looks similar to the following: int x = 15 + 12; You may notice that the programs written in a high-level language are easier and more intuitive to write, read, understand, and modify than the programs written in machine and assembly languages. You might have realized that computers do not understand programs written in high-level languages, as they understand only sequences of 0s and 1s. So there’s a need for a way to translate a program written in a high-level language to machine language. The translation is accomplished by a compiler, an interpreter, or a combination of both. A compiler is a program that translates programs written in a high-level programming language into machine language. Compiling a program is an overloaded phrase. Typically, it means translating a program written in a high-level language into machine language. Sometimes it is used to mean translating a program written in a high-level programming language into a lower-level programming language, which is not necessarily the machine language. The code that is generated by a compiler is called compiled code. The compiled program is executed by the computer. Another way to execute a program written in high-level programming language is to use an interpreter. An interpreter does not translate the whole program into machine language at once. Rather, it reads one instruction written in a high-level programming language at a time, translates it into machine language, and executes it. You can view an interpreter as a simulator. Sometimes a combination of a compiler and an interpreter may be used to compile and run a program written in a high-level language. For example, a program written in Java is compiled into an intermediate language called bytecode. An interpreter, specifically called a Java Virtual Machine (JVM) for the Java platform, is used to interpret the bytecode and execute it. An interpreted program runs slower than a compiled program. Most of the JVMs today use just-in-time compilers (JIT), which compile the entire Java program into machine language as needed. Sometimes another kind of compiler, which is called an ahead-of-time (AOT) compiler, is used to compile a program in an intermediate language (e.g., Java bytecode) to machine language. Figure 1-2 shows the relationship between the source code, a compiler, and the machine code. A program in Source Code Input Compiler Output Figure 1-2. The relationship between source code, a compiler, and machine code intermediate or machine language Programming languages are also categorized as first, second, third, and fourth generation languages. The higher the generation of the language, the closer it gets to the plain spoken human language to write programs in that language. The machine language is also known as first generation programming language or 1GL. The assembly language is also known as second generation programming language or 2GL. High level procedural programming languages such as C, C++, Java, and C#, in which you have to write the algorithm to solve the problem using the language syntax, are also known as third generation programming languages or 3GL. High-level non-procedural programming languages, in which you do not need to write the algorithm to solve a program, are known as fourth generation programming languages or 4GL. Structured Query Language (SQL) is the most widely used 4GL programming language, which is used to communicate with databases. 3 Chapter 1 ■ Programming Concepts Components of a Programming Language A programming language is a system of notations used to write instructions for computers. It can be described using three components: • Syntax • Semantics • Pragmatics The syntax part deals with forming valid programming constructs using available notations. The semantics part deals with the meaning of the programming constructs. The pragmatics part deals with the use of the programming language in practice. Like a written language (e.g., English), a programming language has vocabulary and grammar. The vocabulary of a programming language consists of a set of words, symbols, and punctuation marks. The grammar of a programming language defines rules on how to use the vocabulary of the language to form valid programming constructs. You can think of a valid programming construct in a programming language like a sentence in a written language, which is formed using the vocabulary and grammar of the language. Similarly, a programming construct is formed using the vocabulary and the grammar of the programming language. The vocabulary and the rules to use that vocabulary to form valid programming constructs are known as the syntax of the programming language. In a written language, you may form a grammatically correct sentence, which may not have any valid meaning. For example, “The stone is laughing.” is a grammatically correct sentence. However, it does not make any sense. In a written language, this kind of ambiguity is allowed. A programming language is meant to communicate instructions to computers, which have no room for any ambiguity. We cannot communicate with computers using ambiguous instructions. There is another component of a programming language, which is called semantics, which explain the meaning of the syntactically valid programming constructs. The semantics of a programming language answer the question, “What does this program do when it is run on a computer?” Note that a syntactically valid programming construct may not also be semantically valid. A program must be syntactically and semantically correct before it can be executed by a computer. The pragmatics of a programming language describe its uses and its effects on the users. A program written in a programming language may be syntactically and semantically correct. However, it may not be easily understood by other programmers. This aspect is related to the pragmatics of the programming language. The pragmatics are concerned with the practical aspect of a programming language. It answers questions about a programming language like its ease of implementation, suitability for a particular application, efficiency, portability, support for programming methodologies, etc. Programming Paradigms The online Merriam-Webster’s Learner’s dictionary defines the word “paradigm” as follows: “A paradigm is a theory or a group of ideas about how something should be done, made, or thought about.” In the beginning, it is a little hard to understand the word “paradigm” in a programming context. Programming is about providing a solution to a real-world problem using computational models supported by the programming language. The solution is called a program. Before we provide a solution to a problem in the form of a program, we always have a mental view of the problem and its solution. Before I discuss how to solve a real-world problem using a computational model, let’s take an example of a real-world social problem, one that has nothing to do with computers. 4 Chapter 1 ■ Programming Concepts Suppose there is a place on Earth that has a shortage of food. People in that place do not have enough food to eat. The problem is “shortage of food.” Let’s ask three people to provide a solution to this problem. The three people are a politician, a philanthropist, and a monk. A politician will have a political view about the problem and its solution. He may think about it as an opportunity to serve his countrymen by enacting some laws to provide food to the hungry people. A philanthropist will offer some money/food to help those hungry people because he feels compassion for all humans and so for those hungry people. A monk will try to solve this problem using his spiritual views. He may preach to them to work and make livings for themselves; he may appeal to rich people to donate food to the hungry; or he may teach them yoga to conquer their hunger! Did you see how three people have different views about the same reality, which is “shortage of food”? The ways they look at the reality are their paradigms. You can think of a paradigm as a mindset with which a reality is viewed in a particular context. It is usual to have multiple paradigms, which let one view the same reality differently. For example, a person who is a philanthropist and politician will have his ability to view the “shortage of food” problem and its solution differently, once with his political mindset and once with his philanthropist mindset. Three people were given the same problem. All of them provided a solution to the problem. However, their perceptions about the problem and its solution were not the same. We can define the term paradigm as a set of concepts and ideas that constitutes a way of viewing a reality. Why do we need to bother about a paradigm anyway? Does it matter if a person used his political, philanthropical, or spiritual paradigm to arrive at the solution? Eventually we get a solution to our problem. Don’t we? It is not enough just to have a solution to a problem. The solution must be practical and effective. Since the solution to a problem is always related to the way the problem and the solution are thought about, the paradigm becomes paramount. You can see that the solution provided by the monk may kill the hungry people before they can get any help. The philanthropist’s solution may be a good short-term solution. The politician’s solution seems to be a long-term solution and the best one. It is always important to use the right paradigm to solve a problem to arrive at a practical and the most effective solution. Note that one paradigm cannot be the right paradigm to solve every kind of problem. For example, if a person is seeking eternal happiness, he needs to consult a monk, not a politician or a philanthropist. Here is a definition of the term “programming paradigm” by Robert W. Floyd, who was a prominent computer scientist. He gave this definition in his 1978 ACM Turing Award lecture titled “The Paradigms of Programming.” “A programming paradigm is a way of conceptualizing what it means to perform computation, and how tasks that are to be carried out on a computer should be structured and organized.” You can observe that the word “paradigm” in a programming context has a similar meaning to that used in the context of daily life. Programming is used to solve a real-world problem using computational models provided by a computer. The programming paradigm is the way you think and conceptualize about the real-world problem and its solution in the underlying computational models. The programming paradigm comes into the picture well before you start writing a program using a programming language. It is in the analysis phase when you use a particular paradigm to analyze a problem and its solution in a particular way. A programming language provides a means to implement a particular programming paradigm suitably. A programming language may provide features that make it suitable for programming using one programming paradigm and not the other. 5 Chapter 1 ■ Programming Concepts A program has two components—data and algorithm. Data is used to represent pieces of information. An algorithm is a set of steps that operates on data to arrive at a solution to a problem. Different programming paradigms involve viewing the solution to a problem by combining data and algorithms in different ways. Many paradigms are used in programming. The following are some commonly used programming paradigms: • Imperative paradigm • Procedural paradigm • Declarative paradigm • Functional paradigm • Logic paradigm • Object-oriented paradigm Imperative Paradigm The imperative paradigm is also known as an algorithmic paradigm. In the imperative paradigm, a program consists of data and an algorithm (sequence of commands) that manipulates the data. The data at a particular point in time defines the state of the program. The state of the program changes as the commands are executed in a specific sequence. The data is stored in memory. Imperative programming languages provide variables to refer to the memory locations, an assignment operation to change the value of a variable, and other constructs to control the flow of a program. In imperative programming, you need to specify the steps to solve a problem. Suppose you have an integer, say 15, and you want to add 10 to it. Your approach would be to add 1 to 15 10 times and you get the result, 25. You can write a program using an imperative language to add 10 to 15, as follows. Note that you do not need to understand the syntax of the following code; just try to get the feeling of it. int num = 15; // num holds 15 at this point int counter = 0; // counter holds 0 at this point while (counter < 10) { num = num + 1; // Modifying data in num counter = counter + 1; // Modifying data in counter } // num holds 25 at this point The first two lines are variable declarations that represent the data part of the program. The while loop represents the algorithm part of the program that operates on the data. The code inside the while loop is executed 10 times. The loop increments the data stored in the num variable by 1 in its each iteration. When the loop ends, it has incremented the value of num by 10. Note that data in imperative programming is transient and the algorithm is permanent. FORTRAN, COBOL, and C are a few examples of programming languages that support the imperative paradigm. Procedural Paradigm The procedural paradigm is similar to the imperative paradigm with one difference: it combines multiple commands in a unit called a procedure. A procedure is executed as a unit. Executing the commands contained in a procedure is known as calling or invoking the procedure. A program in a procedural language 6 Chapter 1 ■ Programming Concepts consists of data and a sequence of procedure calls that manipulate the data. The following piece of code is typical for a procedure named addTen: void addTen(int num) { int counter = 0; while (counter < 10) { num = num + 1; // Modifying data in num counter = counter + 1; // Modifying data in counter } // num has been incremented by 10 } The addTen procedure uses a placeholder (also known as parameter) num, which is supplied at the time of its execution. The code ignores the actual value of num. It simply adds 10 to the current value of num. Let’s use the following piece of code to add 10 to 15. Note that the code for addTen procedure and the following code are not written using any specific programming language. They are provided here only for the purpose of illustration. int x = 15; // x holds 15 at this point addTen(x); // Call addTen procedure that will increment x by 10 // x holds 25 at this point You may observe that the code in imperative paradigm and procedural paradigm are similar in structure. Using procedures results in modular code and increases reusability of algorithms. Some people ignore this difference and treat the two paradigms, imperative and procedural, as the same. Note that even if they are different, a procedural paradigm always involves the imperative paradigm. In the procedural paradigm, the unit of programming is not a sequence of commands. Rather, you abstract a sequence of commands into a procedure and your program consists of a sequence of procedures instead. A procedure has side effects. It modifies the data part of the program as it executes its logic. C, C++, Java, and COBOL are a few examples of programming languages that support the procedural paradigm. Declarative Paradigm In the declarative paradigm, a program consists of the description of a problem and the computer finds the solution. The program does not specify how to arrive at the solution to the problem. It is the computer’s job to arrive at a solution when a problem is described to it. Contrast the declarative paradigm with the imperative paradigm. In the imperative paradigm, we are concerned about the “how” part of the problem. In the declarative paradigm, we are concerned about the “what” part of the problem. We are concerned about what the problem is, rather than how to solve it. The functional paradigm and the logic paradigm, which are described next, are subtypes of the declarative paradigm. Writing a database query using a structured query language (SQL) falls under programming based on the declarative paradigm, where you specify what data you want and the database engine figures out how to retrieve the data for you. Unlike the imperative paradigm, the data is permanent and the algorithm is transient in the declarative paradigm. In the imperative paradigm, the data is modified as the algorithm is executed. In the declarative paradigm, data is supplied to the algorithm as input and the input data remains unchanged as the algorithm is executed. The algorithm produces new data rather than modifying the input data. In other words, in the declarative paradigm, execution of an algorithm does not produce side effects. 7 Chapter 1 ■ Programming Concepts Functional Paradigm The functional paradigm is based on the concept of mathematical functions. You can think of a function as an algorithm that computes a value from some given inputs. Unlike a procedure in procedural programming, a function does not have a side effect. In functional programming, values are immutable. A new value is derived by applying a function to the input value. The input value does not change. Functional programming languages do not use variables and assignments, which are used for modifying data. In imperative programming, a repeated task is performed using a loop construct, for example, a while loop. In functional programming, a repeated task is performed using recursion, which is a way in which a function is defined in terms of itself. In other words, a recursive function does some work, then calls itself. A function always produces the same output when it is applied to the same input. A function, say add, that can be applied to an integer x to add an integer n to it may be defined as follows: int add(x, n) { if (n == 0) { return x; } else { return 1 + add(x, n-1); // Apply the add function recursively } } Note that the add function does not use any variable and does not modify any data. It uses recursion. You can call the add function to add 10 to 15, as follows: add(15, 10); // Results in 25 Haskell, Erlang, and Scala are a few examples of programming languages that support the functional paradigm. ■ Tip Java SE 8 added a new language construct called lambda expressions, which can be used to write functional programming style code in Java. Logic Paradigm Unlike the imperative paradigm, the logic paradigm focuses on the “what” part of the problem rather than how to solve it. All you need to specify is what needs to be solved. The program will figure out the algorithm to solve it. The algorithm is of less importance to the programmer. The primary task of the programmer is to describe the problem as closely as possible. In the logic paradigm, a program consists of a set of axioms and a goal statement. The set of axioms is the collection of facts and inference rules that make up a theory. The goal statement is a theorem. The program uses deductions to prove the theorem within the theory. Logic programming uses a mathematical concept called a relation from set theory. A relation in set theory is defined as a subset of the Cartesian product of two or more sets. Suppose there are two sets, Persons and Nationality, defined as follows: Person = {John, Li, Ravi} Nationality = {American, Chinese, Indian} 8 Chapter 1 ■ Programming Concepts The Cartesian product of the two sets, denoted as Person x Nationality, would be another set, as shown: Person x Nationality = {{John, American}, {John, Chinese}, {John, Indian}, {Li, American}, {Li, Chinese}, {Li, Indian}, {Ravi, American}, {Ravi, Chinese}, {Ravi, Indian}} Every subset of Person x Nationality is another set that defines a mathematical relation. Each element of a relation is called a tuple. Let PersonNationality be a relation defined as follows: PersonNationality = {{John, American}, {Li, Chinese}, {Ravi, Indian}} In logic programming, you can use the PersonNationality relation as the collection of facts that is known to be true. You can state the goal statement (or the problem) like so PersonNationality(?, Chinese) which means “give me all names of people who are Chinese.” The program will search through the PersonNationality relation and extract the matching tuples, which will be the answer (or the solution) to your problem. In this case, the answer will be Li. Prolog is an example of a programming language that supports the logic paradigm. Object-Oriented Paradigm In the object-oriented (OO) paradigm, a program consists of interacting objects. An object encapsulates data and algorithms. Data defines the state of an object. Algorithms define the behavior of an object. An object communicates with other objects by sending messages to them. When an object receives a message, it responds by executing one of its algorithms, which may modify its state. Contrast the object-oriented paradigm with the imperative and functional paradigms. In the imperative and functional paradigms, data and algorithms are separated, whereas in the object-oriented paradigm, data and algorithms are not separate; they are combined in one entity, which is called an object. Classes are the basic units of programming in the object-oriented paradigm. Similar objects are grouped into one definition called a class. A class’ definition is used to create an object. An object is also known as an instance of the class. A class consists of instance variables and methods. The values of instance variables of an object define the state of the object. Different objects of a class maintain their states separately. That is, each object of a class has its own copy of the instance variables. The state of an object is kept private to that object. That is, the state of an object cannot be accessed or modified directly from outside the object. Methods in a class define the behavior of its objects. A method is like a procedure (or subroutine) in the procedural paradigm. Methods can access/modify the state of the object. A message is sent to an object by invoking one of its methods. Suppose you want to represent real-world people in your program. You will create a Person class and its instances will represent people in your program. The Person class can be defined as shown in Listing 1-1. This example uses the syntax of the Java programming language. You do not need to understand the syntax used in the programs that you are writing at this point; I discuss the syntax to define classes and create objects in subsequent chapters. 9 Chapter 1 ■ Programming Concepts Listing 1-1. The Definition of a Person Class Whose Instances Represent Real-World Persons in a Program package com.jdojo.concepts; public class Person { private String name; private String gender; public Person(String initialName, String initialGender) { name = initialName; gender = initialGender; } public String getName() { return name; } public void setName(String newName) { name = newName; } public String getGender() { return gender; } } The Person class includes three things: • Two instance variables: name and gender • One constructor: Person(String initialName, String initialGender) • Three methods: getName(), setName(String newName), and getGender() Instance variables store internal data for an object. The value of each instance variable represents the value of a corresponding property of the object. Each instance of the Person class will have a copy of name and gender data. The values of all properties of an object at a point in time (stored in instance variables) collectively define the state of the object at that time. In the real world, a person possesses many properties, for example, name, gender, height, weight, hair color, addresses, phone numbers, etc. However, when you model the real-world person as a class, you include only those properties of the person that are relevant to the system being modeled. For this current demonstration, let’s model only two properties—name and gender—of a real-world person as two instance variables in the Person class. A class contains the definition (or blueprint) of objects. There needs to be a way to construct (to create or to instantiate) objects of a class. An object also needs to have the initial values for its properties that will determine its initial state at the time of its creation. A constructor of a class is used to create an object of that class. A class can have many constructors to facilitate the creation of its objects with different initial states. The Person class provides one constructor, which lets you create its object by specifying the initial values for name and gender. The following snippet of code creates two objects of the Person class: Person john = new Person("John Jacobs", "Male"); Person donna = new Person("Donna Duncan", "Female"); The first object is called john with "John Jacobs" and "Male" as the initial values for its name and gender properties, respectively. The second object is called donna with "Donna Duncan" and "Female" as the initial values for its name and gender properties, respectively. 10 Chapter 1 ■ Programming Concepts Methods of a class represent behaviors of its objects. For example, in the real world, a person has a name and his ability to respond when he is asked for his name is one of his behaviors. Objects of the Person class have abilities to respond to three different messages: getName, setName, and getGender. The ability of an object to respond to a message is implemented using methods. You can send a message, say getName, to a Person object and it will respond by returning its name. It is the same as asking “What is your name?” and having the person respond by telling you his name. String johnName = john.getName(); // Send getName message to john String donnaName = donna.getName(); // Send getName message to donna The setName message to the Person object asks him to change his current name to a new name. The following snippet of code changes the name of the donna object from "Donna Duncan" to "Donna Jacobs": donna.setName("Donna Jacobs"); If you send the getName message to donna object at this point, it will return "Donna Jacobs", not "Donna Duncan". You may notice that your Person objects do not have the ability to respond to a message, such as setGender. The gender of Person object is set when the object is created and it cannot be changed afterwards. However, you can query the gender of a Person object by sending the getGender message to it. What messages an object may (or may not) respond to is decided at design-time based on the need of the system being modeled. In the case of the Person objects, we decided that they would not have the ability to respond to the setGender message by not including a setGender(String newGender) method in the Person class. Figure 1-3 shows the state and interface of the Person object called john. A Person object Interface of a Person object getName setName getGender name John Jacobs gender Male State of a Person object Figure 1-3. The state and the interface for a Person object The object-oriented paradigm is a very powerful paradigm for modeling real-world phenomena in a computational model. We are used to working with objects all around us in our daily life. The object oriented paradigm is natural and intuitive, as it lets you think in terms of objects. However, it does not give you the ability to think in terms of objects correctly. Sometimes, the solution to a problem does not fall into the domain of an object-oriented paradigm. In such cases, you need to use the paradigm that suits the problem domain the most. The object-oriented paradigm has a learning curve. It is much more than just creating and using objects in your program. Abstraction, encapsulation, polymorphism, and inheritance are some of the important features of the object-oriented paradigm. You must understand and be able to use these features to take full advantage of the object-oriented paradigm. I discuss these features in the sections to follow. In subsequent chapters, I discuss these features and how to implement them in programs in detail. 11 Chapter 1 ■ Programming Concepts To name a few, C++, Java and C# (pronounced “C sharp”) are programming languages that support the object-oriented paradigm. Note that a programming language itself is not object-oriented. It is the paradigm that is object-oriented. A programming language may or may not have features to support the object oriented paradigm. What Is Java? Java is a general purpose programming language. It has features to support programming based on the object-oriented, procedural, and functional paradigms. You often read a phrase like “Java is an object oriented programming language.” What is meant is that the Java language has features that support the object-oriented paradigm. A programming language is not object-oriented. It is the paradigm that is object-oriented, and a programming language may have features that make it easy to implement the object oriented paradigm. Sometimes, programmers have misconceptions that all programs written in Java are always object-oriented. Java also has features that support the procedural and functional paradigms. You can write a program in Java that is a 100% procedural program without an iota of object-orientedness in it. The initial version of the Java platform was released by Sun Microsystems (part of Oracle Corporation since January 2010) in 1995. Development of the Java programming language was started in 1991. Initially, the language was called Oak and it was meant to be used in set-top boxes for televisions. Soon after its release, Java became a very popular programming language. One of the most important features for its popularity was its “write once, run anywhere” (WORA) feature. This feature lets you write a Java program once and run it on any platform. For example, you can write and compile a Java program on UNIX and run it on Microsoft Windows, Macintosh, or UNIX machine without any modifications to the source code. WORA is achieved by compiling a Java program into an intermediate language called bytecode. The format of bytecode is platform-independent. A virtual machine, called the Java Virtual Machine (JVM), is used to run the bytecode on each platform. Note that JVM is a program implemented in software. It is not a physical machine and this is the reason it is called a “virtual” machine. The job of a JVM is to transform the bytecode into executable code according to the platform it is running on. This feature makes Java programs platform independent. That is, the same Java program can be run on multiple platforms without any modifications. The following are a few characteristics behind Java’s popularity and acceptance in the software industry: • Simplicity • Wide variety of usage environments • Robustness Simplicity may be a subjective word in this context. C++ was the popular and powerful programming language widely used in the software industry at the time Java was released. If you were a C++ programmer, Java would provide simplicity for you in its learning and use over the C++ experience you had. Java retained most of the syntax of C/C++, which was helpful for C/C++ programmers trying to learn this new language. Even better, it excluded some of the most confusing and hard-to-use-correctly features (though powerful) of C++. For example, Java does not have pointers and multiple inheritance, which are present in C++. If you are learning Java as your first programming language, whether it is a simple language to learn may not be true for you. This is the reason why I said that the simplicity of Java or any programming language is very subjective. The Java language and its libraries (a set of packages containing Java classes) have been growing ever since its first release. You will need to put in some serious effort in order to become a serious Java developer. Java can be used to develop programs that can be used in different environments. You can write programs in Java that can be used in a client-server environment. The most popular use of Java programs in its early days was to develop applets, which have been deprecated in Java SE 9. An applet is a Java program that is embedded in a web page, which uses the HyperText Markup Language (HTML), and is displayed in a web browser such as Microsoft Internet Explorer, Google Chrome, etc. An applet’s code is stored on a web server, downloaded to the client machine when the HTML page containing the reference to the applet is loaded by the browser, and run on the client machine. 12 Chapter 1 ■ Programming Concepts Java includes features that make it easy to develop distributed applications. A distributed application consists of programs running on different machines connected through a network. Java has features that make it easy to develop concurrent applications. A concurrent application has multiple interacting threads of execution running in parallel. I discuss these features of the Java platform in detail in subsequent chapters in this book. Robustness of a program refers to its ability to handle unexpected situations reasonably. The unexpected situation in a program is also known as an error. Java provides robustness by providing many features for error checking at different points during a program’s lifetime. The following are three different types of errors that may occur in a Java program: • Compile-time errors • Runtime errors • Logic errors Compile-time errors are also known as syntax errors. They are caused by incorrect use of the Java language syntax. They are detected by the Java compiler. A program with compile-time errors does not compile into bytecode until the errors are corrected. Missing a semicolon at the end of a statement, assigning a decimal value such as 10.23 to a variable of integer type, etc., are examples of compile-time errors. Runtime errors occur when a Java program is run. This kind of error is not detected by the compiler because a compiler does not have all of the runtime information available to it. Java is a strongly typed language and it has a robust type checking at compile time as well as runtime. Java provides a neat exception handling mechanism to handle runtime errors. When a runtime error occurs in a Java program, the JVM throws an exception, which the program may catch and deal with. For example, dividing an integer by zero (e.g., 17/0) generates a runtime error. Java avoids critical runtime errors, such as memory overrun and memory leaks, by providing a built-in mechanism for automatic memory allocation and deallocation. The feature of automatic memory deallocation is known as garbage collection. Logic errors are the most critical errors in a program, and they are hard to find. They are introduced by the programmer by implementing the functional requirements incorrectly. This kind of error cannot be detected by a Java compiler or Java runtime. They are detected by application testers or users when they compare the actual behavior of a program with its expected behavior. Sometimes, a few logic errors can sneak into the production environment and they go unnoticed even after the application is decommissioned. An error in a program is known as a bug. The process of finding and fixing bugs in a program is known as debugging. All modern integrated development environments (IDEs) such as NetBeans, Eclipse, JDeveloper, and IntelliJ IDEA provide programmers with a tool called a debugger, which lets them run the program step-by-step and inspect the program’s state at every step to detect the bug. Debugging is a reality of programmer’s daily activities. If you want to be a good programmer, you must learn and be good at using the debuggers that come with the development tools that you use to develop your Java programs. The Object-Oriented Paradigm and Java The object-oriented paradigm supports four major principles: abstraction, encapsulation, inheritance, and polymorphism. They are also known as four pillars of the object-oriented paradigm. Abstraction is the process of exposing the essential details of an entity, while ignoring the irrelevant details, to reduce the complexity for the users. Encapsulation is the process of bundling data and operations on the data together in an entity. Inheritance is used to derive a new type from an existing type, thereby establishing a parent child relationship. Polymorphism lets an entity take on different meanings in different contexts. The four principles are discussed in detail in the sections to follow. 13 Chapter 1 ■ Programming Concepts Abstraction A program provides a solution to a real-world problem. The size of the program may range from a few lines to a few million lines. It may be written as a monolithic structure running from the first line to the millionth line in one place. A monolithic program becomes harder to write, understand, and maintain if its size is over 25 to 50 lines. For easier maintenance, a big monolithic program must be decomposed into smaller subprograms. The subprograms are then assembled together to solve the original problem. Care must be taken when a program is being decomposed. All subprograms must be simple and small enough to be understood by themselves, and when assembled, they must solve the original problem. Let’s consider the following requirement for a device: Design and develop a device that will let the users type text using all English letters, digits, and symbols. One way to design such a device is to provide a keyboard that has keys for all possible combinations of all letters, digits, and symbols. This solution is not reasonable as the size of the device will be huge. You may realize that we are talking about designing a keyboard. Look at your keyboard and see how it has been designed. It has broken down the problem of typing text into typing a letter, a digit, or a symbol one at a time, which represents the smaller part of the original problem. If you can type all letters, all digits, and all symbols one at a time, you can type text of any length. Another decomposition of the original problem may include two keys: one to type a horizontal line and another to type a vertical line, which a user can use to type in E, T, I, F, H, and L because these letters consist of only horizontal and vertical lines. With this solution, a user can type six letters using the combination of just two keys. However, with your experience using keyboards, you may realize that decomposing the keys so that a key can be used to type in only part of a letter is not a reasonable solution, although it is a solution. Why is providing two keys to type six letters not a reasonable solution? Aren’t we saving space and number of keys on the keyboard? The use of the phrase “reasonable” is relative in this context. From a purist point of view, it may be a reasonable solution. My reasoning behind calling it “not reasonable” is that it is not easily understood by users. It exposes more details to the users than needed. A user would have to remember that the horizontal line is placed at the top for T and at bottom for L. When a user gets a separate key for each letter, he does not have to deal with these details. It is important that the subprograms that provide solutions to parts of the original problem must be simplified to have the same level of detail to work together seamlessly. At the same time, a subprogram should not expose details that are not necessary for someone to know in order to use it. Finally, all keys are mounted on a keyboard and they can be replaced separately. If a key is broken, it can be replaced without worrying about other keys. Similarly, when a program is decomposed into subprograms, a modification in a subprogram should not affect other subprograms. Subprograms can also be further decomposed by focusing on a different level of detail and ignoring other details. A good decomposition of a program aims at providing the following characteristics: • Simplicity • Isolation • Maintainability Each subprogram should be simple enough to be understood by itself. Simplicity is achieved by focusing on the relevant pieces of information and ignoring the irrelevant ones. What pieces of information are relevant and what are irrelevant depends on the context. Each subprogram should be isolated from other subprograms so that any changes in a subprogram should have localized effects. A change in one subprogram should not affect any other subprograms. A subprogram defines an interface to interact with other subprograms. The inner details about the subprogram are hidden from the outside world. As long as the interface for a subprogram remains unchanged, the changes in its inner details should not affect the other subprograms that interact with it. 14 Chapter 1 ■ Programming Concepts Each subprogram should be small enough to be written, understood, and maintained easily. All of these characteristics are achieved during decomposition of a problem (or program that solves a problem) using a process called abstraction. Abstraction is a way to perform decomposition of a problem by focusing on relevant details and ignoring the irrelevant details about it in a particular context. Note that no details about a problem are irrelevant. In other words, every detail about a problem is relevant. However, some details may be relevant in one context and some in another. It is important to note that it is the “context” that decides what details are relevant and what are irrelevant. For example, consider the problem of designing and developing a keyboard. For a user’s perspective, a keyboard consists of keys that can be pressed and released to type text. Number, type, size, and position of keys are the only details that are relevant to the users of a keyboard. However, keys are not the only details about a keyboard. A keyboard has an electronic circuit and it is connected to a computer. A lot of things occur inside the keyboard and the computer when a user presses a key. The internal workings of a keyboard are relevant to keyboard designers and manufacturers. However, they are irrelevant to the users of a keyboard. You can say that different users have different views of the same thing in different contexts. What details about the thing are relevant and what are irrelevant depends on the user and the context. Abstraction is about considering details that are necessary to view the problem in the way that is appropriate in a particular context and ignoring (hiding or suppressing or forgetting) the details that are unnecessary. Terms like “hiding” and “suppressing” in the context of abstraction may be misleading. These terms may mean hiding some details of a problem. Abstraction is concerned with which details of a thing should be considered and which should not for a particular purpose. It does imply hiding of the details. How things are hidden is another concept called information hiding, which is discussed in the following section. The term “abstraction” is used to mean one of the two things: a process or an entity. As a process, it is a technique to extract relevant details about a problem and ignore the irrelevant details. As an entity, it is a particular view of a problem that considers some relevant details and ignores the irrelevant details. Abstraction for Hiding Complexities Let’s discuss the application of abstraction in real-world programming. Suppose you want to write a program that will compute the sum of all integers between two integers. Suppose you want to compute the sum of all integers between 10 and 20. You can write the program as follows. Do not worry if you do not understand the syntax used in programs in this section; just try to grasp the big picture of how abstraction is used to decompose a program. int sum = 0; int counter = 10; while (counter <= 20) { sum = sum + counter; counter = counter + 1; } System.out.println(sum); This snippet of code will add 10 + 11 + 12 + … + 20 and print 165. Suppose you want to compute sum of all integers between 40 and 60. Here is the program to achieve just that: int sum = 0; int counter = 40; while (counter <= 60) { sum = sum + counter; counter = counter + 1; } System.out.println(sum); 15 Chapter 1 ■ Programming Concepts This snippet of code will perform the sum of all integers between 40 and 60, and it will print 1050. Note the similarities and differences between the two snippets of code. The logic is the same in both. However, the lower and upper limits of the range are different. If you can ignore the differences that exist between the two snippets of code, you will be able to avoid the duplicating of logic in two places. Let’s consider the following snippet of code: int sum = 0; int counter = lowerLimit; while (counter <= upperLimit) { sum = sum + counter; counter = counter + 1; } System.out.println(sum); This time, you did not use any actual values for the lower and upper limits of any range. Rather, you used lowerLimit and upperLimit placeholders that are not known at the time the code is written. By using two placeholders in your code, you are hiding the identity of the lower and upper limits of the range. In other words, you are ignoring their actual values when writing this piece of code. You have applied the process of abstraction in the code by ignoring the actual values of the lower and upper limits of the range. When this piece of code is executed, the actual values must be substituted for lowerLimit and upperLimit placeholders. This is achieved in a programming language by packaging the snippet of code inside a module (subroutine or subprogram) called a procedure. The placeholders are defined as formal parameters of that procedure. Listing 1-2 has the code for such a procedure. Listing 1-2. A Procedure Named getRangeSum to Compute the Sum of All Integers Between Two Integers int getRangeSum(int lowerLimit, int upperLimit) { int sum = 0; int counter = lowerLimit; while (counter <= upperLimit) { sum = sum + counter; counter = counter + 1; } return sum; } A procedure has a name, which is getRangeSum in this case. A procedure has a return type, which is specified just before its name. The return type indicates the type of value that it will return to its caller. The return type is int in this case, which indicates that the result of the computation will be an integer. A procedure has formal parameters (possibly zero), which are specified within parentheses following its name. A formal parameter consists of data type and a name. In this case, the formal parameters are named as lowerLimit and upperLimit, and both are of the data type int. It has a body, which is placed within braces. The body of the procedure contains the logic. When you want to execute the code for a procedure, you must pass the actual values for its formal parameters. You can compute and print the sum of all integers between 10 and 20 as follows: int s1 = getRangeSum(10, 20); System.out.println(s1); 16 Chapter 1 ■ Programming Concepts This snippet of code will print 165. To compute the sum all integers between 40 and 60, you can execute the following snippet of code: int s2 = getRangeSum(40, 60); System.out.println(s2); This snippet of code will print 1050, which is exactly the same result you achieved before. The abstraction method that you used in defining the getRangeSum procedure is called abstraction by parameterization. The formal parameters in a procedure are used to hide the identity of the actual data on which the procedure’s body operates. The two parameters in the getRangeSum procedure hide the identity of the lower and upper limits of the range of integers. Now you have seen the first concrete example of abstraction. Abstraction is a vast topic. I cover some more basics about abstraction in this section. Suppose a programmer writes the code for the getRangeSum procedure, as shown in Listing 1-2, and another programmer wants to use it. The first programmer is the designer and writer of the procedure; the second one is the user of the procedure. What pieces of information does the user of the getRangeSum procedure need to know in order to use it? Before you answer this question, let’s consider a real-world example of designing and using a DVD (Digital Versatile Disc) player. A DVD player is designed and developed by electronic engineers. How do you use a DVD player? Before you use a DVD player, you do not open it to study all the details about its parts that are based on electronics engineering theories. When you buy it, it comes with a manual on how to use it. A DVD player is wrapped in a box. The box hides the details of the player inside. At the same time, the box exposes some of the details about the player in the form of an interface to the outside world. The interface for a DVD player consists of the following items: • Input and output connection ports to connect to a power outlet, a TV set, etc. • A panel to insert a DVD • A set of buttons to perform operations such as eject, play, pause, fast forward, etc. The manual that comes with the DVD player describes the usage of the player’s interface meant for its users. A DVD user need not worry about the details of how it works internally. The manual also describes some conditions to operate it. For example, you must plug the power cord to a power outlet and switch on the power before you can use it. A program is designed, developed, and used in the same way as a DVD player. The user of the program, shown in Listing 1-2, need not worry about the internal logic that is used to implement the program. A user of the program needs to know only its usage, which includes the interface to use it, and conditions that must be met before and after using it. In other words, you need to provide a manual for the getRangeSum procedure that will describe its usage. The user of the getRangeSum procedure will need to read its manual to use it. The “manual” for a program is known as its specification. Sometimes it is also known as documentation or comments. It provides another method of abstraction, which is called abstraction by specification. It describes (or exposes or focuses) the “what” part of the program and hides (or ignores or suppresses) the “how” part of the program from its users. Listing 1-3 shows the same getRangeSum procedure code with its specification. Listing 1-3. The getRangeSum Procedure with its Specification for Javadoc Tool /** * Computes and returns the sum of all integers between two * integers specified by lowerLimit and upperLimit parameters. * * The lowerLimit parameter must be less than or equal to the * upperLimit parameter. If the sum of all integers between the 17 Chapter 1 ■ Programming Concepts * lowerLimit and the upperLimit exceeds the range of the int data * type then result is not defined. * * @param lowerLimit The lower limit of the integer range * @param upperLimit The upper limit of the integer range * @return The sum of all integers between lowerLimit (inclusive) * and upperLimit (inclusive) */ public static int getRangeSum(int lowerLimit, int upperLimit) { int sum = 0; int counter = lowerLimit; while (counter <= upperLimit) { sum = sum + counter; counter = counter + 1; } return sum; } It uses Javadoc standards to write a specification for a Java program that can be processed by the Javadoc tool to generate HTML pages. In Java, the specification for a program element is placed between /** and */ immediately before the element. The specification is meant for the users of the getRangeSum procedure. The Javadoc tool will generate the specification for the getRangeSum procedure, as shown in Figure 1-4. Figure 1-4. The specification for the getRangeSum procedure This specification provides the description (the “what” part) of the getRangeSum procedure. It also specifies two conditions, known as pre-conditions, which must be true when the procedure is called. The first pre-condition is that the lower limit must be less than or equal to the upper limit. The second pre condition is that the value for lower and upper limits must be small enough so that the sum of all integers between them fits in the size of the int data type. It specifies another condition that is called post-condition, which is specified in the “Returns” clause. The post-condition holds as long as pre-conditions hold. 18 Chapter 1 ■ Programming Concepts The pre-conditions and post-conditions are like a contract (or an agreement) between the program and its user. It states that as long as the user of the program makes sure that the pre-condition holds true, the program guarantees that the post-condition will hold true. Note that the specification never tells the user about how the program fulfills (implementation details) the post-condition. It only tells “what” it is going to do rather than “how” it is going to do it. The user of the getRangeSum program, who has the specification, need not look at the body of the getRangeSum procedure to figure out the logic that it uses. In other words, you have hidden the details of the implementation of the getRangeSum procedure from its users by providing this specification to them. That is, users of the getRangeSum procedure can ignore its implementation details for the purpose of using it. This is another concrete example of abstraction. The method of hiding implementation details of a subprogram (the “how” part) and exposing its usage (the “what” part) by using specification is called abstraction by specification. Abstraction by parameterization and abstraction by specification let the users of a program view the program as a black box, where they are concerned only about the effects that program produces rather than how the program produces those effects. Figure 1-5 depicts the user’s view of the getRangeSum procedure. Note that a user does not see (and need not see) the body of the procedure that has the details. The details are relevant only to the writer of the program, not its users. Inputs to 10 Body of getRangeSum Output from getRangeSum 20165 as a black box getRangeSum Figure 1-5. User’s view of the getRangeSum procedure as a black box using abstraction What advantages did you achieve by applying the abstraction to define the getRangeSum procedure? One of the most important advantages is isolation. It is isolated from other programs. If you modify the logic inside its body, other programs, including the ones that are using it, need not be modified. To print the sum of integers between 10 and 20, you use the following program: int s1 = getRangeSum(10, 20); System.out.println(s1); The body of the procedure uses a while loop, which is executed as many times as the number of integers between lower and upper limits. The while loop inside the getRangeSum procedure executes n times where n is equal to (upperLimit – lowerLimit + 1). The number of instructions that needs to be executed depends on the input values. There is a better way to compute the sum of all integers between two integers, lowerLimit and upperLimit, using the following formula: n = upperLimit - lowerLimit + 1; sum = n * (2 * lowerLimit + (n-1))/2; If you use this formula, the number of instructions that are executed to compute the sum of all integers between two integers is always the same. You can rewrite the body of the getRangeSum procedure, as shown in Listing 1-4. The specification of getRangeSum procedure is not shown here. Listing 1-4. Another Version of the getRangeSum Procedure with the Logic Changed Inside its Body public int getRangeSum(int lowerLimit, int upperLimit) { int n = upperLimit - lowerLimit + 1; int sum = n * (2 * lowerLimit + (n-1))/2; return sum; } 19 Chapter 1 ■ Programming Concepts Note that the body (implementation or the “how” part) of the getRangeSum procedure has changed between Listing 1-3 and Listing 1-4. However, the users of the getRangeSum procedure are not affected by this change because the details of the implementation of this procedure were kept hidden from its users by using abstraction. If you want to compute the sum of all integers between 10 and 20 using the version of the getRangeSum procedure, as shown in Listing 1-4, your old code is still valid. int s1 = getRangeSum(10, 20); System.out.println(s1); You have just seen one of the greatest benefits of abstraction, in which the implementation details of a program (in this case, a procedure) can be changed without warranting any changes in the code that uses the program. This benefit also gives you a chance to rewrite your program logic to improve performance in the future without affecting other parts of the application. I consider two types of abstraction in this section: • Procedural abstraction • Data abstraction Procedural abstraction lets you define a procedure, for example, getRangeSum, that you can use as an action or a task. So far, I have been discussing procedural abstraction. Abstraction by parameterization and abstraction by specification are two methods to achieve procedural abstraction as well as data abstraction. The next section discusses data abstraction in detail. Data Abstraction Object-oriented programming is based on data abstraction. However, I need to discuss data type briefly before I discuss data abstraction. A data type (or simply a type) is defined in terms of three components: • A set of values (or data objects) • A set of operations that can be applied to all values in the set • A data representation, which determines how the values are stored Programming languages provide some predefined data types, which are known as built-in data types. They also let programmers define their own data types, which are known as user-defined data types. A data type that consists of an atomic and indivisible value, and that is defined without the help of any other data types, is known as a primitive data type. For example, Java has built-in primitive data types such as int, float, boolean, char, etc. Three components that define the int primitive data type in Java are as follows: • An int data type consists of a set of all integers between -2147483648 and 2147483647. • Operations such as addition, subtraction, multiplication, division, comparison, and many more are defined for the int data type. • A value of int data type is represented in 32-bit memory in 2’s complement form. All three components of the int data type are predefined by Java language. You cannot extend or redefine the definition of the int data type. You can give a name to a value of the int data type as int n1; 20 Chapter 1 ■ Programming Concepts This statement says that n1 is a name (technically called an identifier) that can be associated with one value from the set of values that defines values for int data type. For example, you can associate integer 26 to the name n1 using an assignment statement as follows: n1 = 26; At this stage, you may be asking, “Where is the value 26, which is associated with the name n1, stored in memory?” You know from the definition of int data type that n1 will take 32-bit memory. However, you do not know, cannot know, and do not need to know where in the memory that 32-bit is allocated for n1. Do you see an example of abstraction here? If you see an example of abstraction in this case, you are right. This is an example of abstraction, which is built into the Java language. In this instance, the pieces of information about the data representation of the data value for int data type are hidden from the users (programmers) of the data type. In other words, a programmer ignores the memory location of n1 and focuses on its value and the operations that can be performed on it. A programmer does not care if the memory for n1 is allocated in a register, RAM, or the hard disk. Object-oriented programming languages such as Java let you create new data types using an abstraction mechanism called data abstraction. The new data types are known as abstract data types (ADT). The data objects in ADT may consist of a combination of primitive data types and other ADTs. An ADT defines a set of operations that can be applied to all its data objects. The data representation is always hidden in ADT. For users of an ADT, it consists of operations only. Its data elements may only be accessed and manipulated using its operations. The advantage of using data abstraction is that its data representation can be changed without affecting any code that uses the ADT. ■ Tip Data abstraction lets programmers create a new data type called an abstract data type, where the storage representation of the data objects is hidden from the users of the data type. In other words, ADT is defined solely in terms of operations that can be applied to the data objects of its type without knowing the internal representation of the data. The reason this kind of data type is called abstract is that users of ADT never see the representation of the data values. Users view the data objects of an ADT in an abstract way, by applying operations on them without knowing the details about representation of the data objects. Note that an ADT does not mean absence of data representation. Data representation is always present in an ADT. It only means hiding of the data representation from its users. Java has constructs, for example, class, interface, annotation, and enum, that let you define new ADTs. When you use a class to define a new ADT, you need to be careful to hide the data representation, so your new data type is really abstract. If the data representation in a Java class is not hidden, that class creates a new data type, but not an ADT. A class in Java gives you features that you can use to expose the data representation or hide it. In Java, the set of values of a class data type are called objects. Operations on the objects are called methods. Instance variables (also known as fields) of objects are the data representation for the class type. A class in Java lets you implement operations that operate on the data representation. An interface in Java lets you create a pure ADT. An interface lets you provide only the specification for operations that can be applied to the data objects of its type. No implementation for operations or data representation can be mentioned in an interface. Listing 1-1 shows the definition of the Person class using Java language syntax. By defining a class named Person, you have created a new ADT. Its internal data representation for name and gender uses String data type (String is a built-in ADT provided by Java class library). Note that the definition of the Person class uses the private keyword in the name and gender declarations to hide it from the outside world. Users of the Person class cannot access the name and gender data elements. It provides four operations: a constructor and three methods (getName, setName, and getGender). 21 Chapter 1 ■ Programming Concepts A constructor operation is used to initialize a newly constructed data object of the Person type. The getName and setName operations are used to access and modify the name data element, respectively. The getGender operation is used to access the value of the gender data element. Users of the Person class must use only these four operations to work with data objects of the Person type. Users of the Person type are oblivious to the type of data storage being used to store name and gender data elements. I am using three terms, “type,” “class,” and “interface,” interchangeably because they mean the same thing in the context of a data type. It gives the developer of the Person type freedom to change the data representation for the name and gender data elements without affecting any users of Person type. Suppose one of the users of Person type has the following snippet of code: Person john = new Person("John Jacobs", "Male"); String intialName = john.getName(); john.setName("Wally Jacobs"); String changedName = john.getName(); This snippet of code has been written only in terms of the operations provided by the Person type. It does not (and could not) refer to the name and gender instance variables directly. Let’s see how to change the data representation of the Person type without affecting the snippet of code. Listing 1-5 shows the code for a newer version for the Person class. Listing 1-5. Another Version of the Person Class That Uses a String Array of Two Elements to Store Name and Gender Values as Opposed to Two String Variables package com.jdojo.concepts; public class Person { private String[] data = new String[2]; public Person(String initialName, String initialGender) { data[0] = initialName; data[1] = initialGender; } public String getName() { return data[0]; } public void setName(String newName) { data[0] = newName; } public String getGender() { return data[1]; } } Compare the code in Listing 1-1 and Listing 1-5. This time, you have replaced the two instance variables (name and gender), which were the data representation for the Person type in Listing 1-1, with a String array of two elements. Since operations (or methods) in a class operate on the data representation, you had to change the implementations for all four operations in the Person type. The client code in Listing 1-5 was written in terms of the specifications of the four operations and not their implementation. Since you have not 22 Chapter 1 ■ Programming Concepts changed the specification of any of the operations, you do not need to change the snippet of code that uses the Person class; it is still valid with the newer definition of the Person type, as shown in Listing 1-5. Some methods in the Person class use the abstraction by parameterization and all of them use the abstraction by specification. I have not shown the specification for the methods here, which would be Javadoc comments. You have seen two major benefits of data abstraction in this section. • It lets you extend the programming language by letting you define new data types. The new data types you create depend on the application domain. For example, for a banking system, Person, Currency, and Account may be good choices for new data types, whereas for an auto insurance application, Person, Vehicle, and Claim may be good choices. The operations included in a new data type depend on the need of the application. • The data type created using data abstraction may change the representation of the data without affecting the client code using the data type. Encapsulation and Information Hiding The term encapsulation is used to mean two different things: a process or an entity. As a process, it is an act of bundling one or more items into a container. The container could be physical or logical. As an entity, it is a container that holds one or more items. Programming languages support encapsulations in many ways. A procedure is an encapsulation of steps to perform a task; an array is an encapsulation of several elements of the same type, etc. In object oriented programming, encapsulation is bundling of data and operations on the data into an entity called a class. Java supports encapsulation in various ways. • It lets you bundle data and methods that operate on the data in an entity called a class. • It lets you bundle one or more logically related classes in an entity called a package. A package in Java is a logical collection of one or more related classes. A package creates a new naming scope in which all classes must have unique names. Two classes may have the same name in Java as long as they are bundled (or encapsulated) in two different packages. • It lets you bundle packages into a module, which was introduced in Java SE 9. A module can export its packages. Types defined in exported packages are accessible to other modules, whereas types in non-exported packages are inaccessible to other modules. • It lets you bundle one or more related classes in an entity called a compilation unit. All classes in a compilation unit can be compiled separately from other compilation units. While discussing the concepts of object-oriented programming, the two terms—encapsulation and information hiding—are often used interchangeably. However, they are different concepts in object-oriented programming, and they should not be used interchangeably as such. Encapsulation is simply the bundling of items together into one entity. Information hiding is the process of hiding implementation details that are likely to change. Encapsulation is not concerned with whether the items that are bundled in an entity are hidden from other modules in the application or not. What should be hidden (or ignored) and what should not be hidden is the concern of abstraction. Abstraction is only concerned about which item should be hidden. Abstraction is not concerned about how the item should be hidden. Information hiding is concerned with how an item is hidden. 23 Chapter 1 ■ Programming Concepts Encapsulation, abstraction, and information hiding are three separate concepts. They are very closely related, though. One concept facilitates the workings of the others. It is important to understand the subtle differences in roles they play in object-oriented programming. ■ Tip In Java SE 9, you will often come across a phrase like “a module provides strong encapsulation”. Here, the term encapsulation is used in the sense of information hiding. It means that types in non-exported packages in a module are hidden from (or inaccessible to) other modules. It is possible to use encapsulation with or without hiding any information. For example, the Person class in Listing 1-1 shows an example of encapsulation and information hiding. The data elements (name and gender) and methods (getName(), setName(), and getGender()) are bundled together in a class called Person. This is encapsulation. In other words, the Person class is an encapsulation of the data elements name and gender, plus the methods getName(), setName(), and getGender(). The same Person class uses information hiding by hiding the data elements from the outside world. Note that name and gender data elements use the Java keyword private, which essentially hides them from the outside world. Listing 1-6 shows the code for a Person2 class. Listing 1-6. The Definition of the Person2 Class in Which Data Elements Are Not Hidden by Declaring Them Public package com.jdojo.concepts; public class Person2 { public String name; // Not hidden from its users public String gender; // Not hidden from its users public Person2(String initialName, String initialGender) { name = initialName; gender = initialGender; } public String getName() { return name; } public void setName(String newName) { name = newName; } public String getGender() { return gender; } } The code in Listing 1-1 and Listing 1-6 is essentially the same except for two small differences. The Person2 class uses the keyword public to declare the name and gender data elements. The Person2 class uses encapsulation the same way the Person class uses it. However, the name and gender data elements are not hidden. That is, the Person2 class does not use data hiding (data hiding is an example of information hiding). If you look at the constructor and methods of Person and Person2 classes, their bodies use information hiding because the logic written inside their bodies is hidden from their users. 24 Chapter 1 ■ Programming Concepts ■ Tip Encapsulation and information hiding are two distinct concepts of object-oriented programming. The existence of one does not imply the existence of the other. Inheritance Inheritance is another important concept in object-oriented programming. It lets you use abstraction in a new way. You have seen how a class represents an abstraction in previous sections. The Person class shown in Listing 1-1 represents an abstraction for a real-world person. The inheritance mechanism lets you define a new abstraction by extending an existing abstraction. The existing abstraction is called a supertype, a superclass, a parent class, or a base class. The new abstraction is called a subtype, a subclass, a child class, or a derived class. It is said that a subtype is derived (or inherited) from a supertype; a supertype is a generalization of a subtype; and a subtype is a specialization of a supertype. The inheritance can be used to define new abstractions at more than one level. A subtype can be used as a supertype to define another subtype and so on. Inheritance gives rise to a family of types arranged in a hierarchical form. Inheritance allows you to use varying degrees of abstraction at different levels of hierarchy. In Figure 1-6, the Person class is at the top (highest level) of the inheritance hierarchy. Customer and Employee classes are at the second level of inheritance hierarchy. As you move up the inheritance level, you focus on more important pieces information. In other words, at a higher level of inheritance, you are concerned about the bigger picture; and at lower levels of inheritance, you are concerned about more and more details. There is another way to look at inheritance hierarchy from abstraction point of view. At the Person level in Figure 1-6, you focus on the common characteristics of Customer and Employee, ignoring the differences between them. At the Employee level, you focus on common characteristics of Clerk, Programmer, and Cashier, ignoring the differences between them. Figure 1-6. Inheritance hierarchy for the Person class 25 Chapter 1 ■ Programming Concepts In inheritance hierarchy, a supertype and its subtype represent an “is-a” relationship. That is, an Employee is a Person; a Programmer is an Employee, etc. Since the lower level of inheritance means more pieces of information, a subtype always includes what its supertype has and maybe some more. This characteristic of inheritance leads to another feature in object-oriented programming, which is known as the principle of substitutivity. It means that a supertype can always be substituted with its subtype. For example, you have considered only name and gender information for a person in your Person abstraction. If you inherit Employee from Person, Employee includes name and gender information, which it inherits from Person. Employee may include some more pieces of information such as employee ID, hire date, salary, etc. If a Person is expected in a context, it implies that only name and gender information are relevant in that context. You can always replace a Person in that context with an Employee, a Customer, a Clerk, or a Programmer because being a subtype (direct or indirect) of the Person these abstractions guarantee that they have the ability to deal with at least name and gender information. At programming level, inheritance provides a code reuse mechanism. The code written in supertype may be reused by its subtype. A subtype may extend the functionality of its supertype by adding more functionalities or by redefining existing functionalities of its supertype. ■ Tip Inheritance is also used as a technique to implement polymorphism, which is discussed in the next section. Inheritance lets you write polymorphic code. The code is written in terms of the supertype and the same code works for subtypes. Inheritance is a vast topic. This book devotes a complete chapter on how to use inheritance in Java. Polymorphism The word “polymorphism” has its root in two Greek words: “poly” (means many) and “morphos” (means form). In programming, polymorphism is the ability of an entity (e.g., variable, class, method, object, code, parameter, etc.) to take on different meanings in different contexts. The entity that takes on different meanings is known as a polymorphic entity. Various types of polymorphism exist. Each type of polymorphism has a name that usually indicates how that type of polymorphism is achieved in practice. The proper use of polymorphism results in generic and reusable code. The purpose of polymorphism is writing reusable and maintainable code by writing code in terms of a generic type that works for many types (or ideally all types). Polymorphism can be categorized in the following two categories: • Ad hoc polymorphism • Universal polymorphism If a piece of code works for a finite number of types and all those types must be known when the code is written, it is known as ad hoc polymorphism. Ad hoc polymorphism is also known as apparent polymorphism because it is not polymorphism in a true sense. Some computer science purists do not consider ad hoc polymorphism to be polymorphism at all. Ad hoc polymorphism is further divided into two categories: • Overloading polymorphism • Coercion polymorphism If a piece of code is written in such a way that it works for an infinite number of types (will also work for new types not known at the time the code is written), it is called universal polymorphism. In universal polymorphism, the same code works on many types, whereas in ad hoc polymorphism, different implementations of code are provided for different types, giving an apparent impression of polymorphism. 26 Chapter 1 ■ Programming Concepts Universal polymorphism is further divided into two categories: • Inclusion polymorphism • Parametric polymorphism In the subsequent sections, I describe these types of polymorphism in detail with examples. Overloading Polymorphism Overloading is an ad hoc polymorphism. Overloading results when a method (called a method in Java and a function in other languages) or an operator has at least two definitions that work on different types. In such cases, the same name (for the method or operator) is used for their different definitions. That is, the same name exhibits many behaviors and hence the polymorphism. Such methods and operators are called overloaded methods and overloaded operators. Java lets you define overloaded methods. Java has some overloaded operators, but it does not let you overload an operator for an ADT. That is, you cannot provide a new definition for an operator in Java. Listing 1-7 shows code for a class named MathUtil. Listing 1-7. An Example of an Overloaded Method in Java // MathUtil.java package com.jdojo.concepts; public class MathUtil { public static int max(int n1, int n2) { /* Code to determine the maximum of two integers goes here */ } public static double max(double n1, double n2) { /* Code to determine the maximum of two floating-point numbers goes here */ } public static int max(int[] num) { /* Code to determine the maximum in an array of int goes here */ } } The max() method of the MathUtil class is overloaded. It has three definitions and each of its definitions performs the same task of computing maximum, but on different types. The first definition computes a maximum of two numbers of int data type, the second one computes a maximum of two floating-point numbers of double data type, and the third one computes a maximum of an array of numbers of int data type. The following snippet of code uses all three definitions of the overloaded max() method: int max1 = MathUtil.max(10, 23); // Uses max(int, int) double max2 = MathUtil.max(10.34, 2.89); // Uses max(double, double) int max3 = MathUtil.max(new int[]{1, 89, 8, 3}); // Uses max(int[]) Note that method overloading gives you only sharing of the method name. It does not result in the sharing of the methods’ definitions. In Listing 1-7, the method name, max, is shared by all three methods, but they all have their own definition of computing maximum of different types. In method overloading, the definitions of methods do not have to be related. They may perform entirely different things and share the same name. 27 Chapter 1 ■ Programming Concepts The following snippet of code shows an example of operator overloading in Java. The operator is +. In the following three statements, it performs three different things: int n1 = 10 + 20; // Adds two integers double n2 = 10.20 + 2.18; // Adds two floating-point numbers String str = "Hi " + "there"; // Concatenates two strings In the first statement, the + operator performs addition on two integers, 10 and 20, and returns 30. In the second statement, it performs addition on two floating-point numbers, 10.20 and 2.18, and returns 12.38. In the third statement, it performs concatenation of two strings, “Hi ” and “there”, and returns "Hi there". In overloading, the types of the actual parameters of methods (the types of operands in case of operators) are used to determine which definition of the code to use. Method overloading provides only the reuse of the method name. You can remove method overloading by simply supplying a unique name to all versions of an overloaded method. For example, you could rename the three versions of the max() method as max2Int(), max2Double(), and maxNInt(). Note that all versions of an overloaded method or operator do not have to perform related or similar tasks. In Java, the only requirement to overload a method name is that all versions of the method must differ in number and/or type of their formal parameters. Coercion Polymorphism Coercion is an ad hoc polymorphism. Coercion occurs when a type is implicitly converted (coerced) to another type automatically even if it was not intended explicitly. Consider the following statements in Java: int num = 707; double d1 = (double)num; // Explicit conversion of int to double double d2 = num; // Implicit conversion of int to double (coercion) In the first statement, the variable num has been declared to be of int data type, and it’s assigned a value of 707. The second statement uses cast, (double), to convert the int value stored in num to double, and it assigns the converted value to a variable named d1. This is the case of explicit conversion from int to double. In this case, the programmer makes his intention explicit by using the cast. The third statement has exactly the same effect as the second one; however, it relies on implicit conversion (called widening conversion in Java) provided by the Java language that converts an int to double automatically when needed. The third statement is an example of coercion. A programming language (including Java) performs different types of coercion in different contexts: assignment (shown previously), method parameters, etc. Consider the following snippet of code that shows a definition of a square() method, which accepts a parameter of double data type: double square(double num) { return num * num; } The square() method can be called with actual parameter of double data type, as follows: double d1 = 20.23; double result = square(d1); The same square() method may also be called with actual parameter of int data type, as follows: int k = 20; double result = square(k); 28 Chapter 1 ■ Programming Concepts You have just seen that the square() method works on parameters of the double as well as int data type, although you have defined it only once in terms of a formal parameter of double data type. This is exactly what polymorphism means. In this case, the square() method is called a polymorphic method with respect to double and int data types. Thus, the square() method is exhibiting polymorphic behavior even though the programmer who wrote the code did not intend it. The square() method is polymorphic because of the implicit type conversion (coercion from int to double) provided by the Java language. Here is a more formal definition of a polymorphic method: Suppose m is a method that declares a formal parameter of type T. If S is a type that can be implicitly converted to T, the method m is said to be polymorphic with respect to S and T. Inclusion Polymorphism Inclusion is a universal polymorphism. It is also known as subtype (or subclass) polymorphism because it is achieved using subtyping or subclassing. This is the most common type of polymorphism supported by object-oriented programming languages. Java supports it. Inclusion polymorphism occurs when a piece of code that is written using a type works for all its subtypes. This type of polymorphism is possible based on the subtyping rule that a value that belongs to a subtype also belongs to the supertype. Suppose T is a type and S1, S2, S3… are subtypes of T. A value that belongs to S1, S2, S3... also belongs to T. This subtyping rule makes it possible to write code as follows: T t; S1 s1; S2 s2; ... t = s1; // A value of type s1 can be assigned to a variable of type T t = s2; // A value of type s2 can be assigned to a variable of type T Java supports inclusion polymorphism using inheritance, which is a subclassing mechanism. You can define a method in Java using a formal parameter of a type, for example, Person, and that method can be called on all its subtypes, for example, Employee, Student, Customer, etc. Suppose you have a method processDetails() as follows: void processDetails(Person p) { /* Write code using the formal parameter p, which is of type Person. The same code will work if an object of any of the subclass of Person is passed to this method. */ } The processDetails() method declares a formal parameter of the Person type. You can define any number of classes that are subclasses of the Person class. This method will work for such subclasses. Assume that Employee and Customer are subclasses of the Person class. You can write code like this: Person p1 = create a Person object; Employee e1 = create an Employee object; Customer c1 = create a Customer object; processDetails(p1); // Use the Person type processDetails(e1); // Use the Employee type, which is a subclass of Person processDetails(c1); // Use the Customer type, which is a subclass of Person 29 Chapter 1 ■ Programming Concepts The effect of the subtyping rule is that the supertype includes (hence the name inclusion) all values that belong to its subtypes. A piece of code is called universally polymorphic only if it works on an infinite number of types. In the case of inclusion polymorphism, the number of types for which the code works is constrained but infinite. The constraint is that all types must be the subtype of the type in whose term the code is written. If there is no restriction on how many subtypes a type can have, the number of subtypes is infinite (at least in theory). Note that inclusion polymorphism not only lets you write reusable code, it also lets you write extensible and flexible code. The processDetails() method works on all subclasses of the Person class. It will keep working for all subclasses of the Person class, which will be defined in the future, without any modifications. Java uses other mechanisms, like method overriding and dynamic dispatch (also called late binding), along with subclassing rules to make the inclusion polymorphism more effective and useful. Parametric Polymorphism Parametric is a universal polymorphism. It is also called “true” polymorphism because it lets you write true generic code that works for any types (related or unrelated). Sometimes, it is also referred to as generics. In parametric polymorphism, a piece of code is written in such a way that it works on any type. Contrast parametric polymorphism with inclusion polymorphism. In inclusion polymorphism, code is written for one type and it works for all of its subtypes. It means all types for which the code works in inclusion polymorphism are related by a supertype-subtype relationship. However, in parametric polymorphism, the same code works for all types, which are not necessarily related. Parametric polymorphism is achieved by using a type variable when writing the code, rather than using any specific type. The type variable assumes a specific type for which the code needs to be executed. Java supports parametric polymorphism since Java 5 through generics. Java supports polymorphic entities (e.g., parameterized classes) as well as polymorphic methods (parameterized methods) that use parametric polymorphism. In Java, parametric polymorphism is achieved in using generics. All collection types in Java use generics. You can write code using generics as follows: /* Example #1 */ // Create a List of String List sList = new ArrayList(); // Add two Strings to the List sList.add("string 1"); sList.add("string 2"); // Get the first String from the List String s1 = sList.get(0); /* Example #2 */ // Create a List of Integer List iList = new ArrayList(); // Add two Integers to the list iList.add(10); iList.add(20); // Get the first Integer from the List int k1 = iList.get(0); This code uses a List object as a list of String type and a List object as a list of Integer type. Using generics, you can treat a List object as a list of any type in Java. Note the use of in these examples to specify the type for which you want to instantiate the List object. 30 Chapter 1 ■ Programming Concepts Summary Writing a set of instructions for a computer to accomplish a task is known as programming. The set of instructions is known as a program. Different types of programming languages exist. They differ in their closeness to the instructions that the hardware can understand or the paradigm. A machine language lets you write programs using 0s and 1s, and it is the lowest level programming language. A program written in machine language is known as machine code. An assembly language lets you write programs using mnemonics. A program written using an assembly language is known as assembly code. Later, higher-level programming languages were developed, using an English-like language. Several types of programming paradigms are in practice. A programming paradigm is a thinking cap for viewing and analyzing real-world problems in a particular way. Imperative, procedural, functional, and object-oriented are some widely used paradigms in software development. Java is a programming language that supports procedural, functional, and object-oriented programming paradigms. Abstraction, encapsulation, inheritance, and polymorphism are the four pillars of object-oriented paradigms. Abstraction is the process of hiding details of a program that are irrelevant to the users of that program. Encapsulation is the process of bundling multiple items into one entity. Inheritance is the process of arranging classes in a hierarchical manner to build supertype-subtype relationships. Inheritance promotes reusability of code by allowing programmers to write the code in terms of a supertype that also works for all of the subtypes. Polymorphism is the way of writing a piece of code once that can operate on multiple types. Method overloading, method overriding, subtyping, and generics are some of the ways to implement polymorphism. EXERCISES Answers to all of the following questions can be found in the different sections of this chapter. 1. What is programming and what is a program? 2. What is the difference between an assembler and a compiler? 3. What is machine language and what does a program written in machine language consist of? 4. What is assembly language and what does a program written in assembly language consist of? 5. Name three higher-level programming languages. 6. Based on the generation of a programming language (1GL, 2GL, etc.), in what categories do Java and SQL fall? 7. What is a programming paradigm? Describe procedural, functional, and object oriented paradigms with examples. 8. Name the four pillars of object-oriented programming and describe each of them with examples. 9. What is “true” polymorphism and how does Java support it? 10. What is an abstract data type? How does Java support the abstract data type? 31 CHAPTER 2 Setting Up the Environment In this chapter, you will learn: • What software you need to write, compile, and run Java programs • From where to download the required software • How to verify the installation of the Java Development Kit 9 (JDK 9) • How to start the jshell command-line tool that lets you run snippets of Java code • From where to download, install, and configure the NetBeans IDE (Integrated Development Environment) used to write, compile, package, and run Java programs System Requirements You need to have the following software installed on your computer to follow the examples in this book: • JDK 9 • A Java editor, preferably NetBeans 9.0 or later Installing JDK 9 You will need JDK 9 to compile and run the Java programs. You can download JDK 9 for your operating system from http://www.oracle.com/technetwork/java/javase/downloads/index.html. Follow the instructions on this web page to install the JDK on your operating system. The web page at https://docs. oracle.com/javase/9/install/toc.htm contains a detailed explanation of the JDK installation. Throughout this book, I assume that you have installed the JDK in the C:\java9 directory on Windows. If you have installed it in a different directory or you are using a different operating system, you need to use the path for the JDK installation on your system. For example, if you have installed it in the /home/ksharan/ jdk9 directory on a UNIX-like operating system, use /home/ksharan/jdk9 whenever I use C:\java9 in this book. When you work with Java, you will frequently hear three terms: • JDK_HOME • JRE_HOME • JAVA_HOME © Kishori Sharan 2017 33 K. Sharan, Beginning Java 9 Fundamentals, https://doi.org/10.1007/978-1-4842-2902-6_2 Chapter 2 ■ Setting Up the Environment JDK_HOME refers to the directory on your computer in which the JDK is installed. If you have installed the JDK in C:\java9, JDK_HOME refers to the C:\java9 directory. There is a subset of the JDK, which is called the JRE (Java Runtime Environment). If you have compiled Java code and just want to run it, you need to install only the JRE. The JDK contains the JRE with several tools, such as the Java compiler. JRE_HOME refers to the directory on your computer in which you have installed the JRE. You can always use the JDK installation directory as the value for the JRE_HOME because JDK includes JRE. Typically, JAVA_HOME refers to the JRE_HOME. Depending on the context, it may also refer to the JDK_HOME. I use the term JDK_HOME in this book to refer to the directory where the JDK 9 is installed. In the next two sections, I explain the directory structure of the JDK and how to verify the JDK installation. The JDK Directory Structure In this section, I explain the directory structure of the JDK installation. There are a few significant changes in the way JDK’s directories and their contents are organized in JDK 9. I also compare the JDK 8 and JDK 9 directory structure. If you want to migrate your JDK 8 application to JDK 9, the new JDK 9 structure may break your application and you need to pay close attention to the changes described in this section. Before JDK 9, the JDK build system used to produce two types of runtime images—A Java Runtime Environment (JRE) and a Java Development Kit (JDK). The JRE was a complete implementation of the Java SE Platform and the JDK had an embedded JRE and development tools and libraries. You had a choice to install only JRE or a JDK, which had an embedded JRE. Figure 2-1 shows the main directories in JDK installation prior to Java SE 9. The JDK_HOME is the directory in which the JDK was installed. If you installed JRE only, you will have only directories under the jre directory. JDK_HOME bin include lib jre bin lib Figure 2-1. JDK and JRE installation directory arrangements before Java SE 9 The installation directories in JDK 8 are arranged as follows: • The bin directory contains the command-line development and debugging tools such as javac, jar, and javadoc. It also contains the java command to launch Java applications. • The include directory contains C/C++ header files to be used while compiling the native code. • The lib directory contains several JARs and other types of files for the JDK’s tools. It had a tools.jar file, which contains the Java classes for the javac compiler. 34 Chapter 2 ■ Setting Up the Environment • The jre\bin directory contains essential commands such as the java command. On the Windows platform, it contains the system’s runtime dynamically linked libraries (DLLs). • The jre\lib directory contains user-editable configuration files such as .properties and .policy files. • The jre\lib\endorsed directory contains JARs that allow the Endorsed Standards Override Mechanism, which allows the later versions of classes and interfaces that implement Endorsed Standards or Standalone Technology, which are created outside the Java Community Process, to be incorporated into the Java Platform. These JARs were prepended to the JVM’s bootstrap class path, thus overriding any definition of these classes and interfaces present in the Java runtime. • The jre\lib\ext directory contains JARs that allow the extension mechanism. This mechanism loads all JARs in this directory by an extension class loader, which is the child of the bootstrap class loader and parent of the system class loader, which loads all application classes. By placing JARs in this directory, you can extend the Java SE Platform. The contents of these JARs are visible to all applications that compile with or run on this runtime image. • The jre\lib directory contains several JARs. The rt.jar file contains the Java classes and resource files for the runtime. Many tools depend on the location of the rt.jar file. • The jre\lib directory contains dynamically linked native libraries for non-Windows platforms. • The jre\lib directory contains several other sub-directories, which contain runtime files such as fonts and images. The root directory of the JDK and of the JRE that is not embedded in a JDK used to contain several files such as COPYRIGHT, LICENSE, and README. A release file in the root directory contains a key-value pair describing the runtime image, such as the Java version, OS version, and architecture. The following is a sample release file from JDK 8, whose partial contents are shown: JAVA_VERSION="1.8.0_66" OS_NAME="Windows" OS_VERSION="5.2" OS_ARCH="amd64" BUILD_TYPE="commercial" The Java SE 9 has flattened the directory hierarchy for the JDK and removed the distinction between a JDK and a JRE. Figure 2-2 shows the directories for a JDK installation in JDK 9. The JRE 8 installation does not contain the include and jmods directories. JDK_HOME bin conf jmods legal include lib Figure 2-2. JDK directory arrangements in Java SE 9 35 Chapter 2 ■ Setting Up the Environment The installation directories in JDK 9 are arranged as follows: • There is no subdirectory named jre. • The bin directory contains all commands. On the Windows platform, it continues to contain the system’s runtime dynamically linked libraries. • The conf directory contains the user-editable configuration files such as .properties and .policy files that used to be in the jre\lib directory before. • The include directory contains C/C++ header files to be used while compiling the native code as before. It exists only in the JDK. • The jmods directory contains the platform modules in JMOD format. You need it when creating a custom runtime image. It exists only in the JDK, not in the JRE. • The legal directory contains legal notices. • The lib directory contains the dynamically linked native libraries on the non Windows platform. Its subdirectories and files are not supposed to be directly edited or used by developers. It contains a file named modules that contains the Java SE platform modules in an internal format named JIMAGE. ■ Tip The JDK 9 is much bigger than JDK 8 because JDK 9 contains two copies of the platform modules— one in the jmods directory in the JMOD format and one in the lib\modules file in the JIMAGE format. The root directory of the JDK 9 continues to have files such as COPYRIGHT, LICENSE, and README. The release file in JDK 9 contains a new entry with a MODULES key whose value is a list of modules included in the image. Partial contents of a release file in JDK 9 image are as follows: MODULES=java.rmi,jdk.jdi,jdk.policytool OS_VERSION="5.2" OS_ARCH="amd64" OS_NAME="Windows" JAVA_VERSION="9" JAVA_FULL_VERSION="9-ea+133" I have shown only three modules in the list. In a full JDK install, this list will include all platform modules. In a custom runtime image, this list will contain only the modules that you included in the image. ■ Tip The lib\tools.jar in the JDK and the lib\rt.jar in the JRE have been removed from Java SE 9. Classes and resources that were available in these JARs are now stored in the lib directory in internal format. A new scheme called jrt may be used to retrieve those classes and resources from the runtime image. Applications dependent on the locations of these JARs will stop working. 36 Chapter 2 ■ Setting Up the Environment Verifying the JDK Installation The JDK_HOME\bin directory contains a command named java, which is used to launch a Java application. When the java command is run with one of the following options, it prints the JDK version information: • -version • --version • -showversion • --show-version All four options print the same JDK version information. The options starting with one hyphen are UNIX-style options, whereas the options starting with two hyphens are GNU-style options. JDK 9 introduced GNU-style options. The UNIX-style options print the JDK version on the standard error stream, whereas the GNU-style options print it on the standard output stream. The -version and --version options exit after printing the information, whereas the -showversion and --show-version options continue to execute other options after printing the information. The following command shows how to print the JDK version: C:\>java --version java 9 Java(TM) SE Runtime Environment (build 9+181) Java HotSpot(TM) 64-Bit Server VM (build 9+181, mixed mode) If the first line of the output prints "java 9", your JDK installation is fine. You might get an output similar to the one shown: 'java' is not recognized as an internal or external command, operable program or batch file. This output indicates that the JDK_HOME\bin directory is not included in the PATH environment variable on your computer. In that case, you can use the full path of the java command to print its version and everywhere else you need it. My JDK_HOME is C:\java9 on Windows. The following commands show you how to use the full path and how to set the PATH environment variable on the command prompt: C:\>C:\java9\bin\java --version java 9 Java(TM) SE Runtime Environment (build 9+181) Java HotSpot(TM) 64-Bit Server VM (build 9+181, mixed mode) C:\>SET PATH=C:\java9\bin;%PATH% C:\>java --version java 9 Java(TM) SE Runtime Environment (build 9+181) Java HotSpot(TM) 64-Bit Server VM (build 9+181, mixed mode) You can also set the PATH environment variable permanently on Windows using the following: Control Panel > System and Security > System > Advanced system settings > Environment Variables 37 Chapter 2 ■ Setting Up the Environment If you have more than one JDK installed on your computer, it is easier to create a batch (or a shell) script to open a command prompt and set the PATH environment variable in the script. This way, you can work with multiple JDKs without setting the PATH environment variable at the system level. Starting the JShell Tool JDK 9 includes a jshell tool in the JDK_HOME\bin directory. The tool lets you execute a snippet of Java code instead of writing a full Java program. This is very helpful for beginners. Chapter 23 covers the jshell tool in detail. The following commands shows you how to start the jshell tool, execute a few Java snippets of code, and then exit the jshell tool: C:\>jshell | Welcome to JShell -- Version 9 | For an introduction type: /help intro jshell> System.out.println("Hello JDK 9!") Hello JDK 9! jshell> 2 + 2 $2 ==> 4 jshell> /exit | Goodbye C:\> While you are reading subsequent chapters, you can start the jshell tool on a command prompt and enter a snippet of code to see the results. Installing NetBeans 9 You need a Java editor to write, package, compile, and run your Java application and NetBeans is one such Java editor. The source code for this book contains NetBeans projects. However, it is not necessary to use NetBeans. You can use another Java editor such as Eclipse, IntelliJ IDEA, or JDeveloper. To follow the examples in this book, you need to copy the source code (the .java files) to the projects that you create using another Java editor. You can download NetBeans from https://netbeans.org/. NetBeans 9.0 runs on JDK 8 and JDK 9. When you install NetBeans, it will ask you to select the JDK home directory. If you install NetBeans on JDK 8, you can select JDK 9 as the Java platform to use JDK 9 inside NetBeans. If you install it on JDK 9, JDK 9 will be the default Java platform inside NetBeans. In the next section, I show you how to select a Java platform inside the NetBeans IDE. 38 Chapter 2 ■ Setting Up the Environment Configuring NetBeans Start the NetBeans IDE. If you open the IDE for the first time, it shows a pane titled Start Page, as shown in Figure 2-3. If you do not want this to show again, you can uncheck the checkbox labeled Show On Startup, which is on the upper-right corner of the pane. You can close the Start Page pane by clicking the X in the pane’s header. If you want to show this page at any time, you can use the Help --> Start Page menu item. Figure 2-3. The Initial NetBeans IDE screen Select Tools ➤ Java Platform to display the Java Platform Manager dialog box, as shown in Figure 2-4. I am running the NetBeans IDE on JDK 1.8, which is shown in the Platforms list. If you are running it on JDK 9, the JDK 9 will be shown in the Platforms list and you do not need any further configuration. 39 Chapter 2 ■ Setting Up the Environment Figure 2-4. The Java Platform Manager dialog box If you see JDK 9 in the Platforms list, your IDE has been configured to use JDK 9 and you can close the dialog box by clicking the Close button. If you do not see JDK 9 in the Platforms list, click the Add Platform… button to open the Add Java Platform dialog box, as shown on in Figure 2-5. Make sure that the Java Standard Edition radio button is selected. Click the Next ➤ button to display the Add Java Platform dialog box, as shown in Figure 2-6. 40 Chapter 2 ■ Setting Up the Environment Figure 2-5. The Select Platform Type box Figure 2-6. The Add Java Platform dialog box 41 Chapter 2 ■ Setting Up the Environment On the Add Java Platform dialog box, select the directory in which the JDK 9 is installed. I installed the JDK 9 in C:\java9, so I selected the C:\java9 directory on this dialog box. Click the Next ➤ button. The Add Java Platform dialog box, as shown in Figure 2-7, is displayed. The Platform Name and Platform Sources fields are prefilled. Figure 2-7. The Add Java Platform dialog box Click the Finish button, which will bring you back to the Java Platform Manager dialog box showing JDK 9 as an item in the Platforms list, as shown in Figure 2-8. Click the Close button to close the dialog box. You are done with configuring the NetBeans IDE to use the JDK 9. 42 Chapter 2 ■ Setting Up the Environment Figure 2-8. The Java Platform Manager showing JDK 1.8 and JDK 9 as Java platforms Summary To work with Java programs, you need to install JDK 9 and a Java editor such as NetBeans. The directory in which the JDK is installed is typically referred to as JDK_HOME. JDK installation copies many Java tools/ commands in the JDK_HOME\bin directory, such as the javac command to compile a Java program, the java command to run a Java program, and the jshell tool to run snippets of Java code. The NetBeans IDE can be installed on top of JDK 8 or JDK 9. When you install it on top of JDK 8, you need to configure the IDE to use JDK 9 as one of the Java platforms. 43 CHAPTER 3 Writing Java Programs In this chapter, you will learn: • About the structure of a Java program • How to organize the source code of a Java program • How to write, compile, and run a Java program using the Java Shell, a command prompt, and the NetBeans integrated development environment (IDE) • What observable and resolved modules are • What a module graph is • What the module path and the class path are and how to use them • Briefly about the Java Platform and the Java Virtual Machine (JVM) This chapter and the rest of the chapters in this book assume that you have installed JDK 9 and NetBeans IDE 9, as described in Chapter 2. The Goal Statement The main goal of this chapter is simple—write a Java program to print the following message on the console: Welcome to Java 9! You might think—how hard would it be to print a message in Java? In fact, it is not hard to print a message in Java. The following one line of code will print this message: System.out.println("Welcome to Java 9!"); However, you have to do a lot of plumbing work to print this message in a full-fledged Java program. I will show you how to print a message in Java using three methods: • Using the Java Shell, which is also known as the JShell tool • Using a command prompt or a terminal • Using the NetBeans IDE Using the JShell tool requires no plumbing work and is the easiest of all. It will let you print a message without knowing anything else about the Java programming language. © Kishori Sharan 2017 45 K. Sharan, Beginning Java 9 Fundamentals, https://doi.org/10.1007/978-1-4842-2902-6_3 Chapter 3 ■ Writing Java Programs ■ Note The JShell tool was introduced in JDK 9. Using a command prompt requires the most plumbing work and makes you learn the basics of the Java program’s structure before you can print a message as the stated goal in this section. Using the NetBeans IDE requires a little plumbing work and provides the most help you would need as a developer. After this chapter, you will use only NetBeans to write all programs unless the other two methods are required to show their special features. The following sections show you how to achieve the stated goal using the three methods. Using the JShell Tool Chapter 2 has a quick introduction to the JShell tool. You need to enter the following line of code to print the message: System.out.println("Welcome to Java9!"); I explain each part of this code in the next section. The following JShell session shows you all the steps in a Windows command prompt: c:\>jshell | Welcome to JShell -- Version 9-ea | For an introduction type: /help intro jshell> System.out.println("Welcome to Java 9!"); Welcome to Java 9! jshell> /exit | Goodbye c:\> You have seen how to execute a Java statement using JShell. You have not seen a full Java program yet. JShell is a very powerful tool and you can use it to learn the Java language quickly. For the next few chapters, it will be a handy tool to experiment with code snippets used in examples. I cover all its details in a chapter later in this book. What Is a Java Program? A Java program, which is written using the rules and grammar of the Java programming language, is a set of instructions to be executed by a computer to perform a task. In the next few sections, I explain only the basics involved in writing a Java program. I cover a detailed explanation of all aspects of a Java program in subsequent chapters. Developing a Java application involves four steps: • Writing the source code • Compiling the source code • Packaging the compiled code • Running the compiled code 46 Chapter 3 ■ Writing Java Programs You can write Java programs using a text editor of your choice, such as Notepad on Windows and the vi editor on UNIX. The source code is compiled into object code, also known as bytecode, using a Java compiler. The compiled code is packaged into a JAR file (Java Archive). The packaged compiled code is run by a JVM. When you are using an IDE such as NetBeans, the IDE provides you with a built-in editor to write the source code. The IDE also provides you simple ways to compile, package, and run the application. Writing the Source Code This section covers the details of writing the source code. I demonstrate this by using Notepad on Windows. You can use a text editor of your choice that is available on your operating system. ■ Note I cover using the NetBeans IDE later in this chapter. I first want to cover using a text editor because the process reveals a lot about Java programs that you need to know. When you finish writing the source code, you must save the file with the extension .java. You are going to name your source code file Welcome.java. Note that any extension to the file other than .java is not acceptable. For example, the names like Welcome.txt and Welcome.doc are not valid source code file names. Whenever you use a language to write something (in your case, Java source code), you need to follow the grammar of that language, and use a specific syntax depending on the thing you are writing. Let’s take an example of writing a letter to your friend. The letter will have several parts: a heading, a greeting, a body, closing statements, and your signature. In a letter, it is not just important to put all five parts together; rather, they should also be placed in a specific order. For example, the closing needs to follow the body. Some parts in a letter may be optional and others mandatory. For example, it is fine to exclude the return address in a letter to your friend, whereas it is mandatory in a business letter. In the beginning, you can think of writing a Java program similar to writing a letter. A Java program consists of one or more modules. A module contains zero or more packages. A package contains one or more types. The term type is a generic term that refers to a user-defined data type. You can have four types of user-defined data types—classes, interfaces, enums, and annotations. Broadly speaking, enums and annotations are specialized types of classes and interfaces, respectively. In the next several chapters, you will be working with only classes. Figure 3-1 shows the arrangement of a module. Module Package1 Package2 Type1 Type2 Type3 Type4 Type5 Type6 Figure 3-1. The structure of a Java program 47 Chapter 3 ■ Writing Java Programs ■ Note Modules were introduced in JDK 9. Up to JDK 8, you had packages and types, but no modules. Pure Java programs are operating system agnostic. You write the same Java code on all operating systems. Operating systems use different syntax to refer to files and separate file paths. While working with Java programs, you have to refer to files and directories and you will need to use the syntax for your operating system. Windows uses a backslash (\) as a directory separator in a file path, for example, C:\bj9f\src, whereas UNIX-like operating systems use a forward slash (/), for example, /home/ksharan/bj9f. Windows uses a semicolon (;) as a path separator, for example, C:\java9\bin;C:\bj9r, whereas UNIX-like operating systems use a colon (:), for example, /home/ksharan/java9/bin:/home/ksharan/bj9f. I use Windows to work with examples in this book. I also explain the differences while using different operating systems whenever they exist. I use the following directory structure to work with the example in this section. • bj9f • bj9f\src • bj9f\mod • bj9f\lib I named the top-level directory bj9f, which is short for Beginning Java 9 Fundamentals. You can create this directory inside any other directory on your computer. For example, you can have it as C:\bj9f on Windows and /home/ksharan/bj9f on UNIX. You will store the source code in the bj9f\src directory, the compiled code in the bj9f\mod directory, and the packaged code in the bj9f\lib directory. Go ahead and create these directories on your computer. You need them in the sections that follow. Writing Comments Comments are non-executable code that is used to document the code. The Java compiler ignores them. They are included in source code to document the program’s functionality and logic. Java supports three types of comments: • Single-line comment • Multi-line comment • Documentation comment or Javadoc comment A single-line comment starts with two forward slashes (//) followed by text. For example: // This is a single-line comment package com.jdojo.intro; // This is also a single-line comment A single-line comment may start at any position in a line. The part of the line starting from two forward slashes to the end of the line is considered a comment. As shown previously, you can also mix Java source code, for example, a package declaration and a comment in one line. Note that this type of comment cannot be inserted in the middle of the Java code. The following package declaration, which is discussed shortly in detail, is incorrect because the package name and the semicolon are also considered as part of the comment: package // An incorrect single-line comment com.jdojo.intro; 48 Chapter 3 ■ Writing Java Programs The following line is a single-line comment. It has a valid package declaration as the comment’s text. It will be treated as a comment, not as a package declaration. // package com.jdojo.intro; The second type of comment is called a multi-line comment. A multi-line comment may span multiple lines. It starts with a forward slash immediately followed by an asterisk (/*) and ends with an asterisk immediately followed by a forward slash (*/). An example of a multi-line comment in a Java source code is as follows: /* This is a multi-line comment. It can span more than one line. */ This comment can also be written using two single-line comments, as follows: // This is a multi-line comment. // It can span more than one line The style of comment that you use in the source code is your personal choice. A multi-line comment may be inserted in the middle of Java code, as shown here. The compiler ignores all text starting from /* to */. package /* A correct comment */ com.jdojo.intro; The third type of comment is called documentation (or Javadoc) comment, which is also a multi-line comment. It is used to generate documentation for Java programs. This kind of comment begins with a forward slash immediately followed by two asterisks (/**) and ends with an asterisk that is immediately followed by a forward slash (*/).The following is a simple example of a documentation comment: /** This is a documentation comment. javadoc generates documentation from such comments. */ Writing Javadoc comments is a vast topic. It is covered in Appendix B in detail. I start all source code in this book with a single-line comment that contains the name of the file that contains the source code, for example: // Welcome.java Declaring a Module A module acts as a container for packages. A module may contain packages that may be used internally within the module or by other modules. A module controls the accessibility of its packages. A module exports its packages for other modules to use them. If a module needs to use packages from another module, 49