Fundamentals of OOP and Data Structures in Java by Richard Wiener - 9780521662208 - Compare Prices on New & Used Textbooks, Cheap Textbooks

GetTextbooks.co.uk
Compare Prices & Save up to 90%

Search by ISBN, title, author, etc ...

		Fundamentals of OOP and Data Structures in Java by Richard Wiener, Lewis J. Pinson ISBN-10: 9780521662208 ISBN-10: 0-521-66220-6 ISBN-13: 9780521662208 ISBN-13: 978-0-521-66220-8 Hardcover 2000-06-05 Cambridge University Press Find Lowest Price
Editorials

Product Description Fundamentals of OOP and Data Structures in Java presents the fundamentals of Object-Oriented Programming (OOP) and Graphical User Interface (GUI) programming with Java as the example language. Wiener and Pinson introduce each of the major data structures with supporting, GUI-based laboratory programs designed to reinforce the basic concepts and principles. These laboratories allow the reader to explore and experiment with the properties of each data structure. All source code for the laboratories is available on the Web. By integrating the principles of OOP and GUI programming, this unique book presents the fundamental issues of data structures within the context of paradigms that are essential to today's professional software developer. The text assumes only an elementary understanding of Java and no experience with OOP.
Book Description Fundamentals of OOP and Data Structures in Java is for an course on classical data structures. Part one of the book presents the basic principles of Object-Oriented Programming (OOP) and Graphical User Interface (GUI) programming with Java. Part two introduces each data structure with GUI-based laboratory programs designed to reinforce the basic principles of the text. These laboratories allow the reader to experiment with the properties of each data structure. By integrating the principles of OOP and GUI programming, this book presents the fundamental issues of data structures in the context of paradigms that are essential to today's professional software developer.
Reviews

Book is too dated to use now (as of 2005) After reading the first three chapters, I had to conclude that the book was too dated to use. Here are some of its problems: (1) The book and previous reviewers speak of code that can be downloaded from the publisher's web site; the publisher no longer makes such downloads available. (2) With respect to software design methodologies, the author embraces "design by contract" which was championed by Bertrand Meyer in 1997 in "Object-Oriented Software Construction." This approach has pretty much been left by the wayside, with "patterns" being the currently touted approach. The author also adheres to a design methodology which rigidly classifies object messages as being either commands (methods that change the internal state of the object) or queries (methods that report back on the object's internal state). When it was time to implement stacks, this rigid adherence put him in a quandry. Traditionally "popping" a stack results in both situtations: the topmost value is returned by the pop (like a query) and the internal state of the stack is changed (like a command). To adhere to the command/query dichotomy, the author made popping a two-process. "Pop" changes the internal state of the stack, storing the topmost element in an internal field and reducing the size of the stack by one. However in order to restrict popping to "command" status, the topmost value is not reported back to the invoking code. Instead the user has to issue a subsequent "query" requesting the value of the topmost element. This implementation is oblivious to the impact that such a two-step process would have in a threaded environment. If thread_2 issues a pop command after thread_1 pops, but prior to thread_1 querying for the topmost value, the topmost element would be lost forever. (3) The author makes use of Java classes that have since been deprecated. For instance he uses the Vector class, which has been more or less replaced by ArrayList. (4) The author's convention for naming methods isn't in line with the current, prevailing conventions. For "commands" he uses various action words followed by a noun which describes the field being impacted by the command. For "queries" he restricts the name to a noun or noun phrase which describes the field value that's being returned. However it is now more common to see "commands" named "setField()" and "queries" named "getField()". Many IDE's automatically create method names utilizing the "set" and "get" naming convention. For these reasons, I can no longer recommend the book.
A book that fills a real need in the CS curriculum The relative newness and the complexity of Java have created an enormous amount of difficulty for those who teach it in the CS curriculums around the world. While the structure of the computer science major is also not a stable entity, there are some constants that must be covered. A course in data structures is a staple in the beginning, generally being taken after the first course in programming in the main language used in the major. The problem has been that Java is such a large language, there are so many different ways to teach the first course. This has required textbooks in data structures using Java to either assume very little or to assume too much. This book takes a middle, very effective approach. The assumptions are that the reader has a good deal of programming knowledge, but not necessarily in Java or any other object-oriented language. Part one is devoted to a survey of object-oriented programming in general and how it is done in Java in particular. An instructor could use it to prep the students familiar with programming in other languages or to fill the holes of any material not covered in previous courses. The main point of the book is of course the coverage and explanation of the standard data structures used in programming. These structures are described by a combination of explanation and a great deal of source code. To help prevent the cramps in the fingers and brain that would come from typing it all in, all source code is available online. This is especially helpful because exercises are included at the end of the chapters and many of them involve modification of the code in the text. Turning good code into bad code by mucking with it and then correcting it is far and away the best way to learn to program, since that is how we program anyway. This is a backhand way of saying that the exercises make excellent short, yet challenging programming assignments. Data structures has often been the course where computer science students are set on the track to performing significant work in the field. Good data structures texts in Java have been lacking, so this book fills a significant void. Definitely worth examining for adoption.
Selecting a Java textbook for teaching a Graduate Seminar September 8, 2000 It is customary as Professor of Computer Science at Long Island University for me routinely to review and select textbooks about Object-Oriented programming and Data Structures in Java and other programming languages for both undergraduate and graduate classes. Almost every day the Computer Science professors receive desk copies of new computer textbooks from publishing houses. Most textbooks are unacceptable for one reason or another. Either they don't cover their subject adequately; appear to be written for the author's peers rather than for the student, or coded examples don't work so the book is rejected. Recently, while attempting to select a textbook on Object-Oriented programming and Data Structures in Java for both undergraduate and graduate seminars for the fall term 2000, I discovered one outstanding book: Fundamentals of OOP and Data Structures in Java by Richard Wiener and Lewis J. Pinson, published by Cambridge University Press, ISBN No. 0-521-66220-6. Fundamentals of OOP and Data Structures in Java is written in a clear, concise style with numerous examples that WORK. This textbook is written with students in mind, not the authors' peers. It is evident that Professors Wiener and Pinson understand data structures, their intended use in any programming environment, and when and how to use them. Conceptually, their presentation makes this book a must for any class that focuses on Data Structures and Object-Oriented programming in Java. I particularly like "Part Two: Data Structures." This section discusses "Abstract Data Types," "Containers as Abstract Data Types," and the classic data structures themselves. No important topic is bypassed or perfunctorily treated. Clear explanations and examples abound. Students, professors, or anyone interested in object-oriented programming and data structures in Java, BUY THIS BOOK! Professor Dwight Peltzer Dept. of Computer Science Long Island University Brookville, NY
Selecting a Java textbook for teaching a Graduate Seminar September 8, 2000 It is customary as Professor of Computer Science at Long Island University for me routinely to review and select textbooks about Object-Oriented programming and Data Structures in Java and other programming languages for both undergraduate and graduate classes. Almost every day the Computer Science professors receive desk copies of new computer textbooks from publishing houses. Most textbooks are unacceptable for one reason or another. Either they don't cover their subject adequately; appear to be written for the author's peers rather than for the student, or coded examples don't work so the book is rejected. Recently, while attempting to select a textbook on Object-Oriented programming and Data Structures in Java for both undergraduate and graduate seminars for the fall term 2000, I discovered one outstanding book: Fundamentals of OOP and Data Structures in Java by Richard Wiener and Lewis J. Pinson, published by Cambridge University Press, ISBN No. 0-521-66220-6. Fundamentals of OOP and Data Structures in Java is written in a clear, concise style with numerous examples that WORK. This textbook is written with students in mind, not the authors' peers. It is evident that Professors Wiener and Pinson understand data structures, their intended use in any programming environment, and when and how to use them. Conceptually, their presentation makes this book a must for any class that focuses on Data Structures and Object-Oriented programming in Java. I particularly like "Part Two: Data Structures." This section discusses "Abstract Data Types," "Containers as Abstract Data Types," and the classic data structures themselves. No important topic is bypassed or perfunctorily treated. Clear explanations and examples abound. Students, professors, or anyone interested in object-oriented programming and data structures in Java, BUY THIS BOOK! Professor Dwight Peltzer Dept. of Computer Science Long Island University Brookville, NY
Academically Comprehensive for the OO Programmer Dr. Wiener and Dr. Pinion have distinguished them selves once again as long time academicians in the Object Oriented Programming paradigm. This book is not for the casual Java programmer. It becomes obvious as you study this book that the authors are truly dedicated to OOP. This excellent CS-2 level textbook is uniquely divided into two parts: (1) Foundations and (2) Data Structures. Part One provides the student of Java as well as the professional Java programmer a comprehensively in-depth review of the fundamental building blocks so necessary for competency in OOP with the Java programming language. This section is populated with rich examples to enhance student understanding. Each chapter concludes with reinforcement exercises uniquely designed to support learning objectives. The authors have developed an exceptional thread of continuity throughout Part One to lead you into Part Two. The student should not skip/jump any section for Part One is uniquely compressed stressing the absolute essentials in OOP, which in-fact superbly prepares the reader for Part Two "Data Structures." Part Two is where the authors truly demonstrate their years of experience in academia teaching the concepts of the Abstract Data Type (ADT). Their previous teaching experience in several programming languages is brought to light in their comprehensive approach as they lead the student into this prime area supporting object-oriented software development. Again as in the first section, each chapter is uniquely inclusive of clearly designed examples to support the student's understanding of the ADT concepts so essential for the OOP student or professional programmer. The authors provide a multitude of interface code listings and classes that extend and implement other classes uniquely designed to enhance student understanding. They also provide a rich set of exercises which supports the students understanding requiring the student to complete as programming assignments. To ease the students testing their code, the authors have provided an excellent set of GUI Lab applications, which are uniquely designed for the various programming exercises. I teach Java programming at the CS-1 level and personally have used several of the author's examples to support my class lectures in preparation for the students' entry into the second level CS-2. This comprehensive CS-2 level textbook is well worth considering for both the academic and professional teaching environments.

[ United States | Canada ]