深入学习Java：Head First Java 2nd Edition 教程

5星 · 超过95%的资源需积分: 42 179 浏览量更新于2024-07-26 收藏 33.45MB PDF 举报

"Head.First.Java.2nd.Edition.2005" 《Head First Java》是第二版，出版于2005年，是Head First系列图书中的一本，专门针对Java编程语言的学习而设计。这本书以其独特的教学方式，旨在吸引和引导读者深入理解Java技术。Head First系列以其生动、有趣的风格著称，不同于传统的教科书，它通过丰富的图表、幽默的语言和互动性的设计，让学习过程更为轻松和高效。 Scott McNealy，Sun Microsystems的前董事长、总裁和首席执行官评论说，Java技术已经无处不在，如果你是一名软件开发者但尚未掌握Java，那么现在是时候深入学习了。他强调了Java在软件开发领域的广泛性和重要性。 Dr. Dan Russell，IBM Almaden Research Center的研究主任，以及斯坦福大学人工智能课程的讲师，对《Head First Java》给予了高度评价。他认为这本书不仅以吸引人的风格将读者从零基础带入到Java高手的行列，而且涵盖了大量传统教材中留作练习的实际问题，如对象序列化和网络启动协议等。同时，他还称赞该书机智、幽默且实用，能在教授这些复杂概念的同时保持读者的兴趣。 Warren Keuffel，《Software Development Magazine》的编辑则指出，《Head First Java》成功地将印刷页面转化为接近图形用户界面（GUI）的体验。作者们以独特的方式，使学习Java的过程变得令人期待和有趣。 Ken Arnold也认为这本书快速、不拘一格、充满趣味且引人入胜，提醒读者要小心，因为可能会在愉快的阅读中不知不觉学到很多东西。《Head First Java 2nd Edition》是一本非常受欢迎的Java学习书籍，它采用创新的教学方法，帮助读者轻松理解并掌握Java编程的核心概念，包括面向对象编程、类与对象、接口、异常处理、多线程、输入/输出流、网络编程和高级特性等。无论你是初学者还是有经验的程序员，都能从中受益，提升自己的Java技能。

xiv

Life and Death of an Object

Objects are born and objects die.

You’re in charge. You decide when and

how to construct them. You decide when to abandon them. The Garbage Collector (gc)

rec

laims the memory. We’ll look at how objects are created, where they live, and how to

keep or abandon them efficiently. That means we’ll talk about the heap, the stack, scope,

constructors, super constructors, null references, and gc eligibility.

Numbers Matter

Do the Math.

The Java API has methods for absolute value, rounding, min/max, etc.

But what about formatting? You might want numbers to print exactly two decimal points,

or with commas in all the right places. And you might want to print and manipulate dates,

too. And what about parsing a String into a number? Or turning a number into a String?

We’ll start by learning what it means for a variable or method to be static.

‘d’ is assigned a new Duck object, leaving the

original (first) Duck object abandoned. That

first Duck is toast..

Heap

When someone calls

the go() method, this

Duck is abandoned. His

only reference has been

reprogrammed for a

different Duck.

kid instance one

kid instance two

static variable:

iceCream

Static variables

are shared by

all instances of

a class.

instance variables:

one per instance

static variables:

one per class

The stack and the heap, where objects and variables live 236

Methods on the stack 237

Where local variables live 238

Where

instance variables live 239

The miracle of

object creation 240

Constructors (the code that runs when you say new) 241

Initializing the state of a new Duck 243

Overloaded constructors 247

Superclass constructors (constructor chaining) 250

Invoking overloaded constructors using this() 256

Life of an object 258

Garbage Collection (and making objects eligible) 260

Exercises and puzzles 266

Math class (do you really need an instance of it?) 274

static methods 275

static variables 277

Constants (static ﬁ nal variables) 282

Math methods (random(), round(), abs(), etc.) 286

Wrapper classes (Integer, Boolean, Character, etc.) 287

Autoboxing 289

Number formatting 294

Date formatting and manipulation 301

Static imports 307

Exercises and puzzles 310

Risky Behavior

Stuff happens. The file isn’t there. The server is down. No matter how good a

programmer you are, you can’t control everything. When you write a risky method, you need

code to handle the bad things that might happen. But how do you know when a method is

risky? Where do you put the code to handle the exceptional situation? In this chapter, we’re

going to build a MIDI Music Player, that uses the risky JavaSound API, so we better find out.

A Very Graphic Story

Face it, you need to make GUIs.

Even if you believe that for the rest of your

life you’ll write only server-side code, sooner or later you’ll need to write tools, and you’ll

want a graphical interface. We’ll spend two chapters on GUIs, and learn more language

features including Event Handling and Inner Classes. We’ll put a button on the screen,

we’ll paint on the screen, we’ll display a jpeg image, and we’ll even do some animation.

class with a

risky method

class with a

class Cow {

void moo() {

if (serverDown){

explode();

}

your code

class Bar {

void go() {

moo();

}

int stuff() {

x.beep();

}

calls risky method

class MyOuter {

class MyInner {

void go() {

}

The outer and inner objects

are now intimately linked.

These two objects on the

heap have a special bond. The

inner can use the outer’s

variables (and vice-versa).

Your ﬁ rst GUI 355

Getting a user event 357

Implement a listener interface 358

Getting a button’s ActionEvent 360

Putting graphics on a GUI 363

Fun with paintComponent() 365

The Graphics2D object 366

Putting more than one button on a screen 370

Inner classes to the rescue (make your listener an inner class) 376

Animation (move it, paint it, move it, paint it, move it, paint it...) 382

Code Kitchen (painting graphics with the beat of the music) 386

Exercises and puzzles 394

Making a music machine (the BeatBox) 316

What if you need to call risky code? 319

Exceptions say “something bad may have happened...” 320

The compiler guarantees (it checks) that you’re aware of the risks 321

Catching exceptions using a try/catch (skateboarder) 322

Flow control in try/catch blocks 326

The ﬁ nally block (no matter what happens, turn off the oven!) 327

Catching multiple exceptions (the order matters) 329

Declaring an exception (just duck it) 335

Handle or declare law 337

Code Kitchen (making sounds) 339

Exercises and puzzles 348

xvi

Work on your Swing

Swing is easy. Unless you actually care where everything goes. Swing code looks

easy, but then compile it, run it, look at it and think, “hey, that’s not supposed to go there.”

The thing that makes it easy to code is the thing that makes it hard to control—the

Layout

Manager

. But with a little work, you can get layout managers to submit to your will. In

this chapter, we’ll work on our Swing and learn more about widgets.

Saving Objects

Objects can be flattened and inflated.

Objects have state and behavior.

Behavior lives in the class, but state lives within each individual object. If your program

needs to save state, you can do it the hard way, interrogating each object, painstakingly

writing the value of each instance variable. Or, you can do it the easy OO way—you simply

freeze-dry the object (serialize it) and reconstitute (deserialize) it to get it back.

Components in

the east and

west get their

preferred width.

Things in the

north and

south get their

preferred

height.

The center gets

whatever’s left.

Swing Components 400

Layout Managers (they control size and placement) 401

Three Layout Managers (border, ﬂow, box) 403

BorderLayout (cares about ﬁve regions) 404

FlowLayout (cares about the order and preferred size) 408

BoxLayout (like ﬂow, but can stack components vertically) 411

JTextField (for single-line user input) 413

JTextArea (for multi-line, scrolling text) 414

JCheckBox (is it selected?) 416

JList (a scrollable, selectable list) 417

Code Kitchen (The Big One - building the BeatBox chat client) 418

Exercises and puzzles 424

Saving object state 431

Writing a serialized object to a ﬁle 432

Java input and output streams (connections and chains) 433

Object serialization 434

Implementing the Serializable interface 437

Using transient variables 439

Deserializing an object 441

Writing to a text ﬁle 447

java.io.File 452

Reading from a text ﬁle 454

Splitting a String into tokens with split() 458

CodeKitchen 462

Exercises and puzzles 466

serialized

deserialized

Any questions?

xviii

Release Your Code

It’s time to let go.

You wrote your code. You tested your code. You refined your code.

You told everyone you know that if you never saw a line of code again, that’d be fine. But in

the end, you’ve created a work of art. The thing actually runs! But now what? In these final

two chapters, we’ll explore how to organize, package, and deploy your Java code. We’ll look

at local, semi-local, and remote deployment options including executable jars, Java Web

Start, RMI, and Servlets. Relax. Some of the coolest things in Java are easier than you think.

MyApp.jar

classes

com

foo

101101

10 110 1

0 11 0

001 10

001 01

101101

10 110 1

0 11 0

MyApp.class

JWS

Web Server

Lorper

iure

eugue

tat vero

conse

euguero-

MyApp.jnlp

MyApp.jar

Deployment options 582

Keep your source code and class ﬁ les separate 584

Making an executable JAR (Java ARchives) 585

Running an executable JAR 586

Put your classes in a package! 587

Packages must have a matching directory structure 589

Compiling and running with packages 590

Compiling with -d 591

Making an executable JAR (with packages) 592

Java Web Start (JWS) for deployment from the web 597

How to make and deploy a JWS application 600

Exercises and puzzles 601

Data Structures

Sorting is a snap in Java.

You have all the tools for collecting and manipulating

your data without having to write your own sort algorithms The Java Collections

Framework has a data structure that should work for virtually anything you’ll ever need

to do. Want to keep a list that you can easily keep adding to? Want to find something by

name? Want to create a list that automatically takes out all the duplicates? Sort your co-

workers by the number of times they’ve stabbed you in the back?

Collections 533

Sorting an ArrayList with Collections.sort() 534

Generics and type-safety 540

Sorting things that implement the Comparable interface 547

Sorting things with a custom Comparator 552

The collection API—lists, sets, and maps 557

Avoiding duplicates with HashSet 559

Overriding hashCode() and equals() 560

HashMap 567

Using wildcards for polymorphism 574

Exercises and puzzles 576

0 1 2 3

List

Set

Map

“Ball” “Fish” “Car”

“Ball1” “Ball2” “Fish” “Car”

剩余721页未读，继续阅读

jerryxx0728

粉丝: 0
资源: 1

深入学习Java：Head First Java 2nd Edition 教程

深入学习Java：Head First Java 2nd Edition电子书下载

精通Java：Head First Java 2nd edition深度解读

Head-First Java 2nd Edition: 英文入门教程

[.Head.First.Java,.2nd.Edition].Head.First.Java,.2nd.Edition

First read Head.First.Java.2nd.Edition.Dec.2007.pdf

Head.First.Java.2nd.Edition(1)

Head.First.Servlets.and.JSP.2nd.Edition.Mar.2008

Head.First.HTML.and.CSS.2nd.Edition.Aug.2012

Head.First.Servlets.and.JSP.2nd.Edition.Mar.2008 03

Head.First.CSharp.2nd.Edition

最新资源