Introduction to Java Programming Comprehensive Version

ISBN-10: 0132221586
ISBN-13: 9780132221580
Edition: 6th 2007 (Revised)
Authors: Y. Daniel Liang
List price: $115.00
30 day, 100% satisfaction guarantee

If an item you ordered from TextbookRush does not meet your expectations due to an error on our part, simply fill out a return request and then return it by mail within 30 days of ordering it for a full refund of item cost.

Learn more about our returns policy

Description: Now integrating Java 5 throughout, this reference introduces Java programming fundamentals including problem-solving, object-oriented programming, GUI programming, data structures, networking, internationalization, advanced GUI programming, and Web  More...

what's this?
Rush Rewards U
Members Receive:
coins
coins
You have reached 400 XP and carrot coins. That is the daily max!

Study Briefs

Limited time offer: Get the first one free! (?)

All the information you need in one place! Each Study Brief is a summary of one specific subject; facts, figures, and explanations to help you learn faster.

Add to cart
Study Briefs
History of Western Art Online content $4.95 $1.99
Add to cart
Study Briefs
History of World Philosophies Online content $4.95 $1.99
Add to cart
Study Briefs
American History Volume 1 Online content $4.95 $1.99
Add to cart
Study Briefs
History of Western Music Online content $4.95 $1.99

Customers also bought

Loading
Loading
Loading
Loading
Loading
Loading
Loading
Loading
Loading
Loading

Book details

List price: $115.00
Edition: 6th
Copyright year: 2007
Publisher: Pearson Education
Binding: Paperback
Pages: 1328
Size: 8.25" wide x 10.00" long x 2.00" tall
Weight: 5.038
Language: English

Now integrating Java 5 throughout, this reference introduces Java programming fundamentals including problem-solving, object-oriented programming, GUI programming, data structures, networking, internationalization, advanced GUI programming, and Web programming.nbsp; Includes many new illustrations. Enhances examples throughout, using small, simple, and stimulating examples to demonstrate concepts and techniques.nbsp; Offers anearlier introduction to writing programs than the previous edition. Features a new chapter on recursion, expanding treatment from earlier editions.nbsp; A useful reference for anyone interested in learning more about programming.

Fundamentals of Programming
Introduction to Computers, Programs, and Java
Introduction
What Is a Computer?
Programs
Operating Systems
(Optional) Number Systems
Java, the World Wide Web, and Beyond
The Java Language Specification, API, JDK, and IDE
A Simple Java Program
Creating, Compiling, and Executing a Java Program
Anatomy of a Java Program
Displaying Text in a Message Dialog Box
Primitive Data Types and Operations
Introduction
Writing Simple Programs
Identifiers
Variables
Assignment Statements and Assignment Expressions
Constants
Numeric Data Types and Operations
Numeric Type Conversions
Character Data Type and Operations
The String Type
Getting Input from Input Dialogs
Case Studies
Getting Input from the Console
Programming Style and Documentation
Programming Errors
Debugging
Selection Statements
Introduction
Boolean Data Type and Operations
If Statements
Switch Statements
Conditional Expressions
Formatting Console Output and Strings
Operator Precedence and Associativity
Operand Evaluation Order
Loops
Introduction
The while Loop
The do-while Loop
The for Loop
Which Loop to Use?
Nested Loops
Minimizing Numerical Errors
Case Studies
Keywords break and continue
Methods
Introduction
Creating a Method
Calling a Method
Void Method Example
Passing Parameters by Values
Overloading Methods
Case Study: Computing Taxes with Methods
The Scope of Variables
The Math Class
Case Study: Generating Random Characters
Method Abstraction and Stepwise Refinement
(Optional) Packages
Arrays
Introduction
Array Basics
Copying Arrays
Passing Arrays to Methods
Returning an Array from a Method
(Optional) Variable-Length Argument Lists
Searching Arrays
Sorting Arrays
The Arrays Class
Two-Dimensional Arrays
(Optional) Multidimensional Arrays
Object-Oriented Programming
Objects and Classes
Introduction
Defining Classes for Objects
Constructors
Accessing Objects via Reference Variables
Using Classes from the Java Library
Static Variables, Constants, and Methods
Visibility Modifiers
Data Field Encapsulation
Immutable Objects and Classes
Passing Objects to Methods
The Scope of Variables
The this Keyword
Array of Objects
Class Abstraction and Encapsulation
Case Study: The Loan Class
Case Study: The Course Class
(Optional) Case Study: The StackOfIntegers Class
(Optional GUI) Creating Windows
Strings and Text I/O
Introduction
The String Class
The Character Class
The StringBuilder/StringBuffer Class
Command-Line Arguments
(Optional) Regular Expressions
The File Class
Text I/O
(Optional GUI) Containers and Layout Managers
Inheritance and Polymorphism
Introduction
Superclasses and Subclasses
Using the super Keyword
Overriding Methods
Overriding vs. Overloading
The Object Class and Its to String() Method
Polymorphism, Dynamic Binding, and Generic Programming
Casting Objects and the instanceof Operator
The ArrayList Class
A Custom Stack Class
The protected Data and Methods
The final Classes, Methods, and Variables
(Optional) Methods in the Object Class
(Optional) Hiding Data Fields and Static Methods
(Optional) Initialization Blocks
(Optional GUI) Inheriting GUI Components
Abstract Classes and Interfaces
Introduction
Abstract Classes
The Calendar and GregorianCalendar Classes
Interfaces
Processing Primitive Data Type Values as Objects
Automatic Conversion Between Primitive Types and Wrapper Class Types
(Optional GUI) Handling GUI Events
Object-Oriented Design
Introduction
The Software Development Process
Discovering Class Relationships
Case Study: Object-Oriented Design
Case Study: The Rational Class
Class Design Guidelines
(Optional) Modeling Dynamic Behavior Using Sequence Diagrams and Statecharts
Framework-Based Programming Using Java API
GUI Programming
Getting Started with GUI Programming
Introduction
GUI Components
The Java GUI API
Frames
Layout Managers
The Color Class
The Font Class
Using Panels as Subcontainers
Common Features of Swing GUI Components
Image Icons
Graphics
Introduction
Graphical Coordinate Systems
The Graphics Class
The paintComponent Method
Drawing Graphics on Panels
Drawing Strings, Lines, Rectangles, and Ovals
Case Study: The FigurePanel Class
Drawing Arcs
The Polygon class and Drawing Polygons and Polylines
Centering a Display Using the FontMetrics Class
Case Study: The MessagePanel Class
(Optional) Case Study: The StillClock Class
(Optional) Displaying Images
(Optional) Case Study: The ImageViewer Class
Event-Driven Programming
Introduction
Event and Event Source
Listeners, Registrations, and Handling Events
Mouse Events
Key Events
(Optional) Animation Using the Timer Class
Creating User Interfaces
Introduction
Buttons
Check Boxes
Radio Buttons
Labels
Text Fields
Text Areas
Combo Boxes
Lists
Scroll Bars
Sliders
Creating Multiple Windows
Applets and Multimedia
Introduction
The Applet Class
The JApplet Class
The HTML File and the <applet> Tag
Enabling Applets to Run as Applications
Passing Strings to Applets
(Optional) Case Study: TicTacToe
(Optional) Case Study: Bouncing Ball
(Optional) Locating Resource Using the URL Class
(Optional) Playing Audio
(Optional) Case Study: Multimedia Animations
(Optional) Packaging and Deploying Java Projects
Exception Handling, I/O, and Recursion
Exceptions and Assertions
Introduction
Exception-Handling Overview
Exceptions and Exception Types
Understanding Exception Handling
The finally Clause
When to Use Exceptions
Rethrowing Exceptions
(Optional) Chained Exceptions
(Optional) Creating Custom Exception Classes
(Optional) Assertions
Binary I/O
Introduction
How is I/O Handled in Java?
Text I/O vs. Binary I/O
Binary I/O Classes
Case Study: Copying File
Object I/O
(Optional) Random Access Files
(Optional) Case Study: Address Book
Recursion
Introduction
Example: Factorials
Example: Fibonacci Numbers
Problem Solving Using Recursion
Recursive Helper Methods
Tower of Hanoi
Fractals
Recursion versus Iteration
Data Structures
Lists, Stacks, Queues, Trees, and Heaps
Introduction
Lists
Stacks and Queues
Binary Trees
Heaps
Priority Queues
Generics
Introduction
Motivations
Declaring Generic Classes and Interfaces
Generic Methods
Raw Type and Backward Compatibility
Wildcards
Important Facts
Avoiding Unsafe Raw Types
(Optional) Case Study: Generic Matrix Class
Java Collections Framework
Introduction
The Collection Interface and the AbstractCollection Class
Sets
The Comparator Interface
Lists
Static Methods for Lists and Collections
The Vector and Stack Classes
Queues and Priority Queues
(Optional) Maps
Singleton and Unmodifiable Collections and Maps
Algorithm Efficiency and Sorting
Introduction
Estimating Algorithm Efficiency
Bubble Sort
Merge Sort
Quick Sort
Heap Sort
External Sort
Concurrency, Networking, and Internationalization
Multithreading
Introduction
Thread Concepts
Creating Tasks and Threads
The Thread Class
Example: Flashing Text
GUI Event Dispatcher Thread
(Optional) Case Study: Clock with Audio
Thread Pools
Thread Synchronization
(Optional) Synchronization Using Locks
(Optional) Cooperation Among Threads
(Optional) Case Study: Producer/Consumer
(Optional) Blocking Queues
(Optional) Semaphores
Avoiding Deadlocks
Thread States
Synchronized Collections
(Optional) JProgressBar
Networking
Introduction
Client/Server Computing
The InetAddress Class
Serving Multiple Clients
Applet Clients
Sending and Receiving Objects
Retrieving Files from Web Servers
JEditorPane
(Optional) Case Studies: Distributed TicTacToe Games
(Optional) Datagram Socket
Internationalization
Introduction
The Locale Class
Displaying Date and Time
Formatting Numbers
(Optional) Resource Bundles
(Optional) Character Encoding
Advanced GUI Programming
JavaBeans and Bean Events
Introduction
JavaBeans
Bean Properties
Java Event Model Review
Creating Custom Source Components
(Optional) Creating Custom Event Sets
Containers, Layout Managers, and Borders
Introduction
Swing Container Structures
Layout Managers
Creating Custom Layout Managers
JScrollPane
JTabbedPane
JSplitPane
Swing Borders
(Optional) Pluggable Look-and-Feel
Menus, Toolbars, Dialogs, and Internal Frames
Introduction
Menus
Popup Menus
JToolBar
Processing Actions Using the Action Interface
JOptionPane Dialogs
Creating Custom Dialogs
JColorChooser
JFileChooser
(Optional) Creating Internal Frames
MVC and Swing Models
Introduction
MVC
MVC Variations
Swing Model-View-Controller Architecture
JSpinner
Spinner Models and Editors
JList
List Models
List Cell Renderer
JComboBox
JTable and JTree
Introduction
JTable
Table Models and Table Column Models
Case Study: Modifying Rows and Columns
Table Renderers and Editors
Custom Table Renderers and Editors
Table Model Events
JTree
TreeModel and DefaultTreeModel
TreeNode, MutableTreeNode, and DefaultMutableTreeNode
TreePath and TreeSelectionModel
Case Study: Modifying Trees
Tree Node Rendering and Editing
Tree Events
Web Programming
Java Database Programming
Introduction
Relational Database Systems
SQL
JDBC
PreparedStatement
Retrieving Metadata
Advanced Java Database Programming
Introduction
A Universal SQL Client
Batch Processing
Scrollable and Updateable Result Set
RowSet, JdbcRowSet, and CachedRowSet
Storing and Retrieving Images in JDBC
Servlets
Introduction
HTML and Common Gateway Interface
Creating and Running Servlets
The Servlet API
Creating Servlets
HTML Forms
Database Programming in Servlets
Session Tracking
Sending Images from Servlets
JavaServer Pages
Introduction
A Simple JSP Page
How Is a JSP Page Processed?
JSP Scripting Constructs
Predefined Variables
JSP Directives
Using JavaBeans in JSP
Getting and Setting Properties
Associating Properties with Input Parameters
Forwarding Requests from JavaServer Pages
Case Study: Browsing Database Tables
Remote Method Invocations
Introduction
RMI Basics
Developing RMI Applications
RMI vs. Socket-Level Programming
Developing Three-Tier Applications Using RMI
RMI Callbacks
Java Keywords
The ASCII Character Set
Operator Precedence Chart
Java Modifiers
Special Floating-Point Values
Bit Operations
Index

×
Free shipping on orders over $35*

*A minimum purchase of $35 is required. Shipping is provided via FedEx SmartPost® and FedEx Express Saver®. Average delivery time is 1 – 5 business days, but is not guaranteed in that timeframe. Also allow 1 - 2 days for processing. Free shipping is eligible only in the continental United States and excludes Hawaii, Alaska and Puerto Rico. FedEx service marks used by permission."Marketplace" orders are not eligible for free or discounted shipping.

Learn more about the TextbookRush Marketplace.

×