Thinking in Java: Eckel, Bruce: 9780131872486: Book: : eCampus.com

Preface

(1)

Java SE5 and SE6

(1)

Java SE6

(1)

The 4th edition

(1)

Changes

(2)

Note on the cover design

(1)

Acknowledgements

(6)

Introduction

(10)

Prerequisites

(1)

Learning Java

(1)

Goals

(1)

Teaching from this book

(1)

JDK HTML documentation

(1)

Exercises

(1)

Foundations for Java

(1)

Source code

(3)

Coding standards

(1)

Errors

(2)

Introduction to Objects

(38)

The progress of abstraction

(2)

An object has an interface

(3)

An object provides services

(1)

The hidden implementation

(2)

Reusing the implementation

(1)

Inheritance

(5)

Is-a vs. is-like-a relationships

(1)

Interchangeable objects with polymorphism

(5)

The singly rooted hierarchy

(1)

Containers

(2)

Parameterized types (Generics)

(1)

Object creation & lifetime

(3)

Exception handling: dealing with errors

(1)

Concurrent programming

(1)

Java and the Internet

(9)

What is the Web?

(2)

Client-side programming

(6)

Server-side programming

(1)

Summary

(1)

Everything Is an Object

(32)

You manipulate objects with references

(2)

You must create all the objects

(4)

Where storage lives

(2)

Special case: primitive types

(1)

Arrays in Java

(1)

You never need to destroy an object

(2)

Scoping

(1)

Scope of objects

(1)

Creating new data types: class

(3)

Fields and methods

(2)

Methods, arguments, and return values

(2)

The argument list

(1)

Building a Java program

(4)

Name visibility

(1)

Using other components

(1)

The static keyword

(2)

Your first Java program

(3)

Compiling and running

(1)

Comments and embedded documentation

(7)

Comment documentation

(1)

Syntax

(1)

Embedded HTML

(1)

Some example tags

(2)

Documentation example

(1)

Coding style

(1)

Summary

(1)

Exercises

(4)

Operators

(42)

Simpler print statements

(1)

Using Java operators

(1)

Precedence

(1)

Assignment

(3)

Aliasing during method calls

(1)

Mathematical operators

(3)

Unary minus and plus operators

101

(1)

Auto increment and decrement

101

(2)

Relational operators

103

(2)

Testing object equivalence

103

(2)

Logical operators

105

(3)

Short-circuiting

106

(2)

Literals

108

(3)

Exponential notation

109

(2)

Bitwise operators

111

(1)

Shift operators

112

(4)

Ternary if-else operator

116

(2)

String operator + and +=

118

(1)

Common pitfalls when using operators

119

(1)

Casting operators

120

(2)

Truncation and rounding

121

(1)

Promotion

122

(1)

Java has no ``sizeof''

122

(1)

A compendium of operators

123

(10)

Summary

133

(2)

Controlling Execution

135

(20)

true and false

135

(1)

if-else

135

(2)

Iteration

137

(3)

do-while

138

(1)

for

138

(2)

The comma operator

140

(1)

Foreach syntax

140

(3)

return

143

(1)

break and continue

144

(2)

The infamous ``goto''

146

(5)

switch

151

(3)

Summary

154

(1)

Initialization & Cleanup

155

(54)

Guaranteed initialization with the constructor

155

(3)

Method overloading

158

(8)

Distinguishing overloaded methods

160

(1)

Overloading with primitives

161

(4)

Overloading on return values

165

(1)

Default constructors

166

(1)

The this keyword

167

(6)

Calling constructors from constructors

170

(2)

The meaning of static

172

(1)

Cleanup: finalization and garbage collection

173

(8)

What is finalize() for?

174

(1)

You must perform cleanup

175

(1)

The termination condition

176

(2)

How a garbage collector works

178

(3)

Member initialization

181

(4)

Specifying initialization

183

(2)

Constructor initialization

185

(8)

Order of initialization

185

(1)

static data initialization

186

(4)

Explicit static initialization

190

(1)

Non-static instance initialization

191

(2)

Array initialization

193

(11)

Variable argument lists

198

(6)

Enumerated types

204

(3)

Summary

207

(2)

Access Control

209

(28)

package: the library unit

210

(11)

Code organization

212

(1)

Creating unique package names

213

(4)

A custom tool library

217

(3)

Using imports to change behavior

220

(1)

Package caveat

220

(1)

Java access specifiers

221

(7)

Package access

221

(1)

public: interface access

222

(2)

private: you can't touch that!

224

(1)

protected: inheritance access

225

(3)

Interface and implementation

228

(1)

Class access

229

(4)

Summary

233

(4)

Reusing Classes

237

(40)

Composition syntax

237

(4)

Inheritance syntax

241

(5)

Initializing the base class

244

(2)

Delegation

246

(3)

Combining composition and inheritance

249

(7)

Guaranteeing proper cleanup

251

(4)

Name hiding

255

(1)

Choosing composition vs. inheritance

256

(2)

protected

258

(2)

Upcasting

260

(2)

Why ``upcasting''?

261

(1)

Composition vs. inheritance revisited

261

(1)

The final keyword

262

(10)

final data

262

(5)

final methods

267

(3)

final classes

270

(1)

final caution

271

(1)

Initialization and class loading

272

(2)

Initialization with inheritance

272

(2)

Summary

274

(3)

Polymorphism

277

(34)

Upcasting revisited

278

(3)

Forgetting the object type

279

(2)

The twist

281

(12)

Method-call binding

281

(1)

Producing the right behavior

282

(4)

Extensibility

286

(4)

Pitfall: ``overriding'' private methods

290

(1)

Pitfall: fields and static methods

290

(3)

Constructors and polymorphism

293

(10)

Order of constructor calls

293

(2)

Inheritance and cleanup

295

(6)

Behavior of polymorphic methods inside constructors

301

(2)

Covariant return types

303

(1)

Designing with inheritance

304

(6)

Substitution vs. extension

306

(2)

Downcasting and runtime type information

308

(2)

Summary

310

(1)

Interfaces

311

(34)

Abstract classes and methods

311

(5)

Interfaces

316

(4)

Complete decoupling

320

(6)

``Multiple inheritance'' in Java

326

(3)

Extending an interface with inheritance

329

(2)

Name collisions when combining interfaces

330

(1)

Adapting to an interface

331

(4)

Fields in interfaces

335

(1)

Initializing fields in interfaces

335

(1)

Nesting interfaces

336

(3)

Interfaces and factories

339

(4)

Summary

343

(2)

Inner Classes

345

(44)

Creating inner classes

345

(2)

The link to the outer class

347

(3)

Using .this and .new

350

(2)

Inner classes and upcasting

352

(2)

Inner classes in methods and scopes

354

(2)

Anonymous inner classes

356

(8)

Factory Method revisited

361

(3)

Nested classes

364

(5)

Classes inside interfaces

366

(2)

Reaching outward from a multiply nested class

368

(1)

Why inner classes?

369

(13)

Closures & callbacks

372

(3)

Inner classes & control frameworks

375

(7)

Inheriting from inner classes

382

(1)

Can inner classes be overridden?

383

(2)

Local inner classes

385

(2)

Inner-class identifiers

387

(1)

Summary

388

(1)

Holding Your Objects

389

(54)

Generics and type-safe containers

390

(4)

Basic concepts

394

(2)

Adding groups of elements

396

(2)

Printing containers

398

(3)

List

401

(5)

Iterator

406

(4)

ListIterator

409

(1)

LinkedList

410

(2)

Stack

412

(3)

Set

415

(4)

Map

419

(4)

Queue

423

(4)

PriorityQueue

425

(2)

Collection vs. Iterator

427

(4)

Foreach and iterators

431

(6)

The Adapter Method idiom

434

(3)

Summary

437

(6)

Error Handling with Exception's

443

(60)

Concepts

444

(1)

Basic exceptions

445

(2)

Exception arguments

446

(1)

Catching an exception

447

(2)

The try block

447

(1)

Exception handlers

448

(1)

Creating your own exceptions

449

(8)

Exceptions and logging

452

(5)

The exception specification

457

(1)

Catching any exception

458

(10)

The stack trace

460

(1)

Rethrowing an exception

461

(3)

Exception chaining

464

(4)

Standard Java exceptions

468

(3)

Special case: RuntimeException

469

(2)

Performing cleanup with finally

471

(8)

What's finally for?

473

(3)

Using finally during return

476

(1)

Pitfall: the lost exception

477

(2)

Exception restrictions

479

(4)

Constructors

483

(6)

Exception matching

489

(1)

Alternative approaches

490

(10)

History

492

(2)

Perspectives

494

(3)

Passing exceptions to the console

497

(1)

Converting checked to unchecked exceptions

497

(3)

Exception guidelines

500

(1)

Summary

501

(2)

Strings

503

(50)

Immutable Strings

503

(1)

Overloading `+' vs. StringBuilder

504

(5)

Unintended recursion

509

(2)

Operations on Strings

511

(3)

Formatting output

514

(9)

printf()

514

(1)

System.out.format()

514

(1)

The Formatter class

515

(1)

Format specifiers

516

(2)

Formatter conversions

518

(3)

String.format()

521

(2)

Regular expressions

523

(23)

Basics

524

(3)

Creating regular expressions

527

(2)

Quantifiers

529

(2)

Pattern and Matcher

531

(9)

split()

540

(1)

Replace operations

541

(3)

reset()

544

(1)

Regular expressions and Java I/O

544

(2)

Scanning input

546

(5)

Scanner delimiters

549

(1)

Scanning with regular expressions

550

(1)

StringTokenizer

551

(1)

Summary

552

(1)

Type Information

553

(64)

The need for RTTI

553

(3)

The Class object

556

(13)

Class literals

562

(3)

Generic class references

565

(3)

New cast syntax

568

(1)

Checking before a cast

569

(13)

Using class literals

576

(2)

A dynamic instanceof

578

(2)

Counting recursively

580

(2)

Registered factories

582

(4)

instanceof vs. Class equivalence

586

(2)

Reflection: runtime class information

588

(5)

A class method extractor

590

(3)

Dynamic proxies

593

(5)

Null Objects

598

(9)

Mock Objects & Stubs

606

(1)

Interfaces and type information

607

(6)

Summary

613

(4)

Generics

617

(130)

Comparison with C++

618

(1)

Simple generics

619

(8)

A tuple library

621

(4)

A stack class

625

(1)

RandomList

626

(1)

Generic interfaces

627

(4)

Generic methods

631

(14)

Leveraging type argument inference

633

(2)

Varargs and generic methods

635

(1)

A generic method to use with Generators

636

(1)

A general-purpose Generator

637

(2)

Simplifying tuple use

639

(2)

A Set utility

641

(4)

Anonymous inner classes

645

(2)

Building complex models

647

(3)

The mystery of erasure

650

(12)

The C++ approach

652

(3)

Migration compatibility

655

(1)

The problem with erasure

656

(2)

The action at the boundaries

658

(4)

Compensating for erasure

662

(11)

Creating instances of types

664

(3)

Arrays of generics

667

(6)

Bounds

673

(4)

Wildcards

677

(17)

How smart is the compiler?

680

(2)

Contravariance

682

(4)

Unbounded wildcards

686

(6)

Capture conversion

692

(2)

Issues

694

(7)

No primitives as type parameters

694

(2)

Implementing parameterized interfaces

696

(1)

Casting and warnings

697

(2)

Overloading

699

(1)

Base class hijacks an interface

700

(1)

Self-bounded types

701

(9)

Curiously-recurring generics

701

(2)

Self-bounding

703

(3)

Argument covariance

706

(4)

Dynamic type safety

710

(1)

Exceptions

711

(2)

Mixins

713

(8)

Mixins in C++

714

(1)

Mixing with interfaces

715

(2)

Using the Decorator pattern

717

(2)

Mixins with dynamic proxies

719

(2)

Latent typing

721

(5)

Compensating for the lack of latent typing

726

(11)

Reflection

726

(2)

Applying a method to a sequence

728

(3)

When you don't happen to have the right interface

731

(2)

Simulating latent typing with adapters

733

(4)

Using function objects as strategies

737

(6)

Summary: Is casting really so bad?

743

(4)


	Buy Textbooks Sell Textbooks College Apparel Shop by School Virtual Bookstores	Order Status Shipping Rates Return Policy Marketplace Info F.A.S.T.	Contact Us Privacy Policy Legal Notices Site Security Employment	Help Desk eCampus Blog Affiliate Program Bulk Orders College Marketing

Need Help? bookstore@ecampus.com Copyright© 1999-2008
.