深入浅出Java：Head First Java 2nd Edition 教程

5星 · 超过95%的资源需积分: 10 85 浏览量更新于2024-07-31 收藏 20.08MB PDF 举报

"Head First Java, 2nd Edition 是一本被广泛推荐的Java学习书籍，适合初学者。这本书以其独特的教学方式，将复杂的Java概念以易于理解的方式呈现出来，同时覆盖了大量的实践内容，填补了其他教材可能留下的空白。作者Kathy Sierra和Bert Bates通过一种有趣、机智且贴近实际的方式，使读者在轻松愉快的氛围中掌握Java对象序列化、网络启动协议等高级主题。" 在《Head First Java》第二版中，你可以学到以下关键知识点： 1. **Java基础**：书中首先会介绍Java语言的基础，包括变量、数据类型、运算符、控制流（如if语句、循环）以及方法的定义与调用。这些是编程的基石，让你能够编写简单的程序。 2. **面向对象编程**：Java是一种面向对象的语言，书中的内容将深入讲解类、对象、封装、继承和多态等核心概念，帮助你理解如何构建和使用面向对象的系统。 3. **异常处理**：Java中的异常处理机制是程序健壮性的重要组成部分，书中会解释何时及如何使用try-catch块来捕获和处理运行时错误。 4. **集合框架**：Java集合框架是存储和操作对象的主要工具，包括ArrayList、LinkedList、HashSet、HashMap等。书中会详细阐述它们的使用场景和操作方法。 5. **输入/输出（I/O）**：了解如何读写文件，以及使用InputStream和OutputStream处理数据，这对于处理数据存储和传输至关重要。 6. **多线程**：Java支持多线程编程，书中会介绍如何创建和管理线程，以及线程同步机制如synchronized关键字和wait/notify机制。 7. **网络编程**：Java提供了丰富的API进行网络通信，如Socket和ServerSocket，书中会涵盖如何建立客户端-服务器连接，发送和接收数据。 8. **对象序列化**：对象序列化是将对象转换为字节流以便存储或传输的过程，书中会讲解如何实现Serializable接口和反序列化。 9. **Java标准库**：书中会介绍一些重要的Java库，如Swing用于构建图形用户界面，以及Util包中的各种实用类。 10. **设计模式**：虽然不是初级话题，但书中可能会提及一些常见的设计模式，如工厂模式、单例模式和观察者模式，以帮助你写出更优雅的代码。《Head First 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)

reclai

ms 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 liv

e 239

The miracle of object creation 240

Constructor

s (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页未读，继续阅读

candice1213

粉丝: 0
资源: 2

深入浅出Java：Head First Java 2nd Edition 教程

1 Head First Python, 2nd Edition.zip.001

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

深入学习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 3rd pdf

head first java下载

head-first python 2nd edition

最新资源