书籍详情

Java编程思想:英文版

Java编程思想:英文版

作者:(美)Bruce Eckel著

出版社:机械工业出版社

出版时间:2003-01-01

ISBN:9787111092865

定价:¥69.00

购买这本书可以去
内容简介
  From the fundamentals of Java syntax to its most advanced features (distributed computing, advanced Object-oriented capabilities, multithreading), Thinking In Java is designed to teach. Bruce Eckel's readable style and small, direct programming examples malce even the most arcane concepts clear.
作者简介
  作者:BruceEckelBruceEckel从1986年至今,已经发表了超过150篇计算机技术文章,出版了6本书(其中4本是关于C++的),并且在全世界做了数百次演讲。他是《ThinkinginJava》、《ThinkinginC++》、《C++Inside&Out》《UsingC++》和《ThinkinginPatterns》的作者,同时还是《BlackBeltC++》文集的编辑。他的《ThinkinginC++》一本书在1995年被评为“最佳软件开发图书”,《ThinkinginJava》被评为1999年JavaWorld“最爱读者欢迎图书”,并且赢得了编辑首选图书奖。C++编程思想第2卷:实用编程技术>>更多作品
目录
Preface                  
 Preface to the 2nd edition                  
 The CD ROM                  
 Introduction                  
 Prerequisites                  
 LearningJava                  
 Goals                  
 Online documentation                  
 Chapters                  
 Exercises                  
 Multirnedia CD ROM                  
 Source code                  
 Java versions                  
 Seminars and                  
 mentoring                  
 Errors                  
 Note on the cover design                  
 Acknowledgements                  
 Introduction                  
 Objects                  
 The progress                  
 of abstraction                  
 An object has                  
 an interface                  
 The hidden                  
 implementation                  
 Reusing the                  
 implementation                  
 Inheritance: reusing                  
 the interface                  
 Interchangeable objects                  
 with polymorphism                  
 Object landscapes and                  
 lifetimes                  
 Exception handling:                  
 dealing with errors                  
 Multithreading                  
 Persistence                  
 Java and the lnternet                  
 Analysis and design                  
 Extreme programming                  
 Why Java succeeds                  
 Strategies for transition                  
 Java vs. C++?                  
 Summary                  
 2: Everything is                  
 an Object                  
 You manipolate objects                  
 with references                  
 You must create                  
 all the objeas                  
 You never need to                  
 destroy an object                  
 Creating new data                  
 types: class                  
 Methods, arguments,                  
 and return values                  
 Building a                  
 Java program                  
 Your first Java program                  
 Comments and embedded                  
 docomentation                  
 Coding style                  
 Summary                  
 Exercises                  
 3 : Controlling                  
 Program Flow                  
 Using Java operators                  
 Execution control                  
 Sommary                  
 Exercises                  
 i4: Initialization                  
 & Cleanup                  
 Guaranteed initialization                  
 with the constructor                  
 Method overloading                  
 Cleanup : finalization                  
 and garbage collection                  
 Member initialization                  
 Array initialization                  
 Summary                  
 Exercises                  
 5:Hidingthe                  
 Implem                  
 package:                  
 the libraty unit                  
 Java access specifiers                  
 Interface and                  
 implementation                  
 Class access                  
 Summary                  
 Exercises                  
 6: Reusing-Classes                  
 Composition syntax                  
 Inheritance syntax                  
 Combining composition                  
 and inheritance                  
 Choosing composition                  
 vs. inheritance                  
 protected                  
 Incremental                  
 development                  
 Upcasting                  
 The final keyword                  
 lnitialization and                  
 class loading                  
 Summary                  
 Exercises                  
 7:Polymorphism                  
 Upcasting revisited                  
 The twist                  
 Overriding vs.                  
 overloading                  
 Abstract classes                  
 and methods                  
 Constructors and                  
 polymorphism                  
 Designing with                  
 inheritance                  
 Summary                  
 Exercises                  
 8:Interfaces&                  
 InnerClassex                  
 Interfaces                  
 Inner classes                  
 Summary                  
 Exercises                  
 9: Holding                  
 YourObjects                  
 Arrays                  
 Introduction to                  
 containers                  
 Container disadvantage:                  
 unknown type                  
 Iterators                  
 Container taxonomy                  
 Collection                  
 functionality                  
 List functionality                  
 Set functionality                  
 Map functionality                  
 Holding references                  
 Iterators revisited                  
 Choosing an                  
 implementation                  
 Sorting and                  
 searching Lists                  
 Utilities                  
 Unsupported                  
 operations                  
 Java 1.0/1.1containers                  
 Summary                  
 Exercises                  
 10:Error Handing                  
 with Exceptions                  
 Basic exceptions                  
 Catching an exception                  
 Creating your own                  
 exceptions                  
 The exception                  
 specification                  
 Standard Java                  
 exceptions                  
 Performing cleanup                  
 with finally                  
 Exception restrictions                  
 Constructors                  
 Exception matching                  
 Summary                  
 Exercises                  
 11:The Java                  
 I/O System                  
 the File class                  
 Input and output                  
 Adding attributes                  
 and useful interfaces                  
 Readers&Writers                  
 Off by itself:                  
 RandomAccessFile                  
 Typical uses of                  
 I/O streams                  
 Standard I/O                  
 Compression                  
 Object serialization                  
 Tokenizing input                  
 Summary                  
 Exercises                  
 12:Run-time Type                  
 Identification                  
 The need for RTTI                  
 RTTI syntax                  
 Reflection:run-time                  
 class information                  
 Summary                  
 Exercises                  
 13:Creation windows                  
 &Appets                  
 The basic applet                  
 Running applets from                  
 the command line                  
 Making a button                  
 Capturing an event                  
 Text areas                  
 Controlling layout                  
 The Swing event model                  
 A catalig of Swing                  
 components                  
 Packaging an applet                  
 into a JAR file                  
 Programming                  
 techniques                  
 Visual programming                  
 and Beans                  
 Summary                  
 Exercises                  
 14:Multiple Threads                  
 Responsive                  
 userinterfaces                  
 Sharing                  
 limited resources                  
 Blocking                  
 Priorities                  
 Runnable revisited                  
 Summary                  
 Exercises                  
 15:Distributed                  
 Computing                  
 Network programming                  
 Java Database                  
 Connectivity(JDBC)                  
 Servlets                  
 Java Server Pages                  
 RMI(RemoteMethod                  
 Invocation)                  
 CORBA                  
 Enterprise JavaBeans                  
 Jini:distributed                  
 services                  
 Summary                  
 Exercises                  
 A:Passing&                  
 Returning Objects                  
 Passing                  
 references around                  
 Making local copies                  
 Controlling                  
 cloneability                  
 Read-only classes                  
 Summary                  
 Exercises                  
 B:The JavaNative                  
 Interface(JNI)                  
 Calling a                  
 native method                  
 Accessing JNI functions:                  
 the JNIEnvargument.1069                  
 Passing and                  
 using Java objects                  
 JNI and                  
 Javaexceptions                  
 JNIand threading                  
 Using a preexisting                  
 code base                  
 Additional                  
 information                  
 C:Java Programming                  
 Guidelines                  
 design                  
 Implementation                  
 D: Resources                  
 Software                  
 Books                  
 Index                  
                   

猜您喜欢

读书导航