Beginner Java @ Java Programming
Programming Network : The Programmer Store & Resources
Object-Oriented Programming with Java: An Introduction
by David J. Barnes
Textbook Binding: 1028 pages
Dimensions (in inches): 1.60 x 9.55 x 7.04
Publisher: Prentice Hall
ISBN: 0130869007; 1st edition (January 18, 2000)
From Book News, Inc.: Designed primarily as a first programming text, this work guides students through all of Java's functions. Including a number of case studies from the UK, Barnes (computer science, U. of Kent) presents an "objects-early" approach which stresses the importance of maintaining and object's integrity from outside interference. Information on the use of Java in conjunction with non-Java programs is included.Book News, Inc.®, Portland, OR
From the Inside Flap: Preface
This book is designed for those readers who wish to start learning to program in an object-oriented programming language. It has been designed primarily as a first programming text. It is also suitable for those who already have some experience with another programming language, and who now wish to move on to an object-oriented one. Indeed, much of the material is based on courses delivered by the author to students with a wide range of both non-programming and programming backgrounds. The language we use to teach object-oriented programming is Java.
Since its arrival on the scene in 1995, the adoption of Java as a primary programming language has been amazing. In its favor at the time of its arrival were the facts that it was an object-oriented language, and that it offered a safer and more portable alternative to other languages. It also rode the wave of interest in the World Wide Web, with which it integrated well in its provision of applets. Since then, however, Java has come to be regarded as a genuine mainstream programming language.
Our approach in this book is to regard Java as a language that readers will want to use as a primary tool in many different areas of their programming work - not just for creating programs with graphical content within Web pages. For this reason, in the early chapters we have avoided an emphasis on creating applets and GUI-based programs. While being able to create GUI-based programs is superficially attractive, the language concepts required to create them properly are, in fact, quite advanced. Nevertheless, we recognize that visual examples are much more fun to create and work with. To this end, many of our early examples and exercises are enhanced by the provision of visual material that makes them more interesting to experiment with. An object-oriented language makes this approach relatively easy, without the reader needing to become enmeshed in the details of how they are implemented.
The following are key features of this book:
An 'objects-early' approach; showing how to interact with fully-fledged objects, before moving on, in Chapter 4, to define classes from scratch. Frequent in-place exercises and reviews. A thorough glossary, explaining many of the highlighted items of terminology found in the text. An accessible introduction to the fundamental object-oriented topics of polymorphism and inheritance. Significant coverage of the many GUI classes belonging to both the Abstract Windowing Toolkit (AWT) and Swing (JFC), which support both standalone applications and applets. Up-to-date coverage of the Java 2 Platform API. How to use the power of threads for multi-threaded programs, while avoiding hazards such as deadlock, livelock, and thread starvation. Timely coverage of networking, via TCP/IP, to interact with non-Java programs. A unique chapter on event-driven simulation.
In Chapter 2 through Chapter 15, we cover the most important features of object-oriented programming and the Java language. Within those chapters, exercises have been deliberately positioned between sections, rather than grouped at the end. We recommend that these exercises are attempted at the point they are reached, because many of them are designed to reinforce important concepts that you should feel confident with before moving forward. Each of these chapters also includes periodic reviews to reprise and reinforce the main points of the material covered in the preceding sections. From time to time, case studies are used in order to reinforce or bring out further points that are best made in looking at the design and implementation of a larger problem.
In the remaining chapters, we describe in detail how to use many of the GUI components provided by the AWT and Swing classes, how to write multi-threaded programs, and how to interact with programs across a network. We conclude with a chapter on simulation - a common application area for object-oriented programs. Throughout the book, there is an emphasis on the importance of good programming style; particularly the need to maintain an object's integrity from outside interference.
The individual chapters are organized as follows:
Chapter 1 provides an introduction to the basics of computer systems, for those with little or no experience of using a computer to write programs. We present a simple model of a computer and its components, in order to provide a foundation for the ways in which the design of most programming languages is shaped by them. Experienced programmers will find that they can skip this chapter.
In Chapter 2, we describe the fundamental elements of the Java language, and show how to compile and run a simple program.
In Chapter 3, we provide an introduction to basic object-oriented concepts, such as classes and objects. The approach taken in this chapter is fundamental to that taken in the rest of the book: objects are important. We believe that an 'objects-early' approach is the best way to learn an object-oriented language. At this stage, the emphasis is on using existing classes rather than defining them. This approach helps to emphasize that objects communicate bypassing messages to one another.
In Chapter 4, we begin to show how simple classes may be defined from scratch. We discuss the ways in which objects use attributes to maintain their state and the importance of protecting those attributes from inappropriate modification. It is at this early stage that the concepts of accessors, mutators, and encapsulation are introduced.
In Chapter 5, we start to introduce the core features of Java that enable behavior to be added to class definitions. We concentrate on straight-line sequences of statements, and discuss arithmetic expressions.
In Chapter 6, we continue to add behavior to classes but introduce statements that allow objects to perform alternative sequences of statements. We include a discussion of Boolean expressions, which are used to control this behavior.
In Chapter 7, the ability to repeat statements is added to class definitions. By the end of this chapter, we are able to use the three fundamental elements of behavior - sequence, choice, and repetition.
In Chapter 8, we introduce packages-Java's means of grouping related classes. We include a description of several pre-defined classes that are used over and over again in programs: Math, String, and StringBuffer.
In Chapter 9, we describe array objects, which make it possible to group related objects or items of data into fixed-sized collections.
In Chapter 10, we introduce classes that support arbitrary-sized collections of objects. While most programming languages provide array facilities, Java adds standard collection classes that other languages often leave to programmers to create for themselves.
In Chapter 11, we explore Java's exception-handling mechanism. This provides a way for objects to indicate when an unexpected situation has arisen with which they do not know how to deal. Complementary to this is the ability to `catch' exceptions and develop work-grounds for the problems encountered.
In Chapter 12, we look at some of the many ways in which a program can interact with the external file system, via pre-defined input-output classes.
In Chapter 13, we investigate Java's interface facility. In earlier chapters we use the term 'public interface' informally, but this chapter explores the issue in more depth. Central to it is the concept of polymorphism. Since polymorphism is such a fundamental concept in any objectoriented language, we continue our discussion of it in the next chapter.
In Chapter 14, we take the discussion of polymorphism one stage further by describing Java's extends facility for class inheritance. Inheritance provides the ability to derive new classes that inherit much of their code and functionality from existing classes. Among other things, this permits code reuse. As part of the material in this chapter, we discuss alternatives to inheritance and inappropriate inheritance.
In Chapter 15, we look at abstract classes, nested classes, and nested interfaces. By the end of this chapter, we have covered most of the main features of the Java language. Apart from Chapter 18, therefore, the remaining chapters are largely concerned with using these features in different applications; such as graphical programming, networking, and simulation.
In Chapter 16, we describe the classes of the Abstract Windowing Toolkit (AWT). The AWT provides a powerful collection of classes that simplify the creation of applications with graphical user interfaces. They free a programmer from a need to know details of the windowing environment in which their programs will be run. For the sake of generality, we concentrate on standalone applications, rather than applets. Applets are covered, separately, in Chapter 20.
In Chapter 17, we continue the description of Java's graphical features. This chapter covers the Swing classes, which build on the AWT facilities to provide a more complex set of classes, and greater programmer control over the look-and-feel of a program.
In Chapter 18, we introdu...
From the Back Cover:
• An objects-early approach showing how to design and use fully-fledged objects.
• An accessible introduction to the fundamental object-oriented topics of polymorphism and inheritance.
• Significant coverage of GUI classes belonging to both Abstract Windowing Toolkit (AWT) and Swing (JFC).
• The latest coverage of Java 2 Platform API.
• Usage of power threads for multi-threaded programs.
• Timely coverage of networking, via TCP/IP, to interact with non-Java programs.
• A unique chapter on event-driven simulation.
• Support materials include Prentice Hall's Companion Web site
prenhall/barnes and links to the author's Web site <cs.ukc.ac.uk/people/staff/djb/Book/Index.html>
About the Author: DAVID J. BARNES has lectured and taught Computer Science at the University of Kent at Canterbury, England, since 1983. The University of Kent at Canterbury was Europe's first Authorized Academic Java Campus in agreement with Sun Microsystems, the originators of Java. David Barnes has been a member of the British Computer Society since 1988. His research interests include software engineering and computer science education.
Verry Good Java book, November 13, 2001
Reviewer: A reader from Netherlands
This is one of the best Java Books i've used. It's verry complete and verry easy to search in.
Does not help with your coursework after year one, August 30, 2001
Reviewer: A reader from Canterbury, Kent United Kingdom
A note to UKC CS and CSE students.
It will not help with your second year Networks assignment, which is officially 'not a java programming exercise'.
It Goes Beyond The Introduction!, May 30, 2000
Reviewer: vulinh from San Jose, USA
An excellent Java introduction book! I've found that this book is well-organized and written very clearly. The author also goes beyond the level of an introduction book to explain the fundamental object-oriented design and programming by using Java examples and concepts. Major core Java packages, classes, and interfaces are also covered in depth. Even though I'm wring Java codes for living now, I still love to read this kind of book: A combination of academia and industry. Another advanced Java book that I've found excellent is "Object-oriented Software Development Using Java" written by Xiaoping Jia. These authors will make you love to learn Java!
Computer Graphics / Games: Photoshop Wire | CorelDRAW Wire | PC Games
Graphing Calculators | Shop 4 Calculator
© 2017, Programming Network