Java入门指南：Android开发实战（第3版）

需积分: 10 13 浏览量更新于2024-07-18 收藏 7.45MB PDF 举报

"《Learn Java for Android Development》(第三版)是一本面向有Java基础的学习者，专为Android应用开发入门而设计的权威指南。该书由Jeff Friesen编著，提供最新英文版的内容，深入浅出地讲解了Java语言的基础知识和Android开发所需的关键技能。在本书的第一章，"Getting Started with Java"，作者会引导读者逐步了解Java的基本概念，包括数据类型、控制结构和异常处理，确保对Java语言有一个坚实的基础。章节内容涵盖了如何设置开发环境，以及编写和运行第一个Java程序。第二章至第四章分别关注语言的核心组成部分："Learning Language Fundamentals"探讨语法、运算符和表达式；"Discovering Classes and Objects"介绍面向对象编程的概念，如类、对象和继承；而"Discovering Inheritance, Polymorphism, and Interfaces"则深入解析这些概念在实际项目中的应用，培养灵活运用多态性和接口的能力。第五章和第六章，"Mastering Advanced Language Features, Part 1" 和 "Part 2"，涵盖了更高级的主题，如泛型、枚举、注解等，帮助读者进一步提升Java编程技巧。第七章和第八章是"Exploring the Basic APIs, Part 1" 和 "Part 2"，聚焦于Android开发所依赖的基础API，如Android SDK和UI组件的使用，让读者熟悉如何构建用户界面和交互逻辑。第九章"Exploring the Collections Framework"深入学习Java集合框架，这对于处理大量数据和优化性能至关重要。第十章"Exploring the Concurrency Utilities"讲解并发编程，帮助开发者理解和利用线程池、锁和同步机制。第十一章"Performing Classic I/O"讲解输入输出操作，包括文件读写、输入流和输出流的使用，这对于数据交换和持久化存储是必不可少的。第十二章"Accessing Networks"则指导读者如何进行网络通信，包括HTTP请求、Socket编程等。最后一章"Chapter 13: Migration"可能涉及到向新版本的Java迁移，或者与其他技术栈的整合，确保开发者的知识与时俱进。这本教材不仅适合初学者系统学习，也适合有一定经验的开发者作为参考手册，以便快速掌握Android开发所需的Java技术。通过阅读这本书，读者将建立起扎实的Java基础，并能够顺利地在Android平台上实现创新的应用。"

8 CHAPTER 1: Getting Started with Java

The home directory contains various files (such as README.html, which provides information about

the JDK, and src.zip, which provides the standard class library source code) and subdirectories,

including the following three important subdirectories:

bin: This subdirectory contains assorted JDK tools. You’ll use only a few of

these tools in this book, mainly javac (Java compiler) and java (Java application

launcher). However, you’ll also work with jar (Java ARchive [JAR] creator,

updater, and extractor—a JAR file is a ZIP file with special features), javadoc

(Java documentation generator), and serialver (serial version inspector).

jre: This subdirectory contains the JDK’s private copy of the JRE, which lets

you run Java programs without having to download and install the public JRE.

lib: This subdirectory contains library files that are used by JDK tools. For

example, tools.jar contains the Java compiler’s classfiles. The compiler was

written in Java.

Note javac isn’t the Java compiler. It’s a tool that loads and starts the JVM, identifies the compiler’s main

classfile (located in tools.jar) to the JVM, and passes the name of the source file being compiled to the

compiler’s main classfile.

You execute JDK tools at the command line, passing command-line arguments to a tool. For a

quick refresher on the command line and command-line arguments topics, check out Wikipedia’s

“Command-line interface” entry (http://en.wikipedia.org/wiki/Command-line_interface).

The following command line shows you how to use javac to compile a source file named App.java:

javac App.java

The .java file extension is mandatory. The compiler complains when you omit this extension.

Tip You can compile multiple source files by specifying an asterisk in place of the filename, as follows:

javac *.java

Assuming success, an App.class file is created. If this file describes an application, which minimally

consists of a single class containing a method named main, you can run the application as follows:

java App

You must not specify the .class file extension. The java tool complains when .class is specified.

In addition to downloading and installing the JDK, you’ll need to access the JDK documentation,

especially to explore the Java APIs. There are two sets of documentation that you can explore.

9CHAPTER 1: Getting Started with Java

Oracle’s JDK 7 documentation ( http://docs.oracle.com/javase/7/docs/api/

index.html)

Google’s Java Android API documentation ( https://developer.android.com/

reference/packages.html)

Oracle’s JDK 7 documentation presents many APIs that are not supported by Android. Furthermore,

it doesn’t cover APIs that are specific to Android. This book focuses only on core Oracle Java APIs

that are also covered in Google’s documentation.

Hello, World!

It’s customary to start exploring a new language and its tools by writing, compiling, and running a

simple application that outputs the “Hello, World!” message. This practice dates back to Brian

Kernighan’s and Dennis Ritchie’s seminal book, The C Programming Language.

Listing 1-1 presents the source code to a HelloWorld application that outputs this message.

Listing 1-1. Saying Hello in a Java Language Context

public class HelloWorld

{

public static void main(String[] args)

{

System.out.println("Hello, World!");

}

This short seven-line application has a lot to say about the Java language. I’ll briefly explain each

feature, leaving comprehensive discussions of these features to later chapters.

This source code declares a class, which you can think of as a container for describing an

application. The first line, public class HelloWorld, introduces the name of the class (HelloWorld),

which is preceded by reserved words (names that have meaning to the Java compiler and which

you cannot use to name other things in your programs) public and class. These reserved words

respectively tell the compiler that HelloWorld must be stored in a file named HelloWorld and that a

class is being declared.

The rest of the class declaration appears between a pair of brace characters ({}), which are familiar

to C and C++ developers. Between these characters is the declaration of a single method, which

you can think of as a named sequence of code. This method is named main to signify that it's the

entry point into the application, and it is the analog of the main() function in C and C++.

10 CHAPTER 1: Getting Started with Java

The main() method includes a header that identifies this method and a block of code located

between an open brace character ({) and a close brace character (}). Besides naming this method,

the header provides the following information:

public: This reserved word makes main() visible to the startup code that calls

this method. If public wasn’t present, the compiler would output an error

message stating that it couldn’t find a main() method.

static: This reserved word causes this method to associate with the class

instead of associating with any objects (discussed in Chapter 3) created from

this class. Because the startup code that calls main() doesn’t create an object

from the class to call this method, it requires that the method be declared

static. Although the compiler will not report an error when static is missing,

it will not be possible to run HelloWorld, which will not be an application when

the proper main() method doesn’t exist.

void: This reserved word indicates that the method doesn’t return a value. If you

change void to a type’s reserved word (such as int) and then insert code that

returns a value of this type (such as return 0;), the compiler will not report an

error. However, you won’t be able to run HelloWorld because the proper main()

method wouldn’t exist. (I discuss types in Chapter 2.)

(String[] args): This parameter list consists of a single parameter named

args, which is of type String[]. Startup code passes a sequence of command-

line arguments to args, which makes these arguments available to the code

that executes within main(). You’ll learn about parameters and arguments in

Chapter 3.

main() is called with an array of strings (character sequences delimited by double quote "

characters) that identify the application’s command-line arguments. These strings are stored in

String-based array variable args. (I discuss method calling, arrays, and variables in Chapters 2 and

3.) Although the array variable is named args, there’s nothing special about this name. You could

choose another name for this variable.

main() presents a single line of code, System.out.println("Hello, World!");, which is responsible

for outputting Hello, World! in the command window from where HelloWorld is run. From left to

right, this method call accomplishes the following tasks:

System identifies a standard class of system utilities.

out identifies an object variable located in System whose methods let you output

values of various types optionally followed by a newline (also known as line feed)

character to the standard output stream. (In reality, a platform-dependent line

terminator sequence is output. On Windows platforms, this sequence consists

of a carriage return character [integer value 13] followed by a line feed character

[integer value 10]. On Linux platforms, this sequence consists of a line feed

character. On Mac OS X systems, this sequence consists of a carriage return

character. It's convenient to refer to this sequence as a newline.)

println identifies a method that prints its "Hello, World!" argument (the

starting and ending double quote characters are not written; these characters

delimit but are not part of the string) followed by a newline to the standard

output stream.

11CHAPTER 1: Getting Started with Java

Note The standard output stream is part of Standard I/O (http://en.wikipedia.org/wiki/

Standard_streams), which also consists of standard input and standard error streams, and which

originated with the Unix operating system. Standard I/O makes it possible to read text from different sources

(keyboard or file) and write text to different destinations (screen or file).

Text is read from the standard input stream, which defaults to the keyboard but can be redirected to a file.

Text is written to the standard output stream, which defaults to the screen but can be redirected to a file.

Error message text is written to the standard error stream, which defaults to the screen but can be redirected

to a file that differs from the standard output file.

Assuming that you’re familiar with your platform’s command-line interface and are at the command

line, make HelloWorld your current directory and copy Listing 1-1 to a file named HelloWorld.java.

Then compile this source file via the following command line:

javac HelloWorld.java

Assuming that you’ve included the .java extension, which is required by javac, and that

HelloWorld.java compiles, you should discover a file named HelloWorld.class in the current

directory. Run this application via the following command line:

java HelloWorld

If all goes well, you should see the following line of output on the screen:

Hello, World!

You can redirect this output to a file by specifying the greater than angle bracket (>) followed by a

filename. For example, the following command line stores the output in a file named hello.txt:

java HelloWorld >hello.txt

DumpArgs

In the previous example, I pointed out main()’s (String[] args) parameter list, which consists

of a single parameter named args. This parameter stores an array (think sequence of values) of

arguments passed to the application on the command line. Listing 1-2 presents the source code to a

DumpArgs application that outputs each argument.

Listing 1-2. Dumping Command-Line Arguments Stored in main()’s args Array to the Standard Output Stream

public class DumpArgs

{

public static void main(String[] args)

{

System.out.println("Passed arguments:");

for (int i = 0; i < args.length; i++)

12 CHAPTER 1: Getting Started with Java

System.out.println(args[i]);

}

Listing 1-2’s DumpArgs application consists of a class named DumpArgs that’s very similar to Listing

1-1’s HelloWorld class. The essential difference between these classes is the for loop (a construct

for repeated execution and starting with reserved word for) that accesses each array item and

dumps it to the standard output stream.

The for loop first initializes integer variable i to 0. This variable keeps track of how far the loop has

progressed (the loop must end at some point), and it also identifies one of the entries in the args

array. Next, i is compared with args.length, which records the number of entries in the array.

The loop ends when i’s value equals the value of args.length. (I discuss .length in Chapter 2.)

Each loop iteration executes System.out.println(args[i]);. The string stored in the ith entry of the args

array is accessed and then output to the standard output stream—the first entry is located at index

(location) 0. The last entry is stored at index args.length - 1. Finally, i is incremented by 1 via i++,

and i < args.length is reevaluated to determine whether the loop continues or ends.

Assuming that you’re familiar with your platform’s command-line interface and that you are at the

command line, make DumpArgs your current directory and copy Listing 1-2 to a file named DumpArgs

.java. Then compile this source file via the following command line:

javac DumpArgs.java

Assuming that that you’ve included the .java extension, which is required by javac, and that

DumpArgs.java compiles, you should discover a file named DumpArgs.class in the current directory.

Run this application via the following command line:

java DumpArgs

If all goes well, you should see the following line of output on the screen:

Passed arguments:

For more interesting output, you’ll need to pass command-line arguments to DumpArgs. For example,

execute the following command line, which specifies Curly, Moe, and Larry as three arguments to

pass to DumpArgs:

java DumpArgs Curly Moe Larry

This time, you should see the following expanded output on the screen:

Passed arguments:

Curly

Moe

Larry

剩余1189页未读，继续阅读

xapxxf

粉丝: 122
资源: 20

Java入门指南：Android开发实战（第3版）

Learn Java for Android Development_2nd.pdf

Learn Java for Android Development, 3rd Edition

Learn Java for Android Development

Learn Java for Android Development 3rd Edition mobi格式

Learn Java for Android Development.pdf

Android.App.Development.in.Android.Studio.Java.Android.Edition.For.Beginners.pdf

Learn Kotlin for Android Development.pdf

[android.开发书籍].Learn.Java.for.Android.Development.ra

Apress.Learn.AppleScript.3rd.Edition.Mar.2010.rar

Learn.Java.for.Android.Development_Apress.2010+src

最新资源