Beginning programming with Java
Book - 2021
Featuring plenty of helpful examples and tips, this sixth edition shows beginners how to program in one of the most popular programming languages that is widely used for application development, including Android, desktop and server-side applications.
Saved in:
- Subjects
- Published
-
Hoboken, NJ :
John Wiley & Sons, Inc
[2021]
- Language
- English
- Main Author
- Edition
- 6th Edition
- Item Description
- Includes index.
"Explore the new features in Java 17"--Page 1 of cover. - Physical Description
- xiv, 538 pages : illustrations ; 24 cm
- ISBN
- 9781119806912
- Introduction
- About This Book
- Foolish Assumptions
- Icons Used in This Book
- Beyond the Book
- Where to Go from Here
- Part 1. Getting Started with Java Programming
- Chapter 1. The Big Picture
- What's It All About?
- Telling a computer what to do
- Pick your poison
- From Your Mind to the Computer's Processor
- Translating your code
- Running code
- Code you can use
- Your Java Programming Toolset
- A tool for creating code
- What's already on your hard drive?
- Chapter 2. Setting Up Your Computer
- Let's Get Started
- Firing up IntelliJ IDEA
- Installing Java
- If You Need More Details
- Shining light on filename extensions
- Dealing with a Mac's security features
- Using IntelliJ IDEA with finesse
- Help! My course instructor doesn't want me to use IntelliJ IDEA!
- Downloading Java without IntelliJ IDEA
- A bit of news about bits
- The Java smorgasbord
- Getting the documentation
- What's Next?
- Chapter 3. Running Programs
- Running a Canned Java Program
- Getting the code
- Adding the code to IntelliJ IDEA
- Running the code
- Some Programs Don't Come in Cans
- What's All That Stuff in the IntelliJ IDEA Window?
- Starting up
- The main window
- Part 2. Writing Your Own Java Programs
- Chapter 4. Exploring the Parts of a Program
- Checking Out Java Code for the First Time
- Behold! A program!
- What the program's lines say
- The Elements in a Java Program
- Keywords and their close cousins
- Identifiers that you or I can define
- Identifiers with agreed-upon meanings
- Literals
- Punctuation
- Comments
- Understanding a Simple Java Program
- What is a method?
- The main method in a program
- At Last! Tell the computer to do something!
- Methods, methods everywhere
- The Java class
- Chapter 5. Composing a Program
- Computers Are Stupid
- Building an Echo Chamber
- Typing and running a program
- How the EchoLine program works
- Getting numbers, words, and other things
- Make IntelliJ Do All the Work
- Expecting the Unexpected
- Diagnosing a problem
- Misspelling words (and other missteps)
- Runtime error messages
- What problem? I don't see a problem
- Chapter 6. Using the Building Blocks: Variables, Values, and Types
- Various Variables and Ways in Which They Vary
- Using a variable
- Understanding assignment statements
- To wrap or not to wrap?
- What Do All Those Zeros and Ones Mean?
- Types and declarations
- What's the point?
- Reading Decimal Numbers from the Keyboard
- Though these be methods, yet there is madness in't
- Methods and assignments
- Variations on a Theme
- If it looks like a double and smells like a double
- Moving variables from place to place
- Combining variable declarations
- Experimenting with JShell
- Chapter 7. Numbers and Types
- Using Whole Numbers
- Reading whole numbers from the keyboard
- What you read is what you get
- Creating New Values by Applying Operators
- Finding a remainder
- Take control of your program's output
- The increment and decrement operators
- Assignment operators
- Size Matters
- Chapter 8. Numbers? Who Needs Numbers?
- A Brief Character Study
- I digress
- One character only, please
- Variables and recycling
- When not to reuse a variable
- Reading characters
- The Moment of Truth (and Falsehood)
- Expressions and conditions
- Comparing numbers; comparing characters
- The Remaining Primitive Types
- Part 3. Controlling the Flow
- Chapter 9. Forks in the Road
- Decisions, Decisions!
- Making Decisions (Java if Statements)
- A careful look at if statements
- A complete program
- A treatise on the importance of helpful indentation
- Variations on the Theme
- ... or else what?
- Packing more stuff into an if statement
- Some handy import declarations
- Chapter 10. Which Way Did He Go?
- Forming Bigger and Better Conditions
- Combining conditions: An example
- When to initialize?
- More and more conditions
- A condition always reveals its secrets
- Mixing different logical operators together
- The mating calls of left and right parentheses
- Building a Nest
- The best of the nest
- Cascading if statements
- Enumerating the Possibilities
- Creating an enum type
- Using an enum type
- When One Line Isn't Enough
- Escape to the \next li\ne o\n the scree\n
- More escapism
- Chapter 11. Around and Around It Goes
- Repeating Instructions Again and Again and Again and Again
- Following the action in a loop
- No early bailout
- Where Does Each Statement Belong?
- Finding some pieces
- Assembling the pieces
- Getting values for variables
- From infinity to affinity
- Priming the Pump
- Working on the problem
- Fixing the problem
- Chapter 12. Circling Back to Java Loops
- Repeating Statements a Certain Number of Times (Java for Statements)
- Esprit de for
- Initializing a for loop
- Shut up and chew!
- Repeating Until You Get What You Need (Java do Statements)
- Holding out for a trustworthy response
- Deleting a file
- Taming of the do
- Repeat performance
- Part 4. The Inside Scoop
- Chapter 13. Programming with Objects and Classes
- The Class Is Always Cleaner
- Reference types and Java classes
- How to use a newly defined class
- What's going on here?
- Why bother?
- From Classes Come Objects
- Understanding (or ignoring) the subtleties
- Making reference to an object's parts
- Creating several objects
- If it looks like a Purchase and smells like a Purchase
- Another Way to Think about Classes
- Classes, objects, and tables
- Some questions and answers
- What's Next?
- Chapter 14. Using Methods and Fields from a Java Class
- Long Live the String!
- A simple example
- Putting String variables to good use
- Reading and writing strings
- Using an Object's Methods
- Comparing strings
- The truth about classes and methods
- Calling an object's methods
- Combining and using data
- How to Achieve Static Equilibrium
- Calling static and nonstatic methods
- Turning strings into numbers
- Turning numbers into strings
- Turning numbers into nice looking strings
- Your country; your currency
- The View from On High
- Unravelling Java's import declarations
- Shedding light on the static darkness
- Barry makes good on an age-old promise
- Chapter 15. Creating New Java Methods
- Defining a Method within a Class
- Making a method
- Examining the method's header
- Examining the method's body
- Calling the method
- Following the flow
- Using punctuation
- Combining characters
- Let the Objects Do the Work
- Passing the Buck
- Handing off a value
- Working with a method header
- Using each object's field values
- Passing more than one parameter
- Getting a Value from a Method
- Return on an investment
- How return types and return values work
- Working with the method header (again)
- What Next?
- Part 5. Smart Java Techniques
- Chapter 16. Piles of Files: Dealing with Information Overload
- Running a Disk-Oriented Program
- Reading and writing
- Messing with files on your hard drive
- Running disk-oriented code
- File and error
- Writing a Disk-Oriented Program
- Reading from a file
- Writing to a file
- Writing, Rewriting, and Re-Rewriting
- Chapter 17. How to Flick a Virtual Switch
- Meet the switch Statement
- Anatomy of a switch statement
- Picky details about the switch statement
- A Switch in Time
- Dissecting the switch expression
- Can you switch between two kinds of switch?
- Your Grandparents' switch Statement
- Using a Conditional Operator
- Chapter 18. Creating Loops within Loops
- Paying Your Old Code a Little Visit
- Reworking some existing code
- Running your code
- Nested Development
- Checking for the end of a file
- How it feels to be a computer
- Why the computer accidentally pushes past the end of the file
- Loop therapy
- Using Nested for Loops
- Chapter 19. Out of Many, One
- Some Loops in Action
- Deciding on a loop's limit at runtime
- Using all kinds of conditions in a for loop
- Reader, Meet Arrays; Arrays, Meet the Reader
- Storing values in an array
- Creating a report
- Stuffing values into an array
- Working with Arrays
- Looping in Style
- When Good Arrays Go Bad
- What to Do When Arrays Go Awry
- Using an ArrayList
- Java's many collection classes
- Chapter 20. Oooey-GUI Was a Worm
- Put Some Swing in Your Step
- The merry window
- A class act
- Constructor calls
- A division of labor
- Frame changer
- Drag-and-Drop for GUI Greatness
- Hello, GUI Designer
- Window dressing
- Taking action
- Part 6. The Part of Tens
- Chapter 21. Ten Useful Classes in the Java API
- ArrayList
- File
- Integer
- JFrame
- JOptionPane
- Math
- NumberFormat
- Scanner
- String
- System
- Chapter 22. Ten Bits of Advice for New Software Developers
- How Long Does It Take to Learn Java?
- Which of Barry's Books Should I Read?
- Are Books Other than Barry's Good for Learning Java and Android Development?
- Which Computer Programming Language(s) Should I Learn?
- What Skills Other than Computer Coding Should I Learn?
- How Should I Continue My Learning as a Software Developer?
- How Else Should I Continue My Learning as a Developer?
- HHow Can I Get a Job Developing Software?
- I Still Don't Know What to Do with My Life
- If I Have Other Questions, How Can I Contact Barry Burd?
- Index