21天掌握JAVA编程：初学者指南

需积分: 10 124 浏览量更新于2024-07-30 收藏 5.76MB PDF 举报

"Teach Yourself JAVA in 21 Days 是一本面向初级JAVA学习者的教程，旨在帮助读者在21天内掌握JAVA语言，包括编写applet和应用程序的基础知识。本书适合有一定编程基础的读者，无论你是有多年经验的程序员还是初涉编程的新手，只要了解变量、循环和函数的基本概念，都能从中受益。" 在本书中，作者Laura Lemay和Charles L. Perkins将带领读者深入学习JAVA语言的核心概念和实际应用。他们不仅会讲解JAVA的基础语法，还会涵盖如何利用JAVA进行网页设计的高级主题，比如与HTML、CGI程序的交互。对于那些已经熟练掌握HTML和CGI编程（如Perl、AppleScript或Visual Basic）的读者，这本书是一个理想的选择，可以帮助他们进一步提升在Web页面设计中的技能。本书的章节安排可能按照周来规划，每天的学习内容都经过精心设计，确保读者每天都能逐步掌握新的JAVA知识。内容可能包括： 1. **JAVA语言基础**：介绍JAVA的安装、开发环境的设置，以及基本的数据类型、变量、运算符和控制结构。 2. **类和对象**：讲解JAVA面向对象编程的核心概念，包括类的定义、对象的创建和方法的使用。 3. **封装和继承**：深入讨论封装原则和类之间的继承关系，以及多态性。 4. **异常处理**：介绍JAVA的错误处理机制，如何使用try-catch语句捕获和处理异常。 5. **输入/输出（I/O）**：学习JAVA的流模型，如何进行文件读写和网络通信。 6. **集合框架**：理解ArrayList、LinkedList、HashMap等集合类的使用，以及泛型的概念。 7. **多线程**：介绍如何在JAVA中创建和管理线程，实现并发执行。 8. **GUI编程**：使用Swing或JavaFX库创建图形用户界面，构建桌面应用。 9. **Applet编程**：学习如何编写能在浏览器中运行的JAVA小程序。 10. **JNI和JNI库**：了解JAVA本地接口，如何调用C/C++库。 11. **JAVA标准库和API**：熟悉JAVA的标准库，如IO、网络、XML处理等类库的使用。 12. **调试和测试**：学习如何使用JAVA的调试工具进行程序调试，以及单元测试的重要性。通过这21天的学习，读者不仅可以掌握JAVA编程的基本技能，还能具备解决实际问题的能力。无论是为了提升个人技能，还是为了从事相关工作，这本书都将是一个宝贵的资源。

xix

Sams.net

Learning

Center

abcd

P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95 FM LP#4

Acknowledgments

From Laura Lemay:

To Sun’s Java team, for all their hard work on Java the language and on the browser, and

particularly to Jim Graham, who demonstrated Java and HotJava to me on very short notice in

May and planted the idea for this book.

To everyone who bought my previous books, and liked them. Buy this one too.

From Charles L. Perkins:

To Patrick Naughton, who first showed me the power and the promise of OAK (Java) in early

1993.

To Mark Taber, who shepherded this lost sheep through his first book.

030-4 FM 1/29/96, 8:12 PM19

xxi

Sams.net

Learning

Center

abcd

P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95 FM LP#4

Introduction

The World Wide Web, for much of its existence, has been a method for distributing passive

information to a widely distributed number of people. The Web has, indeed, been exceptionally

good for that purpose. With the addition of forms and image maps, Web pages began to become

interactive—but the interaction was often simply a new way to get at the same information. The

limitations of Web distribution were all too apparent once designers began to try to stretch the

boundaries of what the Web can do. Even other innovations, such as Netscape’s server push to

create dynamic animations, were merely clever tricks layered on top of a framework that wasn’t

built to support much other than static documents with images and text.

Enter Java, and the capability for Web pages of containing Java applets. Applets are small

programs that create animations, multimedia presentations, real-time (video) games, multi-user

networked games, and real interactivity—in fact, most anything a small program can do, Java

applets can. Downloaded over the net and executed inside a Web page by a browser that supports

Java, applets are an enormous step beyond standard Web design.

The disadvantage of Java is that to create Java applets right now, you need to write them in the

Java language. Java is a programming language, and as such, creating Java applets is more

difficult than creating a Web page or a form using HTML. Soon there will be tools and programs

that will make creating Java applets easier—they may be available by the time you read this. For

now, however, the only way to delve into Java is to learn the language and start playing with the

raw Java code. Even when the tools come out, you may want to do more with Java than the tools

can provide, and you’re back to learning the language.

That’s where Teach Yourself Java in 21 Days comes in. This book teaches you all about the Java

language and how to use it to create not only applets, but also applications, which are more

general Java programs that don’t need to run inside a Web browser. By the time you get through

with this book, you’ll know enough about Java to do just about anything, inside an applet or

out.

Who Should Read This Book

Teach Yourself Java in 21 Days is intended for people with at least some basic programming

background—which includes people with years of programming experience and people with

only a small amount of experience. If you understand what variables, loops, and functions are,

you’ll be just fine for this book. The sorts of people who might want to read this book include

you, if one or more of the following is true:

■■ You’re a real whiz at HTML, understand CGI programming (in perl, AppleScript,

Visual Basic, or some other popular CGI language) pretty well, and want to move

onto the next level in Web page design.

030-4 FM 1/29/96, 8:12 PM21

Teach Yourself JAVA in 21 Days

xxii

P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95 FM LP#4

■■ You had some Basic or Pascal in school, you’ve got a basic grasp of what programming

is, but you’ve heard Java is easy to learn, really powerful, and very cool.

■■ You’ve programmed C and C++ for many years, you’ve heard this Java thing is

becoming really popular, and you’re wondering what all the fuss is all about.

■■ You’ve heard that Java is really good for Web-based applets, and you’re curious about

how good it is for creating more general applications.

What if you know programming, but you don’t know object-oriented programming? Fear not.

Teach Yourself Java in 21 Days assumes no background in object-oriented design. If you know

object-oriented programming, the first couple of days will be easy for you.

What if you’re a rank beginner? This book might move a little fast for you. Java is a good language

to start with, though, and if you take it slow and work through all the examples, you may still

be able to pick up Java and start creating your own applets.

How This Book Is Organized

Teach Yourself Java in 21 Days describes Java primarily in its current state—what’s known as the

beta API (Application Programming Interface). This is the version of Java that Netscape and

other browsers, such as Spyglass’s Mosaic, support. A previous version of Java, the alpha API,

was significantly different from the version described in this book, and the two versions are not

compatible with each other. There are other books that describe only the alpha API, and there

may still be programs and browsers out there that can only run using alpha Java programs.

Teach Yourself Java in 21 Days uses primarily Java beta because that is the version that is most

current and is the version that will continue to be used in the future. The alpha API is obsolete

and will eventually die out. If you learn Java using beta API, you’ll be much better prepared for

any future changes (which will be minor) than if you have to worry about both APIs at once.

Java is still in development. “Beta” means that Java is not complete and that things may change

between the time this book is being written and the time you read this. Keep this in mind as you

work with Java and with the software you’ll use to create and compile programs. If things aren’t

behaving the way you expect, check the Web sites mentioned at the end of this introduction for

more information.

Teach Yourself Java in 21 Days covers the Java language and its class libraries in 21 days, organized

as three separate weeks. Each week covers a different broad area of developing Java applets and

applications.

In the first week, you’ll learn about the Java language itself:

■■ Day 1 is the basic introduction: what Java is, why it’s cool, and how to get the

software. You’ll also create your first Java applications and applets.

030-4 FM 1/29/96, 8:12 PM22

xxiii

Sams.net

Learning

Center

abcd

P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95 FM LP#4

■■ On Day 2, you’ll explore basic object-oriented programming concepts as they apply to

Java.

■■ On Day 3, you start getting down to details with the basic Java building blocks: data

types, variables, and expressions such as arithmetic and comparisons.

■■ Day 4 goes into detail about how to deal with objects in Java: how to create them,

how to access their variables and call their methods, and how to compare and copy

them. You’ll also get your first glance at the Java class libraries.

■■ On Day 5, you’ll learn more about Java with arrays, conditional statements. and

loops.

■■ Day 6 is the best one yet. You’ll learn how to create classes, the basic building blocks

of any Java program, as well as how to put together a Java application (an application

being a Java program that can run on its own without a Web browser).

■■ Day 7 builds on what you learned on Day 6. On Day 7, you’ll learn more about how

to create and use methods, including overriding and overloading methods and

creating constructors.

Week 2 is dedicated to applets and the Java class libraries:

■■ Day 8 provides the basics of applets—how they’re different from applications, how to

create them, and the most important parts of an applet’s life cycle. You’ll also learn

how to create HTML pages that contain Java applets.

■■ On Day 9, you’ll learn about the Java classes for drawing shapes and characters to the

screen—in black, white, or any other color.

■■ On Day 10, you’ll start animating those shapes you learned about on Day 9, includ-

ing learning what threads and their uses are.

■■ Day 11 covers more detail about animation, adding bitmap images and audio to the

soup.

■■ Day 12 delves into interactivity—handling mouse and keyboard clicks from the user

in your Java applets.

■■ Day 13 is ambitious; on that day you’ll learn about using Java’s Abstract Windowing

Toolkit to create a user interface in your applet including menus, buttons, checkboxes,

and other elements.

■■ On Day 14, you explore the last of the main Java class libraries for creating applets:

windows and dialogs, networking, and a few other tidbits.

Week 3 finishes up with advanced topics, for when you start doing larger and more complex Java

programs, or when you want to learn more:

■■ On Day 15, you’ll learn more about the Java language’s modifiers—for abstract and

final methods and classes as well as for protecting a class’s private information from

the prying eyes of other classes.

030-4 FM 1/29/96, 8:12 PM23

剩余515页未读，继续阅读

名叫猫的鱼

粉丝: 49
资源: 37

21天掌握JAVA编程：初学者指南

Sams Teach Yourself Java in 21 Days(Covering Java 8) 7th 2016第7版 0分

teach yourself java in 21 days

sams teach yourself sql in 10 minutes

sams teach yourself sql in 10 minutes (fourth edition) pdf

teach yourself cgi programming with perl in a week

write a letter to a foreign friend who wants to teach English in China. Please recommend a city to him.

创建类Teacher，有属性：String name,int age、有参构造方法、方法：teach( ),输出信息“我爱教JAVA”。创建对象t1,赋值：李四，19；调用teach（）方法。

Invocation of init method failed; nested exception is java.lang.IllegalStateException: Ambiguous mapping. Cannot map '/teach' method

java编写需求： 人类：(Person) 成员变量：姓名，年龄 老师类: 成员变量：姓名，年龄 成员方法：teach 年龄为30岁的老师正在讲课 学生类: 成员变量：姓名，年龄，成绩 成员方法：stady

最新资源

java编写需求：人类：(Person) 成员变量：姓名，年龄老师类: 成员变量：姓名，年龄成员方法：teach 年龄为30岁的老师正在讲课学生类: 成员变量：姓名，年龄，成绩成员方法：stady