For introductory courses in Java Programming for business and CIS students. Written by a highly successful teacher and author, this text teaches students how to program in Java from the beginning. Exceptionally readable and student-oriented, it requires no previous programming knowledge and introduces object-oriented programming gently--after students have mastered basic programming concepts.
"synopsis" may belong to another edition of this title.
In recent years, Java has become a premier programming language because of its portability, making it completely platform independent. Java application programs support large systems and commercial "shrink-wrap" software development, while Java applet programs support Internet programming. This book has been written to provide an introduction to programming using the Java language. It is no harder learning how to program using Java than it is using a traditional language such as BASIC, Pascal, or C++. In fact, because of the object-orientation and built-in graphics ability of Java, you can become a productive programmer in much less time than you can using these older languages. The text starts from the beginning, assuming no previous knowledge of any other programming language. The text is appropriate for any introductory programming course using the Java language as well as experienced programmers wanting an introduction to Java.
The text emphasizes problem solving techniques using the Java language. In fact, problem solving is the essential theme throughout the text. The student begins mastering the art of problem solving in Chapter 2, using problem abstraction and stepwise refinement via the Programmer's Algorithm. Emphasis is first placed on the "nuts and bolts" of problem solving and programming, building gradually into the object-oriented programming paradigm. This approach gradually prepares the student for in-depth coverage of classes and objects later in the text, while building essential programming skills. Furthermore, beginning with Chapter 1, a series of GUI10X and Applet10X experiment modules run in parallel with the text chapters to hold student interest and prepare them for in-depth coverage of event-driven, graphics programming discussed in later chapters. The text is highly readable and student oriented, with a teachable pedagogy and excellent features. The text provides sufficient material for a fast-paced one semester course or slower paced two semester course sequence.
Features Highly readable and student oriented. Prepared especially for CIS and MIS students, but will also satisfy the requirements of an introductory programming course for CS students. Thoroughly instructor and student tested. Totally portable, platform independent. Introduces object-oriented programming after students have mastered the basics. Excellent reviews from instructors of both CS and CIS. Presentation and coverage of Java, compliant with version 1.2. Covers both Java applications and applets, with emphasis on CIS applications. A series of GUI10X and Applet10X experiment modules that run in parallel with the text chapters to hold student interest and prepare them for in-depth coverage of event-driven graphics programming discussed in later chapters. Early introduction to problem solving in Chapter 2 and used as a theme throughout the text with 20 Problem Solving In Action case studies. A gentle introduction to classes and objects, beginning in Chapter 3. In-depth coverage of Java classes and objects in Chapter 9. Realistic, real-world business programming examples and case studies throughout. Entire chapter on Graphical User Interfaces, GUIs. The Programmer's Algorithm: A step-by-step process used to get students started on the right programming tract by considering problem definition, solution planning, and good documentation. Problem solving using problem abstraction and stepwise refinement, prior to coding, is stressed throughout the text. All Problem Solving in Action case studies follow these proven software engineering techniques. Early introduction to Java methods in Chapter 2. Discussion of a class at both the abstract and implementation levels provides the student the bigger software design picture as well as the coding details. Comprehensive development of the stack and queue ADTs using Java classes to ensure encapsulation and information hiding. Classes and ADTs viewed as black boxes, thus illustrating the importance of the method interfaces over the implementation details at the software design level. Over 70 tip and note boxes for students throughout, including Programming Tips Programming Notes Style Tips Debugging Tips Debugging Results Caution Boxes Over 300 section-by-section quick-check exercises for students to check their progress with all answers in an appendix. Over 50 examples that pose problems and then give solutions immediately. Over 200 chapter questions. Over 150 chapter programming problems with solutions in an instructor's manual and accompanying disk. Important terms and concepts are magnified and boxed throughout the text. Entire chapter on class inheritance, including a real-world Problem Solving in Action case study for using inheritance via a banking example. All Java syntax formatting is shown throughout within shaded boxes Comprehensive glossary of general computer as well as object-oriented programming and graphics terms. Comprehensive index.
To the Instructor
This text has been written to teach problem solving using the Java language at the freshman level in a first programming course. In today's market, it is imperative that students know both object-oriented programming techniques and the Java language. In this text, students will understand the roles of, and relationship between classes and objects early-on, gradually building into in-depth coverage after they have mastered the language basics.
Some will say that you can't teach a first course in programming using Java, because the language is too complicated. I disagree. I have used Java to teach fundamental structuring and object-oriented concepts and have found that beginning students do not have any more difficulty using Java than BASIC, C++, or Pascal with the approach employed in this text. In fact, they are more enthusiastic about programming and have more fun learning Java because of its graphics and GUI capabilities, as well as the fact that they see Java plastered all over the Internet and news media.
The text can be taught in one or two terms, depending on the ability of the students. In a two term sequence, I would suggest coverage through the topic of methods (Chapters 1-8). Then, begin the second term with classes and objects, in-depth, and finish out the book (Chapters 9-14).
The text begins with a traditional review of hardware and software. This can be covered quickly, especially when students have already been exposed to these topics. Chapter 2 covers problem solving using problem abstraction and stepwise refinement. These concepts are presented in detail here and used as a theme throughout the text. The chapter discusses problem solving using what I call The Programmer's Algorithm and should be covered thoroughly. The programmer's algorithm is a step-by-step process that I have used to get students started on the right programming track by considering problem definition, step-by-step solution planning, and good documentation. I have employed a pseudocode algorithmic language for problem solution that is generic, simple, and allows for easy translation to the coded Java program. In addition, Chapter 2 introduces students to Java methods as a way of implementing their problem solutions.
Chapter 3 introduces the concepts of data abstraction and ADTs. Traditional data types are covered here as well as how to define constants, variables, and objects. Here is where we begin planting the seeds for object-oriented programming before it is covered in-depth in Chapter 9. I suggest that you emphasize the concepts of classes, objects, and ADTs here to get students accustomed to object-oriented concepts.
In Chapters 4-7, students learn about program I/O, decision making, and iteration. These chapters provide the "nuts and bolts" required to write workable Java programs. The sequence, decision, and iteration control structures available in Java are covered thoroughly, emphasizing program logic and the required Java syntax. The common pitfalls of program logic design are pointed out throughout this material via program debugging tips and programming notes boxes. Again, I have integrated object-oriented techniques within these traditional structured programming topics, especially in Chapter 4 when using classes and objects for I/O. I have provided a Java package called keyboardInput on the accompanying CD and used its KeyboardInput class to perform program I/O throughout the text. Since Java treats all I/O as string I/O, you must develop your own classes and methods to provide for simple numeric and character I/O. This is much to complex for the beginning student and is the reason for my keyboardInput package. Later in the text, I "up-wrap" this package to expose its internal workings.
After Chapter 7, your students will have a solid knowledge of the important role of methods for program structuring. Since Chapter 2, they have been designing programs using functional decomposition and have observed the role of methods relative to object behavior. In Chapter 8, methods are covered in-depth. I have incorporated easy to follow guidelines for building method interfaces relative to the topics of return values and parameter passing. It is critical that students understand this material in order to become successful Java programmers and understand the object-oriented concepts presented in later chapters.
At this point, the student is prepared to learn about classes and objects in-depth. Again, there should be no problem here, because I have integrated these topics into the course since Chapter 3. In-depth coverage of classes and objects is provided in Chapter 9 and a solid introduction to class inheritance is provided in Chapter 10. In Chapter 9, students learn how to create their own classes and objects, using them in object-oriented programs. Chapter 10 expands on the material in Chapter 9 by discussing inheritance. Many texts avoid the topic of inheritance. However, inheritance is one of the cornerstones of OOP and is relatively easy to cover at this point. Chapter 10 provides the student with solid understanding of inheritance through a comprehensive banking example. The chapter closes with a discussion of polymorphism and dynamic binding.
Chapter 11 is devoted entirely to designing graphical user interfaces, or GUIs. By this time, the student has experimented extensively with GUIs via the GUI10X modules attached to previous chapters. The material in Chapter 11 simply fills in the details and solidifies the students knowledge of GUIs and how to create them. A comprehensive GUI design problem is provided in a Problem Solving in Action case study at the end of the chapter. In addition, an Applet10X module is attached to this chapter to teach the student how to use the Java Graphics class to create graphical images for both Java applet and application programs to augment their GUI designs.
File manipulation is discussed in-depth in Chapter 12. Here, the student learns how to read and write sequential disk files using Java classes. The topic of files in Java provides a great opportunity to show how Java employs inheritance to create reusable code. Here, the student learns how to employ inheritance through the Java file stream class hierarchy to implement files.
Students get their first exposure to data structures in Chapter 13, which covers one-dimensional arrays. I feel it is important that students have a solid knowledge of arrays and their manipulation. As result, this chapter covers traditional arrays and not some array class built by the author to hide the details and pitfalls associated with arrays. I have also used this topic to present several classic searching and sorting algorithms which are essential at this level. This chapter can be covered earlier, prior to classes and objects, if desired without loss of continuity.
Chapter 14 provides an introduction to recursion and ADTs. Recursion is introduced via a simple compound interest example, followed by and in-depth discussion of how recursion works and when it should be applied. A comprehensive Problem Solving in Action case study is provided on recursive binary search. Next, the classic stack and queue ADTs are covered thoroughly. In this chapter, ADTs are covered at two levels: The purely abstract level using the black box interface approach, and at the implementation level using Java classes. Here is where the student really appreciates object-oriented programming, because the stack and queue ADTs are naturally implemented using Java classes.
Finally, beginning with Chapter 1, a series of GUI10X and Applet10X experiment modules run in parallel with the text chapters to hold student interest and prepare them for in-depth study of event-driven graphics programming discussed in later chapters. Encourage your students to go through these modules and just have some fun. They are designed to hold their interest as well as plant some important seeds which will be cultured later on in the text. Give them plenty of computer time and encourage them to try different things. If they ask "What happens if I do this or that?" Tell them to "try it." This is how they will really learn!
The following supplements are available to support this text:
GUI10X, Applet10X, and Problem Solving in Action source code included on the accompanying CD. JBuilder University edition from Inprise (formally Borland) included on the accompanying CD. A solutions manual that provides solutions to all the chapter questions and problems. An instructor's disk that provides source code to all the chapter programming problems. A companion Web site at prenhall that provides materials for instructors, such as transparency masters, as well as students, such as an on-line study guide.
To the Student
The market demands that computing professionals know the latest programming and software engineering techniques to solve today's complex problems. This book has been written to do just that. The book has been written to provide you with an introduction to problem solving using object-oriented programming techniques and the Java language. The text emphasizes problem solution through the use of problem abstraction and stepwise refinement throughout. By the end of the text you will have the knowledge required to solve complicated problems using this methodical approach that today's computer solutions require. In addition, you will learn about object-oriented programming (OOP), graphical user interfaces, or GUIs, graphics programming, and abstract data types (ADTs).
Make sure that you go through all the examples and Problem Solving in Action case studies. These have been written in short, understandable modules that stress the fundamental concepts being discussed. These problems are integrated into the text at key points in an effort to tie things together and present a methodical design approach to problem solving using the Java language.
Finally, above all, get your hands dirty early and often! Just have some fun programming. Don't be afraid to try different things. A series of GUI10X and Applet10X modules have been provided beginning in Chapter 1 to let you do just that. All the code for these modules is included on the accompanying CD or can be downloaded from prenhall. Have fun experimenting with these modules. Become an active learner. You cannot become a competent programmer by just reading this book and listening to your instructor's lectures. You must get your hands dirty at the machine. Get started early by sitting down at a computer, getting acquainted with your Java compiler, running the GUI10X and Applet10X experiment modules as you go through this text, and writing your own Java programs. This is how you will really learn how to program in Java.
To the Professional
“This is an excellent book. After reading so many that are not, or are at best just adequate, this book really tries (and most often succeeds) to reach the student-a seemingly often forgotten part of the intro text equation. The chapters are sensible, well paced, and well organized. The use of graphic modules throughout will be very effective. It was a brilliant idea.”
—Dr. M.C.Schraefel, University of Victoria
“The material is very readable, clear, rich in terms of examples, excellent learning format, and so forth. I really like the presentation.”
—Alan L. Eliason, Graduate School of Management at Willamette University
Java has become a premier programming language because of its portability, Internet programming capabilities, and object-orientation. Emphasizing problem-solving techniques, this successful author takes advantage of Java's object-orientation and built-in graphics to teach students and professionals how to program.
Author of 19 textbooks and winner of two prestigious college and university teaching excellence awards, STAUGAARD knows what will work in your introductory Java class.
"About this title" may belong to another edition of this title.
Book Description Prentice Hall. Book Condition: Good. . Bookseller Inventory # N07G-00610
Book Description Prentice-Hall, Harlow, Essex, United Kingdom, 1999. paperback. Book Condition: Very Good. 8vo. includes cd-rom. Bookseller Inventory # 247
Book Description Paperback. Book Condition: Good. The book has been read but remains in clean condition. All pages are intact and the cover is intact. Some minor wear to the spine. Bookseller Inventory # GOR004435692
Book Description Prentice Hall, 1999. Textbook Binding. Book Condition: Used: Good. Bookseller Inventory # SONG0130108065
Book Description Prentice Hall, 1999. Textbook Binding. Book Condition: Near Fine. Near Fine. book. Bookseller Inventory # F5S7-1-Z-0130108065-3