introduction
Like any language of human beings, Java provides us with a way of expressing ideas. As compared with other methods, the convenience and flexibility of this expression will be revealed as compared with other ways. Java is not simply imagined into a collection of characteristics; if you look at it, some characteristics are not meaningful. Only the power of Java can only be truly realized when considering "design" instead of considering simple coding. To understand Java in this way, you must first grasp some of its basic concepts and programming. This book discusses programming issues, why they become a problem and Java to solve their methods. So, I have built on how to solve a particular type of problem in a language. In this way, I hope to guide you step by step to enter Java world, making it ultimately a language of your most natural. Through this book, I tried to build a model in your brain - or a "knowledge structure". This can deepen the understanding of the language. If you encounter difficulties, you should learn to fill it in the corresponding place of this model, and then deduct your answer. In fact, when you learn any language, there is a ready-made intellectual structure in your mind that will often play a half-time. 1. Prerequisites this book assume that the reader is familiar with how many programming. The program should have been known that the collection of a series of statements, knows what the subroutine / function / macro is, knows the control statement like "if", and knows the loop structure like "while". Note that these things are similar in a lot of languages. If you have learned a macro language, or use the tools such as Perl, then their basic concepts have no difference. In short, as long as you can get used to basic programming concepts, you can read this book well. Of course, C / C programmers account for more inexpensive when reading. But even if you are not familiar with C, don't exclude yourself (although you will pay more effort). I will tell the concepts of object-oriented programming, as well as the basic control mechanism of Java, so don't worry that you will fight the foundation. Moreover, the first type of knowledge you need to learn will involve basic process control statements. Although there are often some features of C and C languages, they are not intended to make them internal reference, but to help all programmers will look at the two languages correctly. After all, Java is derived from them. I will try to simplify these references and references as much as possible and explain the content that is not familiar with non-C / C programmers. 2. Java's study in my first book "USING C " is almost at the same time (Osborne / McGraw-Hill published in 1989), I started to teach the language. Professor of programming language has become my major. Since 1989, I have seen many drowsy sleeps around the world, full of faces and puzzles. I started to teach in the chamber, I found some special problems from the homework. Even those students who have a smile or frequently noddion of the class, there is also a understanding of many problems. In the "Software Development Conference" over the past few years, I presided over the C group seminars (now become a Java discussion). Some speakers try to infuse too many themes to the audience in a short period of time. So until the end, although the level of the audience is OK, the materials provided are also very sufficient, but some listeners are still lost. This may be because I am too much, but because I am one of the people who take traditional teaching methods, I really want everyone to keep up with lectures. During some time, I have prepared a large number of teaching briefings. After continuous testing and revision (or "repeated", this is a very useful technology in Java programming), and finally successfully integrates all things summed up from my teaching experience - - I am using it for a long time.
It consists of a series of discrete, easy digestive small steps, and there are some appropriate exercises after each small course. I have announced this course at the Java open seminar. You can learn more about http://www.bruceeckel.com (introduction to the workshop is also available in the form of CD-ROM, the specific information is the same Web site is found). Feedback received from each seminar helps me to modify and re-develop the focus of learning materials until I finally think it has become a perfect teaching carrier. But this book is not just a textbook - I tried to load as much information as possible, and in accordance with the topic. In any case, the main purpose of this book is to serve those who learn independently, they are preparing to go deep into a new programming language, and there is not much might attend this professional seminar. 3. The goal is like the previous book "Thinking In C ", this written language professor has a good structure and organization. In particular, my goal is to build a set of organisms to help me better conduct language teaching at their own seminars. When I think about the chapter in the book, I actually want to teach a class. My goal is to get a series of moderate teaching modules that can be taught in a reasonable time. Subsequently some carefully selected exercises, can be done immediately in the classroom. In this book, the goal I want to achieve is summarized as follows: (1) Every time the teaching content advances a small step, which makes it easy for the reader to digest the previous content before continuing. (2) The example used is as short. Of course, doing so sometimes hinders me to solve the problem of "real world". But I also found that for those newcomers, if they can understand each detail, then generally produce greater learning interest. And if they are shocked by the depth and breadth of the issues you have to solve, then it will generally not receive a good learning effect. In addition, in the actual teaching process, the number of codes that can be extracted is severely limited. On the other hand, this will undoubted some people will criticize me to adopt "untrue examples", but as long as it can play a good effect, I would rather accept this accusation. (3) The characteristics to reveal shall be played in sequence in accordance with my carefully selected sequence, and it is in line with the reader's thoughts. Of course, I can't do this forever; in those cases, a brief statement will give this question. (4) I only introduce me to readers, rather than shaking all things I know, this is not a private. I think the importance of information is a reasonable level. Some situations are 95% of the programmers never have to know. If you forced learning, you will only interfere with your normal thinking, so that the language deepened in front of them. Take C language as an example, if you can remember the operator priority form (I can't remember), you can write more "smart" code. But I will think about the first floor, which will also feel troublesome with the reader / maintor of the code. So forget those order, add parentheses when you are not allowed. (5) Each section has a clear learning focus, so teaching time (and interval time of practice) is very short. Do not only keep the reader 's alive, but also make problems more easily, and give yourself a bigger confidence. (6) Provide a solid foundation that readers can fully understand the problem in order to easily turn to some more difficult courses and books. 4. Online documentation is provided by the Java language and library provided by Sun Microsystems (free download) to provide an electronic version of the User Help Manual, which can be read with a web browser. In addition, almost all similar products developed by other vendors have an equivalent document system. This document has been repeated with almost all books related to Java. So you either have it, or you need to download. So this book will not repeat the contents of the document unless otherwise necessary.
Because in general, using a web browser lookup and class-related information is much more convenient than in the book (the electronic version of the edition update is fast). This book will provide some additional instructions about classes when you need to supplement a document, so that you can understand a particular example. 5. Chapter This book carefully considers how people learn Java language. When I lecture, the students reflect the effectively helping I know which parts are more difficult, need to pay special attention. I have also told too many problems once, but the lessons are: If a large number of new features are included, they need to explain all of them, and this is particularly easy to deepen the confusion of students. Therefore, I have made a lot of efforts to make this book more than some issues as much as possible. Therefore, my goal in the book is to let each chapter tell a language characteristic or only tell a few of several interrelated characteristics. In this way, the reader can more easily digest the knowledge learned earlier when turning to the next subject. The following is a brief description of the chapters of this book, and they correspond to the classroom teaching I actually conduct. (1) Chapter 1: Bartry This chapter is a review of object-oriented programming (OOP), including the answer to the basic problem like "What is object", and tells the interface and implementation, abstraction With packaging, messages and functions, inheritance and synthesis, and very important concepts. This chapter will present some of the basic issues created by objects, such as builders, where the object exists, creates where they placed where they are placed and the magic garbage collector (can clear the no longer needed). Other questions to be introduced include the multi-threaded process of the user interface, the multi-threaded process and the Internet, and the like, through the wrong control mechanism implemented by violations. Everyone will learn about what makes Java so special, why is this success, and the problem related to the object-oriented analysis and design. (2) Chapter 2: Everything is the object. This chapter will bring you a place where you can use your first Java program, so you must explain some basic concepts, including the concept of the object "handle"; how to create one Object; an introduction to basic data types and arrays; scope and spam collection to clear the object; how to make all things in Java into a new data type (class), and how to create your own class; function , Argument, return value; visibility of the name and the use of components from other libraries; static keywords; annotations, and embedded documents, etc. (3) Chapter 3: Control Procedure Process This chapter begins with all operators originating from C and C , inherited by Java. In addition, learning operators are not easy to make attention, as well as problems involving shape, promotion, and priority. The basic process control and selection operations will then be described. These are the characteristics of almost all programming languages: select IF-ELSE to achieve selection; with for and while implementation; use Break and Continue and Java label Break and ContiUne (they are considered to be "unknown GOGO" in Java) exit cycle; and use Switch to achieve another form of choice. Although these are common to C and C , there is some differences. In addition to this, all examples are complete Java examples, which makes everyone familiar with Java's appearance. (4) Chapter 4: Initialization and Clear This chapter begins with the builder, its role is the correct implementation of the initialization. The definition of the builder should involve the concept of functions overload (because there may be several builders at the same time). It will then be discussed the clear process, which is not certain as simple as imagining.
After using an object, you can usually do not have to manage it, the garbage collector will automatically intervene, release the memory it occupies. The garbage collector and some of its characteristics are discussed in detail here. In this chapter, we will observe the initialization process more closely: Automatic members initialize, designated members initialization, initialization, Static (static) initialization, and array initialization, etc. (5) Chapter 5: Hide implementation Process This chapter is to explore the way the code is packaged together, and when there is still some part of the exposed state when hidden in the rest of the library. The first thing to discuss is Package and Import keywords, their role is to perform file-level package (package) operations, and allow us to build libraries composed of classes (class libraries). The problem with the directory path and file name at this time. The remaining parts of this chapter will discuss the three keywords of public, private, and protected, "friendly" access, and the meaning of different access control levels in various occasions. (6) Chapter 6: The concept of class regeneration inheritance is an important status in almost all OOP languages. It is an effective way to use existing classes and add new features to it (simultaneously modify it, this is the topic of Chapter 7). When the original code is repeated by inheritance, it is generally necessary to keep the "basic class" unchanged, just connect this or something to achieve the expected results. However, inheritance is not the only means of manufacturing new categories on an existing class. With "synthesis", an object can also be embedded in a new class. In this chapter, you will learn the two methods of reuse the code in Java, and how to apply. (7) Chapter 7: Plorality If you are doing yourself, you may have to spend 9 months to discover and understand the problem, this feature is actually an important foundation for OOP. Through some small, simple examples, readers can know how to create a series of types through inheritance and operate the objects in that series through the basic classes they share. Through Java's velocity concept, all objects in the same series have commonality. This means that the code we have written does not have to rely on specific type information. This makes the program easier to expand, and the inclusiveness is also stronger. As a result, the construction of the program and the maintenance of the code can become more convenient, and the cost pay will be lower. In addition, Java also provides a third pathway for setting up regeneration relationships through the "interface". The so-called "interface" is a pure abstraction of the physical "interface" of the object. Once the concept of versatility is understood, the meaning of the interface is easy to explain. This chapter also introduces you the "internal class" of Java 1.1. (8) Chapter 8: The accommodation of the object For a very simple program, it may only have a fixed number of objects, and the "living time" or "existing time" of the object is known. But usually, our program will create new objects at an uncertain time, only you can understand their details when the program is running. In addition, unless you enter the running period, you can't know the number of objects, and even you can't know the exact type. To solve this common programming problem, we need to have an ability to create any number of objects at any time. The purpose of this chapter is to explore some Java tools used to accommodate them while using objects: from simple array to complex collection (data structure), such as Vector and Hashtable. Finally, we will discuss new and improved Java 1.2 collection libraries. (9) Chapter 9: A violation error Control Java's most basic design tenet is that the organizational error code will not really run. The compiler will capture problems as much as possible. However, in some cases, the problem will not be discovered unless entering the runtime.
These issues are either programming errors, or some natural error conditions, they only appear when they are running normally as a program. Java provides this "illegal control" mechanism for all issues generated by the program run. This chapter will explain Try, Catch, Throw, Throws, and Finally Working Principles in Java. And talk about when it is "throwing" violation, and what operations should be taken after capturing the violation. In addition, everyone will learn some of the standard violations of Java, how to build their own violations, what to do in the builder, and how the violation controller is positioned, and so on. (10) Chapter 10: Java IO System Theory, we can divide any procedures into three parts: input, processing, and output. This means that IO (input / output) is the most critical part of all programs. In this chapter, everyone will learn the various classes provided by Java, how to use them to read and write files, memory blocks, and console. "New" IO of "Old" IO and Java 1.1 will focus on emphasis. In addition, this section also explores how to get an object, "stream" processing (allowing it to be transferred or transmitted over network) and re-builds it. These operations can be done automatically in version 1.1 of Java. In addition, we also discuss the compressed library of Java 1.1, which will be used in Java archive format (JAR). (11) Chapter 11: Operation Type Identification If only one handle pointing to the basic class, Java's runtime class identification (RTTI) enables us to know what the exact type of object is. In general, we need to intend to ignore an accurate type of an object, so that Java's dynamic binding mechanism (versatile) is the correct behavior for that type. But in some occasions, we still need to know what it's accurate type for only one basic handle. After you have this information, you can usually perform a special case more effectively. This chapter will explain the use of RTTI, how to use and how to abandon it when appropriate. In addition, the "reflection" characteristic of Java 1.1 will also be introduced here. (12) Chapter 12: Transfer and Return Objects Since the only way we communicate in Java is "handle", it is very interesting to pass objects into a function and return to an object from that function. This chapter will explain what is in order to manage objects in the function. At the same time, the concept of String (string) class will also solve the same problem in a different way. (13) Chapter 13: Creating a window and programmat Java supports "Abstract Windows Kit" (AWT). This is actually a collection of series, which can solve the window operation problem in a portable form. These windowing programs can be used in the form of a program, and can also be used as a stand-alone application. This chapter will introduce you to AWT and the creation process of online programming. We will also explore the advantages and disadvantages of AWT and some improvements in GUI in GUI. At the same time, important "Java Beans" technology will also be emphasized here. Java Beans is an important basis for creating the "Fast Application Development" (RAD) program constructor. We finally introduced Java 1.2 "Swing" library - it makes Java's UI components have improved significantly. (14) Chapter 14: Multithreaded Java provides a built-in mechanism that provides support for multiple concurrency tasks, we call it "thread". This thread runs in a single program. This is the unique way of operation of multiple sub tasks unless the machine is installed. Although there are many important uses, it is especially important to use a multi-threaded user interface when intended to create a non-sensitive user interface.
For example, after using multi-threaded technology, although there are other tasks at that time, users can still press a button without hindering, or type some text. This chapter will discuss the multi-threaded process mechanism of Java and introduce the relevant syntax. (15) Chapter 15 When network programming begins writing network applications, it will find that all Java features and libraries have already been connected in series. This chapter will explore how to communicate via Internet, and some classes of this programming. In addition, here also demonstrates how to create a Java block, which makes it the same "General Gateway Interface" (CGI) program; revealing how to write CGI programs with C ; also tell the "Java Database Connection" with Java 1.1 ( JDBC) and "Remote Method Call" (RMI) related issues. (16) Chapter 16 Design Paradigm This chapter will discuss it is very important, but it is also a non-traditional "paradigm" programming concept. Everyone will learn an example of the design progress process. First of all, the initial solution, then experience various program logic, constantly reforming the plan into a more appropriate design. Through the study of the whole process, you can experience a way to make design ideas gradually become clear. (17) Chapter 17 This chapter includes a series of projects, or it is based on the contents described earlier in this book, either expansion in previous chapters. These projects are clearly the most complicated books, which effectively demonstrate the application of new technologies and class libraries. Some topics seem to be less suitable for the core position of this book, but I found that it is necessary to discuss them when teaching, these topics are put into the appendix of this book. (18) Appendix A: Use non-Java code to a fully portable Java program that must have some serious defects: the speed is too slow, and the services related to the specific platform cannot be accessed. If you need to use the program in advance, you can consider turn some operations into a "inherent method", which significantly accelerates the speed. These "inherent methods" are actually some special functions to write in another programming language (C / C only). Java can also provide support for non-Java code through other ways, including CORBA. This appendix will be described in detail so that you can create some simple examples, dealing with non-Java code. (19) Appendix B: Contrast C and Java to a C programmer, he should have mastered the basic concepts of object-oriented programming, and Java syntax is undoubtedly very eye-catching. This is obvious because Java itself is derived from C . However, there is a significant difference between C and Java. These differences mean that the major improvements made by Java on the basis of C . Once these differences have been understood, it will understand why Java is an outstanding language. This appendix is set up for this purpose, which tells some of the significant important features that make Java and C . (20) Appendix C: Java Programming Rules This appendix provides a large number of recommendations to help you write low-level programming and code. (21) Appendix D: Performance Through this appendix, you can find bottlenecks existing in its Java program and effectively improve the execution speed. (22) Appendix E: This appendix is described with regard to some words collected by garbage. The operations and methods used to achieve garbage collection. (23) Appendix F: Recommended Readers List the Java References I feel particularly useful. 6. Exercise to consolidate the mastery of new knowledge, I found that simple practice is particularly useful. Therefore, the reader can find a series of exercises at the end of each chapter. Most practices are very simple, can be completed within a reasonable time. If this book is used as a textbook, consider completing in the classroom.
Teacher should pay attention to observation and determine that all students have digest the content of the teach. Some exercises are difficult, they are prepared for those who are interested in deep readers. Most exercises can be done in a shorter time, effectively detect and deepen your knowledge. Some topics are challenging, but they will not be too trouble. In fact, problems encountered in exercises will often encounter in practical applications. 7. Multimedia CD-ROM This book provides a multimedia CD-ROM that can be purchased separately and used. It is different from the ordinary supporting CDs of other computer books, those CDs typically only include the source code used in the book (the source code of this book can be downloaded from www.bruceeckel.com). This CD-ROM is an independent product that includes all the "Hads-onjava" training courses for a week. This is a course with a length of more than 15 hours by Bruce Eckel, including more than 500 demonstrations. The course is based on this book, so it is an ideal supporting product. The CD-ROM contains two versions of this book: (1) This book is prinable, which is exactly the same as the download version. (2) To facilitate the reader to read and index on the screen, the CD-ROM provides a unique hyperlink version. These hyperlinks include: ■ 230 chapters, section and small headings link ■ 3600 cable links CD-ROM burned 600MB of data. I believe it has made a new definition of the so-called "value value". The CD-ROM contains everything that prints the version of this book, and all materials from the five-day quick start courses. I believe it has established a new book quality assessment standard. If you want to purchase this CD-ROM alone, you can only order directly from the Web site www.bruceeckel.com. 8. Source code All source code is provided as a free software that retains copyright, you can get the form of a separate package, or download from http://www.bruceeckel.com. In order to ensure that everyone is the latest version, I use this official site to issue code and this book's electronic version. You can also find an e-book and source mirroring version (some sites have been listed at http://www.bruceeckel.com). But in any case, you should check the official site and determine the mirroring version is indeed the latest version. These codes can be released in class and other educational places. The main goal of copyright is to ensure that the source code gets the correct reference and prevents the code in the printed material in the printing material without permission. Typically, as long as the source code has been properly referenced, there is no problem with the examples of this book in most media. In each source code file, you can discover the following version declaration: 16-17 Program can be used in its own development project and can be referenced in class (including learning materials). However, it is necessary to determine the copyright statement to be reserved in each source file. 9. Coding style In the body, the identifier (function, variable, and class name) is printed in bold. Most keywords also use bold - except for some frequently used keywords (if all bold, it will make the page crowd, such as those "class"). For the example of this book, I use a specific code style. This style has been supported by most Java development environments. The style has been in the past few years, and the earliest originating in the style used by Bjarne Stroustrup in "THE C Programming Language" (Publishing, 2nd Edition). Since the code style is currently a sensitive problem, it is extremely easy to recruit a fierce debate, so I just want to point out that I don't intend to build a style standard through these examples. The reason why these styles are used, completely for my own consideration. Since Java is a very free programming language, the reader can use the appropriate coding style according to their own feel. The book's program is included in the text, and they are directly taken from compilation files.
Therefore, the code files of this book should be able to work properly and will not cause compiler errors. The code that causes the compilation error has been used to note //! So it is easy to find that it is also easy to test in an automated manner. The reader finds and reports to the author's report will be corrected in the source code of the release, and then customize in the update version of this book (all updates will appear at http://www.bruceeckel.com at http://www.bruceeckel.com). 10. Java version Although I tested this book with several manufacturers' Java development platforms, when judging is that the code behavior is correct, it is usually based on Sun's Java development platform. When you read this book, SUN should have issued three important versions of Java: 1.0, 1.1 and 1.2 (Sun claimed to release a major update version every 9 months). As I saw, the 1.1 version has improved the Java language, and it should be marked into version 2.0 (because 1.1 has made such a big revision, I can't imagine what changes will change in version 2.0). However, its version 1.2 seems to eventually put Java into a full day, especially in consideration of the user interface tool. This book mainly discusses 1.0 and version 1.1, and 1.2 has some content involved. But at some time, the new method is significantly better than the old method. At this point, I will obviously be a new method, usually teach everyone a better way, and completely ignore the old method. However, some new methods should be based on old methods, so inevitably want to start with old methods. This feature is especially affinity, because there is not only a large number of old-fashioned Java 1.0 code, and some platforms still support Java 1.0. I will try to point out which feature is unique. Everyone will notice that I have not used submissions, such as 1.1.1. To the time of this book, the last version 1.0 released by Sun is 1.02; and the last version of 1.1 is 1.1.5 (Java 1.2 is still doing beta test). In this book, I will only mention Java 1.0, Java 1.1 and Java 1.2 to avoid typing and printing errors caused by excessive number numbers. 11. Course and Training My company provides a five-day public training course that is based on this book. Each chapter represents a class, and is attached to the corresponding class to consolidate the knowledge learned. Some auxiliary slides can be found on the supporting CD of this book, and the readers are most convenient to readers. For more information, please visit: http://www.bruceeckel.com or send a letter to: Bruce@eckelobjects.com My company also provides consulting services, guiding customers to complete the entire development process - especially your The unit first contact Java development. 12. Errors Whether the author has more effort to avoid, the error is always coming out of the unexpected place. If you think you have discovered an error, please in the source file (found at http://www.bruceeckel.com) Point out that there is a wrong place to fill out the form provided. Send the error correction method to Bruce@eckelobjects.com via an electronics. Correctly corrected the appropriate check and processing, the electronic version of the Web site and the next print version of this book. The specific format is as follows: (1) Write "Tij Correction" on the subject line (remove the quotation mark) so that your party enters the corresponding directory.
(2) In the body of the letter, use the following form: find: Write a single string here so that we can search for the wrong place to comment: Here you can write multi-line approval text, the best "here's how I think it shoud Read "The beginning ###]" ### "pointed out the end of the comment. In this way, I design a corrective tool to "search" for the original text, and your suggested error correction method will pop up in a subsequent window. If you want to add anything on the next version of this book, or what comments on the exercises in the book, you also welcome you. We thank you all your opinions. 13. Cover Design "Thinking In Java" book cover creation inspiration comes from American Arts & Craftsmovement (American Art & Handicraft Movement). This movement starts in the century, and 1900 to 1920 reached its peak. It originated from England, with a historical background. At that time, it was a huge impact of the wind turbines produced by the machine revolution, and was affected by the great impact of strong decorative style in Victoria. Arts & Crafts emphasizes the original style, the original intention of returning to nature is the core of the entire movement. At that time, the handmade production was especially respected. Because of this, people are far away from the use of modern tools. This movement has caused a profound impact on the entire art world until today is still nostalgic. In particular, we face another century, strong nostalgic emotions are inevitable. The computer has been developed to this day, has passed a long way. We are more urgent: the most important thing in software design is the designer itself, rather than streamlined code. If the quality and cultivation of the designer itself are not high, then it is only the tool of "production" code. I look at Java in the same vision: As an attempt to liberate the programmer from the urging mechanism of the operating system, it is the purpose of making people a real "software artist". Regardless of the author or the cover designer of this book (from the child, my friend is my friend). I have been inspired by this move. So the next thing is very simple, or design it yourself, or use the work from that period. In addition, the cover showed a collection box, and natural scholars may use it to show their insect specimens. We believe that these insects are "objects", all in larger "collection box" objects, and then place this object in "Cover". It reveals us the most basic "collection" concept for object-oriented programming technology. Of course, as a programmer, everyone is very sensitive to "insect" or "insect" ("insect" is bug in English, and the program is wrong). The "insect" here has been captured, killing in a wide mouth bottle, and finally disseminating in a small exhibition box - suggesting that Java has the ability to find, "insect" in the program (this is the most Java most One of the characteristics of characteristics). 14. Acknowledgment First, thanks to Doyle Street Cohousing Community (Doul Street Housing Community) tolerate I spend two years to write this book (in fact they have been tolerant "Hu Yue"). I am very grateful to Kevin and Sonda Donovan, who rents me in the city of Crested Butte, so that I can write peace throughout the summer. Thanks to Crested Butte's friendly residents; and Rocky Mountain Biological Laboratory (Rock Mountain Biology Lab), their staff always smile. This is my first time I find an agent to go out, but I have never regret. Thank you Miss Claudette Moore, Moore Literature Agent. It is a strong confidence and perseverance to make me finally dream.
My first two books are published with the editor of the Osborne / McGraw-Hill Press. Jeff also appeared in the right place and the correct time in the Prentice-Hall Press. He also made me feel a pleasant book experience in order to clear all the obstacles that might encounter. Thank you, Jeff - you are very important to me. I would like to thank Gen Kiyooka and his Digigami. The web server I use is what they provide; also thank Scott Callaway, the server is maintained by him. A server is undoubtedly a fairly valuable help during the process of learning the web. Thank you, Cay Horstmann ("Core Java" book, Prentice Hall published in 1997), D'Arcy Smith (Symantec Company) and Paul Tyma ("Java Primer Plus" deputy editor, The Waite Group is in 1996 Annual publication), thank you for helping me clarify some concepts in language. Thanks to the comrades of my Java team in the Java Software Development Conference, as well as those students who have been taught, they raised my lessons. Thank Larry and Tina O'Brien, which is what they put this book and my teaching content into a teaching CD-ROM (about this problem, http://www.bruceeckel.com has more answers) . There are many people sending error correction reports. I really appreciate all of these friends, but I have to say anything to these people. Thank you: Kevin Raulerson (discovers multiple major errors), Bob Resendes (discovered is difficult Record), John Pinto, Joe Dante, Joe Sharp, David Combs (Many Grammar and Unclear), DR. Robert Stephenson, Franklin Chen, Zev Griner, David Karr, Leander A. Stroschein, Steve Clark, Charles A. Lee, AustInmaher, Dennis P. Roth, Roque Oliveira, Douglas Dunn, Dejan Ristic, Neilgalarneau, David B. Malkovsky, Steve Wilkinson, and many other enthusiastic readers. In order to make this book in Europe, PROF. IR. Marc Meurrens has worked a lot. Some technicians have walked into my life, and they have become friends with me later. The most unusual thing is that they are all vegan, usually like to practice yoga work, and other forms of spiritual training. After I practiced, I feel very beneficial to me. They are Kraig Brockschmidt, Genkiyooka and Andrea Provaglio, which helped me to understand the situation of Java and programming in Italy. Obviously, some experiences on Delphi make me more easily understand Java because they have many concepts and language design decisions. My Delphi friend provides a lot of help so that I can inspect some programming environments that are not easy to pay attention.
They are Marco Cantu (another Italian - is it to say that Latin people have a unique advantage when learning Java?), Neil Rubenking (he like yoga / vegetarian / Zen Road, but also very much computer) and zack URLocker (is a comrade that I have visited the world when I travel.). Some of my friends Richard Hale Shaw (and Kim) have played a very critical role. Richard and I spent months ago merged together and explored how students feel the perfect learning experience. Thanks to Koann Vikoren, Eric Eaurot, Deborahsommers, Julie Shaw, Nicole Freeman, Cindy Blair, Barbara Hanscome, Regina Ridley, Alex Dunne, and other respectable members of MFI. Book design, cover design, and cover photos are made by my friend Daniel Will-Harris. He is a famous writer and designer (http://www.willharris.com), which has revealed the mathematical talent of people in junior high school. However, the sample is made by me, so it is mine. I use Microsoft Word 97 for Windows to write this book and use it to generate a small sample. The body font adopts BitStream Carmina; title uses BitStream Calligraph 421 (www.bitstream.com); the symbol of each chapter uses Leonardo extras (http://www.p22.com) from P22; cover font adopts ITC Rennie marckintosh. Thanks to some famous companies that provide compilers: Borland, Microsoft, Symantec, Sybase / PowerSoft / Watcom, and Sun. Special thanks to my teacher and all my students (they are also my teacher), the most interesting written teacher is the author of Gabrielle Rico ("Writing the Natural Way", Putnam published in 1983).
