Professional Java User Interfaces (Paperback)
暫譯: 專業 Java 使用者介面 (平裝本)

Description

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

Acknowledgements.

Introduction.

The interactivity thrill.

Usable GUIs and usable books.

The organization of the book.

Three levels of advice.

Conventions used in the book.

Source code.

Reader feedback.

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.

Introduction.

Focusing on users.

A functional decomposition for user interfaces.

Tool selection: the Java singularity.

Of running little green men and wrong choices.

Organizational aspects.

People and GUIs.

Team composition.

Early design.

Use case diagrams and GUIs.

Lifecycle models, processes and approaches.

Rational Unified Process 18 Extreme Programming and other Agile approaches.

LUCID methodology.

Evolutionary Prototyping process.

UML notation.

Class diagrams.

Sequence diagrams.

State diagrams.

Summary.

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.

User-centered design.

Simplified thinking aloud.

Display organization.

Esthetic considerations.

Abstract-Augmented Area for GUIs.

Interaction styles.

Menu selection.

Form filling.

Language-based styles.

Direct manipulation.

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.

Usability heuristics.

Summary.

3 Java GUI Design.

Java technology for GUIs.

Assembling the components.

Three levels of component cost.

Cost-driven design.

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.

Standard designs.

Ad-hoc designs.

Mixed designs.

Conclusions.

Design guidelines for the Java platform.

Introduction to the guidelines.

J2SE user interface design guidelines.

The Java look and feel design guidelines.

Some definitions.

The Java ‘look’.

The Java ‘feel’.

Some terminology.

An example – applying the guidelines for designing dialogs.

Summary.

4 Recurring User Interface Designs.

GUI area organization.

Terminology.

Main frames.

Multiple document interfaces.

Wizards.

Choosers.

Chooser activation mechanisms.

Chooser interaction styles.

Broadening the choice.

Conclusions.

Memory components.

Input history.

Saving user preferences.

Lazy initialization.

Preference dialogs.

Preference dialogs styles.

Waiting strategies.

Flexible layout.

Common dialogs.

The ‘About’ dialog.

Log-in dialog.

First-time message dialogs.

Splash window.

Command components.

Graphic conventions.

Toolbar composition.

Command composition.

Accessibility.

Testing the final product for accessibility.

Conclusions.

Navigation and keyboard support.

Keyboard shortcuts.

Tab traversal.

Internationalization.

Help support.

Icons and images.

Leveraging object-oriented programming.

Summary.

5 Iterative GUI Development with Java.

Iterating wisely.

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.

Prototyping alternatives.

Different types of prototypes.

Storyboards.

GUI builders.

Reusable prototyping widgets.

A tree prototype utility class.

A visual container prototype utility class.

GUI refactoring.

Some classic refactorings.

Some GUI-specific refactorings.

Failing with style.

Introduction to user interface testing.

Test-driven development.

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.

Common problems.

Continuous profiling.

A posteriori profiling.

Summary.

6 Implementation Issues.

Revisiting the abstract model.

Testing the various layers.

The principle of Single Functional Responsibility.

Isolating presentation details.

Content.

Content assembly.

Explicit navigation.

Business domain.

Data input-output.

A comprehensive data IO design strategy.

Some design patterns.

Remote communication design.

Security issues.

Making objects communicate.

The Observer pattern.

Swing events.

SWT events.

Design-time class decoupling with events.

Event Arbitrator.

Misuses of event-based messaging.

Alternatives to event-based communication mechanisms.

Separating data from views.

Model-View-Controller.

Interaction and control.

Representing user actions with the Command pattern.

Control issues.

A state-oriented approach to GUI control.

Some design patterns for GUIs.

Adaptation.

Composite Context.

Active Object.

Object lifecycle management – a general mindset.

Value Model.

GUI complexity boosters.

Summary.

7 Code Organization.

Introducing software architectures.

Taming references.

Composable units.

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.

Overview.

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.

Overview.

Persistence services.

Factory services.

Other services.

Summary.

Key ideas.

8 Form-Based Rich Clients.

Introduction .

Defining rich clients.

Java rich clients.

GUI design for rich clients: the Third Way.

Reference functional model.

Distributing behavior between client and server.

Common problems.

Runtime data model.

Validation 408 When to validate and notify.

The cake-ordering application, the XP way.

Setting up the first Iteration.

Content first .

Data second.

Commands third.

Closing the loop with the server.

Summary.

9 Web-Based User Interfaces.

An overview of Web user interfaces.

GUI design for the Web.

Fine graphics details .

Area organization.

Levels of client-side control.

Navigation issues.

Implementing Web applications with Java.

The typical architecture of a Web application.

Basic Java Web GUI technologies.

Java applets.

From Web applications to rich clients.

Different development habits.

Summary.

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.

UI widgets.

Designing MIDP GUIs.

Abstract GUI designs.

Designing navigation.

An example custom item.

An example ad-hoc item.

An example application.

The code.

Summary.

11 Java Tools and Technologies.

Introduction to tool selection.

Evaluating open source software.

Open Source Maturity Model.

SWT or Swing?.

The toolkits.

Choosing a toolkit.

Mix and match.

Other GUI technologies.

Utility libraries.

Security tools.

Deployment tools.

Glazed Lists.

JGoodies Swing Suite.

L2FProd Common Components.

Other OSS component libraries.

Some commercially-available Swing components.

Test tools.

Profiling tools.

GUI builders.

Presentation layer technologies.

Assessing a look and feel.

Swing look and feels.

SWT Presentation.

Declarative GUIs with Java.

XML-based formats.

Summary.

12 Advanced Issues.

Building on top of existing libraries.

Attributes .

Roll your own framework.

Memory management for complex GUIs.

A practical case.

Restructuring existing GUI code.

Porting an old applet – a case study.

Long-life GUIs.

Providing new deployment support.

Exploiting technology.

Domain-specific and Little languages.

The future of Java GUIs.

Summary.

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.

NRCP architecture.

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.

Legal issues.

Eclipse.

Netbeans.

An example Eclipse RCP application.

The application.

Introducing client-side modular architectures.

The Snooper application architecture.

Summary.

14 The Personal Portfolio Application.

The scenario.

A note on lifecycle models.

Analysis 606

Early analysis.

Some scenarios.

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.

Implementation.

Software requirements.

The software architecture.

Resources .

Localization bundles.

Images .

The code.

The remote explorer director.

The prototype.

Deployment issues.

Server support.

An alternative, cost-driven implementation.

Choosing a higher-level starting point.

A cost-driven prototype using JDNC.

A brief introduction to JDNC .

Summary.

15 An Example OO User Interface.

Introduction.

A matter of style.

Implementing object-oriented user interfaces.

The Viewable interface.

Some utility classes.

Brief views.

Making collections viewable.

Configuration views.

A utility class.

Interacting with the user.

The Commandable interface.

Managing user commands.

An example application.

OOUI objects.

The code.

Libraries.

Some GUI design considerations.

Control issues.

An alternative implementation using Naked Objects.

Summary.

16 An Example Ad-Hoc Component.

Introduction.

The Drawing Sandbox application.

The application.

The Sandbox architecture.

The Sandbox component.

Top-down refinement of functional organization.

Organizing object communication.

Graphical objects.

User interaction.

Command composition.

The Action framework.

The Actions class.

Undo-redo support.

The Edit class.

Recording edits.

Memory issues.

Control.

The Director class.

Managing actions.

Enforcing logical constraints on actions.

The whole picture.

Stressing the software design.

Adding objects and commands.

The design’s weak points.

Introducing JHotdraw.

Summary.

Key ideas.

A A Questionnaire for Evaluating Java User Interfaces.

B A Questionnaire for Evaluating J2ME Applications.

References.

General advice on usability and GUI design.

Java-specific links.

Index.