精通Java 8编程：第3版，掌握核心技术与高级特性

4星 · 超过85%的资源需积分: 10 118 浏览量更新于2024-07-22 1 收藏 9.17MB PDF 举报

"《Pro Java 8 Programming》第三版是一本详尽讲解Java 8核心开发工具和技术的指南，专为经验丰富的Java程序员或希望提升技能的开发者设计。本书深入探讨了Java语言和核心标准版（SE）开发工具的各个方面，涵盖了从基础到高级的主题。在阅读过程中，读者将学习如何使用和设计自己的库、类和方法，掌握新引入的lambda表达式、闭包、流API等技术，以及如何在现代应用中有效利用线程和I/O API以实现企业级和并行计算能力。改进的集合API、GUI设计与开发（通过Swing组件如JTable和JTree）、剪贴板和拖放功能、Java数据库连接（JDBC）以连接MySQL、Oracle和NoSQL数据库、国际化和本地化，以及XML的使用和应用程序注解添加等高级主题也将逐一解析。本书结构包括15章内容，从理解Java 8的核心特性开始，随后逐步引导读者在实际项目中应用各种新特性和技术。无论你是初学者还是希望深化Java 8技能的专业开发者，这本书都能帮助你充分利用Java开发的便捷性，创建强大且复杂的Java应用程序。通过阅读，读者将能够熟练运用Java 8语言特性，提高代码效率，从而在软件开发领域取得更大的成功。"

Chapter 1 ■ GoinG inside Java

For example, consider the following simple Java class:

class Hello {

public static void main(String[] args) {

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

}

If you compile this class and then use the javap utility with the –c switch (covered later) to disassemble

the class file, you can get a mnemonic version of the bytecode.

Compiled from "Hello.java"

class Hello {

Hello();

Code:

0: aload_0

1: invokespecial #1 // Method java/lang/Object."<init>":()V

4: return

public static void main(java.lang.String[]);

Code:

0: getstatic #2 // Field java/lang/System.out:Ljava/io/

PrintStream;

3: ldc #3 // String Hello World!

5: invokevirtual #4 // Method java/io/PrintStream.println:

(Ljava/lang/String;)V

8: return

}

The main set of mnemonics we’re interested in consists of the three lines under the main() method,

which translate the single System.out.println("Hello World"); line of code.

The first instruction, getstatic, retrieves a PrintStream object from the out field of the java.lang.System

object and places it onto the operand stack. The next line, ldc, pushes the String “Hello World!” onto the

operand stack. Finally, invokevirtual executes a method, in this case println (on the java.io.PrintStream

class). For that method to successfully execute, it expects there to be a String and an instance of

java.io.PrintStream in the stack, in that order. Upon execution these items are removed from the stack.

The Java Class File Format

As already explained, the JVM can’t interpret the Java programming language directly, so when Java code is

compiled, the result is one or more class files containing bytecode, a symbol table, and other information.

The class file structure is a precisely defined binary format that ensures any JVM can load and interpret any

class file, no matter where the class file was produced.

The class file itself consists of a stream of 8-bit bytes. All higher-bit quantities (16, 32, or 64 bits) are

created by reading in a combination of 8-bit bytes, and multibyte quantities are stored in big-endian order

(the high bytes come first). The Java language provides I/O (input/output) streams (supported by the

DataInput, DataInputStream, DataOutput, and DataOutputStream interfaces from the java.io package)

that can read and write class files.

Chapter 1 ■ GoinG inside Java

The data types in the class file are unsigned 1-, 2-, or 4-byte quantities. These are denoted by the syntax

u1, u2, and u4. The class file can also contain a series of contiguous fixed-size items that can be indexed like

an array. These are designated using square brackets ([]).

The class format contains a single ClassFile structure, and that structure contains all the information

about the class or interface that the JVM needs to know. The general structure of the ClassFile is as follows:

ClassFile {

u4 magic;

u2 minor_version;

u2 major_version;

u2 constant_pool_count;

cp_info constant_pool[constant_pool_count – 1];

u2 access_flags;

u2 this_class

u2 super_class;

u2 interfaces_count;

u2 interfaces[interfaces_count];

u2 fields_count;

field_info fields[fields_count];

u2 methods_count;

method_info methods[methods_count];

u2 attributes_count;

attribute_into attributes[attributes_count];

}

The magic parameter is the magic number assigned to the class file format. This will have the value

0xCAFEBABE and identifies the code as being a class file.

The major_version and minor_version items are the major and minor versions of the class file format.

To the JVM, the version numbers indicate the format to which the class file adheres. JVMs can generally

load class files only within a certain version range (for example, within a single major version but a range of

minor versions) and will generally reject files from a newer specification than that of the JVM itself.

The constant_pool_count item is equal to the number of elements contained in the constant pool

plus one. This variable determines if a constant_pool index is valid. The constant_pool[] item is a table of

cp_info structures containing information on the elements in the constant_pool.

The access_flags item is a mask of flags reflecting whether the file is a class or interface and the access

permissions of the class or interface. The mask will be off or will be a combination of public, final, super,

interface, or abstract flags.

The this_class parameter points to a CONSTANT_Class_infor structure in the constant_pool table

representing the class or interface defined by this class file. The super_class item points to a similar

element in the constant_pool representing the direct superclass or interface or zero if no superclass exists.

The interfaces_count parameter represents the number of direct superinterfaces for the class or

interface. The interfaces[] item contains the location of those superinterfaces in the constant_pool table.

The fields_count variable gives the number of field_info structures contained in the ClassFile.

The field_info structures represent all fields, both static and instance, declared by the class or interface.

The methods[] item is a table containing the method_info structures.

Finally, the attributes_count variable gives the number of attributes in the attributes table of the

class or interface. The attributes[] item is a table containing the attributes’ structure.

Chapter 1 ■ GoinG inside Java

The Java Programming Language and APIs

All that we’ve covered so far happens transparently from the perspective of an application developer. In fact,

you don’t really have to know any details of Java’s internal architecture to program in Java. However, what

you do need to know is how to use Java as a programming language and also how to use the various APIs that

come with the different platforms to communicate with the underlying software and operating system. In

fact, this is essentially what the remainder of the book will be about—how to develop effectively with Java.

The Java Programming Language

Although knowledge of the various APIs is essential to achieving anything with Java, a solid foundation in

the core Java language is also highly desirable to make the most effective use of the APIs. In this book, you’ll

explore the following features of core Java programming:

Method, interface, and class design: Writing the main building blocks of your

applications with Java objects can be simultaneously quite straightforward and very

complex. However, if you take the time to follow some basic guidelines for creating

methods, classes, and libraries, it’s not too difficult to develop classes that not only

provide the required functionality but are also reliable, maintainable, and reusable.

Threading: Java includes built-in support for multithreaded applications, and

you’ll often find it necessary or desirable to take advantage of this. To do so,

you should be familiar with Java’s multithreading capabilities and know how to

implement threads correctly within an application.

The Java APIs

As discussed earlier in the chapter, three major versions of the Java platform exist, and each consists of some

significantly different APIs. In this book, we’ll concentrate on some (although by no means all) of the APIs

that form the Standard Edition. More specifically, we’ll cover the following:

User interface components: We’ll take an in-depth approach to show some

of the more complex user interface components; you’ll also learn how to use a

layout manager to arrange components within an interface.

The data transfer API: Closely related to providing the user interface for your

application is the need to provide cut-and-paste and drag-and-drop capabilities.

The printing API: Another common feature often required is the ability to print,

which you’ll examine through the use of Java’s printing capabilities.

JDBC: All but the most trivial of applications require data to be loaded,

manipulated, and stored in some form or another, and a relational database is

the most common means for storing such data. The Java Database Connectivity

(JDBC) API is provided for that purpose; we’ll discuss it in detail.

Internationalization: Most commercial applications and those developed for

internal use by large organizations are used in more than one country and need to

support more than one language. This requirement is sometimes overlooked and

treated as an implementation detail, but to be done successfully, internationalization

should be considered as part of an application’s design. To create a successful

design that includes internationalization support, you should be familiar with Java’s

capabilities in that area, and we’ll discuss them in detail in this book.

Chapter 1 ■ GoinG inside Java

Metadata: Java provides the ability to easily associate data with classes, interfaces,

methods, and fields. Java also includes an API that allows the metadata to be read

programmatically and used by tools to provide various useful functions such as

code generation.

Java Utility Tools: Making the Most of the JVM

Java SE comes with a number of development tools that you can use to compile, execute, and debug Java

programs; we’ll discuss some of the tools that relate to the JVM in the next sections. You can find a description

of all the utility tools on the Oracle web site at http://docs.oracle.com/javase/8/docs/technotes/tools/.

The Java Compiler

The compiler that comes with the J2SE is named javac; it reads class and interface definition files and

converts these into bytecode files. The command to run the Java compiler is as follows:

javac [options] [source files] [@file list]

The options are command-line options. If the number of source files to be compiled is sufficiently short,

the files can just be listed one after another. However, if the number of files is large, a file containing the

names of the files to be compiled can be used preceded by the @ character. Source code file names must end

with the .java suffix.

You can use the command-line options described in Table 1-2 to include additional functionality in the

standard compile command. This is only a partial list of options; for a complete list, including some that may

be specific to the Java compiler implementation, enter javac –help at the command line.

Table 1-2. Standard Options Supported by Java Compilers

Option Description

–classpath This command, followed by a user-specific class path, overrides the system CLASSPATH

environment variable.

–d This command, followed by a directory path, sets the destination directory for the

class files generated by the compiler.

–deprecation This command displays a description of any deprecated methods or classes used in

the source code.

–encoding This command sets the source file encoding name. Otherwise, the default

encoding is used.

–g This command provides more complete debugging information, including local

variable information.

–g:none This command turns off all debugging information.

–g:keyword This command allows the user to specify the type of debugging information provided.

Valid keyword options are source, lines, and vars.

–help This command displays information about the compiler utility options.

(continued)

Chapter 1 ■ GoinG inside Java

Option Description

–nowarn This command prevents warning messages from being displayed. Warnings occur

when the compiler suspects something is wrong with the source code but the

problem isn’t severe enough to stop compilation.

–source This command indicates that features added after the specified release aren’t

supported. For example, specifying –source 1.3 will cause the compiler to fail if it

encounters the assert keyword, since assertions weren’t available until Java 1.4.

–sourcepath This command, followed by a source path, specifies the path that the compiler will

use to search for source code files.

–verbose This command produces additional information about the classes that are loaded

and the source files that were compiled.

–X This command displays information about nonstandard options. These are

options that need not be implemented by a compiler to be considered a valid

implementation, and as such may or may not be supported by a given compiler

implementation.

Table 1-2. (continued)

The Java Interpreter

The java utility launches a Java application by loading and running the class file containing the main

method of the application. The java utility will interpret the bytecode contained in that file and any other

class files that are part of the application. The general command syntax for the java utility is as follows:

java [options] class [arguments]

Alternatively, you can run it as follows:

java [options] –jar file.jar [arguments]

You can provide the initial class file as a separate file or as part of a Java Archive ( JAR) file. The options

are command-line options for the JVM, and the class is the name of the class file containing the static

main() method to execute. The arguments are any arguments that need to be passed to main().

Table 1-3 describes some of the standard options for the java utility and, as with the compiler, you can

enter java –help at the command line to see a complete set of options supported by the implementation

you’re using.

剩余694页未读，继续阅读

ramissue

粉丝: 354
资源: 1487

精通Java 8编程：第3版，掌握核心技术与高级特性

Pro.Java.8.Programming.3rd.Edition.1484206428.epub

Pro Java 8 Programming(3rd) 无水印pdf

java网络编程 Java.Network.Programming.3rd.Edition.Oct.2004

Packt.OpenCV.3.Computer.Vision.Application.Programming.Cookbook.3rd.Edition.2017

Mathematics.for.3D.Game.Programming.and.Computer.Graphics.3rd.Edition.pdf

Prentice.Core.PHP.Programming.3rd.Edition

The.MIT.Press.Essentials.of.Programming.Languages.3rd.Edition

Cocoa.Programming.for.Mac.OS.X.3rd.Edition.rar

/The.MIT.Press.Essentials.of.Programming.Languages.3rd.Edition

python程序设计第3版 Programming.Python.3rd.Edition.Aug.2006

最新资源