Professional Java User Interfaces (Paperback)
$1,320Head First Design Patterns (Paperback)
This book covers the full development life cycle for professional GUI design in Java, from cost estimation and design to coding and testing.
- Focuses on building high quality industrial strength software in Java
- Ready-to-use source code is given throughout the text based on industrial-strength projects undertaken by the author.
Table of Contents
The interactivity thrill.
Usable GUIs and usable books.
The organization of the book.
Three levels of advice.
Conventions used in the book.
Book readers and personas.
Lars, a Java intermediate programmer.
Keiichi, a tech lead.
Shridhar, a professor in computer science.
Melinda (Mellie), a manager.
William, a first year student in a Master in CS course.
Karole, a business analyst.
Juan, an experienced programmer.
1 Putting GUI Development into Context.
Focusing on users.
A functional decomposition for user interfaces.
Tool selection: the Java singularity.
Of running little green men and wrong choices.
People and GUIs.
Use case diagrams and GUIs.
Lifecycle models, processes and approaches.
Rational Unified Process 18 Extreme Programming and other Agile approaches.
Evolutionary Prototyping process.
2 Introduction to User Interface Design.
The human factor.
A model of interactive systems – seven stages and two gulfs.
Developers are part of the design process.
Short term memory and cognitive modeling.
Interacting with human beings.
Simplified thinking aloud.
Abstract-Augmented Area for GUIs.
Conceptual frameworks for UI design.
Entity-based approaches to UI design.
Metaphor-based approaches to UI design.
Function-based approaches to UI design.
‘Null’ approach to UI design.
Object-oriented user interfaces.
Assessing the quality of a GUI.
3 Java GUI Design.
Java technology for GUIs.
Assembling the components.
Three levels of component cost.
Ad-hoc versus custom – the difference between ‘run’ and ‘ride’.
When ad-hoc is the only way to go.
Exploring the design space for a point chooser.
Design guidelines for the Java platform.
Introduction to the guidelines.
J2SE user interface design guidelines.
The Java look and feel design guidelines.
The Java ‘look’.
The Java ‘feel’.
An example – applying the guidelines for designing dialogs.
4 Recurring User Interface Designs.
GUI area organization.
Multiple document interfaces.
Chooser activation mechanisms.
Chooser interaction styles.
Broadening the choice.
Saving user preferences.
Preference dialogs styles.
The ‘About’ dialog.
First-time message dialogs.
Testing the final product for accessibility.
Navigation and keyboard support.
Icons and images.
Leveraging object-oriented programming.
5 Iterative GUI Development with Java.
Introduction to prototyping.
Uses for prototyping.
The two dimensions of prototyping.
Competitors’ product as ready-made prototypes.
Prototyping as a philosophy for development.
Prototypes and customers.
Different types of prototypes.
Reusable prototyping widgets.
A tree prototype utility class.
A visual container prototype utility class.
Some classic refactorings.
Some GUI-specific refactorings.
Failing with style.
Introduction to user interface testing.
What’s first – GUI design or implementation?.
Software testing of Java GUIs.
How to test – GUI software test approaches.
What to test – test coverage criteria.
Usability testing of Java GUIs.
JRE runtime management.
Introduction to profiling.
A posteriori profiling.
6 Implementation Issues.
Revisiting the abstract model.
Testing the various layers.
The principle of Single Functional Responsibility.
Isolating presentation details.
A comprehensive data IO design strategy.
Some design patterns.
Remote communication design.
Making objects communicate.
The Observer pattern.
Design-time class decoupling with events.
Misuses of event-based messaging.
Alternatives to event-based communication mechanisms.
Separating data from views.
Interaction and control.
Representing user actions with the Command pattern.
A state-oriented approach to GUI control.
Some design patterns for GUIs.
Object lifecycle management – a general mindset.
GUI complexity boosters.
7 Code Organization.
Introducing software architectures.
Evolving order and appropriate architectures.
Some common GUI architectures.
The smart GUI antipattern.
A semi-smart GUI architecture.
A three-layer architecture.
A four-layer architecture.
A three-layer organization for GUI code.
The presentation layer.
The application layer.
The service layer.
Two examples of a three-layer implementation.
An MP3 player.
An electronic circuit simulator and editor.
The service layer.
8 Form-Based Rich Clients.
Defining rich clients.
Java rich clients.
GUI design for rich clients: the Third Way.
Reference functional model.
Distributing behavior between client and server.
Runtime data model.
Validation 408 When to validate and notify.
The cake-ordering application, the XP way.
Setting up the first Iteration.
Content first .
Closing the loop with the server.
9 Web-Based User Interfaces.
An overview of Web user interfaces.
GUI design for the Web.
Fine graphics details .
Levels of client-side control.
Implementing Web applications with Java.
The typical architecture of a Web application.
Basic Java Web GUI technologies.
From Web applications to rich clients.
Different development habits.
10 J2ME User Interfaces.
Introduction to the MID profile.
Main UI concepts.
Main UI limitations.
Cost-driven design for J2ME GUIs.
The MIDP UI API.
Designing MIDP GUIs.
Abstract GUI designs.
An example custom item.
An example ad-hoc item.
An example application.
11 Java Tools and Technologies.
Introduction to tool selection.
Evaluating open source software.
Open Source Maturity Model.
SWT or Swing?.
Choosing a toolkit.
Mix and match.
Other GUI technologies.
JGoodies Swing Suite.
L2FProd Common Components.
Other OSS component libraries.
Some commercially-available Swing components.
Presentation layer technologies.
Assessing a look and feel.
Swing look and feels.
Declarative GUIs with Java.
12 Advanced Issues.
Building on top of existing libraries.
Roll your own framework.
Memory management for complex GUIs.
A practical case.
Restructuring existing GUI code.
Porting an old applet – a case study.
Providing new deployment support.
Domain-specific and Little languages.
The future of Java GUIs.
13 Rich Client Platforms.
Introduction to Java rich client platforms.
The case for RCP applications.
What’s in an RCP.
GUI design guidelines and RCPs.
The NetBeans RCP.
The Spring RCP.
The Eclipse RCP.
Eclipse plug-in architecture.
Eclipse RCP plug-ins.
The workbench – the building blocks of ERCP GUIs.
GUI design guidelines for ERCP applications .
Choosing the best RCP for your needs.
When to employ an RCP.
An example Eclipse RCP application.
Introducing client-side modular architectures.
The Snooper application architecture.
14 The Personal Portfolio Application.
A note on lifecycle models.
A refined use case diagram.
Individuating boundary classes.
Choosing a technology.
An initial GUI design.
An initial GUI paper mock-up.
A second GUI paper mock-up.
A throw-away GUI prototype.
Validating the throw-away prototype.
The final GUI.
The software architecture.
The remote explorer director.
An alternative, cost-driven implementation.
Choosing a higher-level starting point.
A cost-driven prototype using JDNC.
A brief introduction to JDNC .
15 An Example OO User Interface.
A matter of style.
Implementing object-oriented user interfaces.
The Viewable interface.
Some utility classes.
Making collections viewable.
A utility class.
Interacting with the user.
The Commandable interface.
Managing user commands.
An example application.
Some GUI design considerations.
An alternative implementation using Naked Objects.
16 An Example Ad-Hoc Component.
The Drawing Sandbox application.
The Sandbox architecture.
The Sandbox component.
Top-down refinement of functional organization.
Organizing object communication.
The Action framework.
The Actions class.
The Edit class.
The Director class.
Enforcing logical constraints on actions.
The whole picture.
Stressing the software design.
Adding objects and commands.
The design’s weak points.
A A Questionnaire for Evaluating Java User Interfaces.
B A Questionnaire for Evaluating J2ME Applications.
General advice on usability and GUI design.