Java 8语言特性详解：从入门到精通

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

"Apress.Beginning.Java.8.Language.Features." 是一本专为初学者和Java开发者设计的指南，由作者根据自己的亲身经历和深入研究撰写而成。作者在1997年的Java培训中初次接触了Java编程，并在几年后才将其应用到实际项目中。由于在认证考试中发现所阅读的书籍对某些Java主题的细节讲解不足，他决定编写一本全面的Java教程，旨在覆盖Java开发人员在项目中有效使用语言所需的基础知识，并帮助他们准备认证考试。本书不仅涵盖了Java 8的关键语言特性，如注解(Annotations)、内嵌类(Inner Classes)、反射(Reflection)、泛型(Generics)、lambda表达式(Lambda Expressions)、线程(Threads)、输入输出(Input/Output)、档案文件处理(Archive Files)、新输入输出接口(New Input/Output)等，还包括垃圾回收(Garbage Collection)、集合框架(Collections)和流(Streams)等内容。作者注重基础知识的教学，强调理解Java的基本构造块，比如通过描述基础概念来构建每个主题，力求使读者能够逐步掌握复杂概念。书中特别注重实践性，提供了超过290个完整的Java程序示例，便于读者直接编译和运行，这对于缺乏编程经验的开发者来说是一大优势。作者花费大量时间进行研究，主要参考了Java语言规范、技术文档和专家论文，甚至深入阅读Java源代码，以确保内容的准确性和深度。此外，作者还强调了图像在理解和记忆编程概念中的重要作用，书中包含丰富的插图，帮助读者更好地理解内容。为了方便读者查找，前言部分的某些材料被放在了索引之后，但可以通过Bookmarks和Contents链接轻松访问。 "Apress.Beginning.Java.8.Language.Features." 是一本详尽且实用的Java入门指南，适合想要系统学习Java 8语言特性和编程实践的读者，无论是新手还是希望进一步巩固基础的开发者，都能从中受益匪浅。

CHAPTER 1 ■ ANNOTATIONS

All default values must be compile-time constants. How do you specify the default value for an array type? You

need to use the array initializer syntax. The following snippet of code shows how to specify default values for an array

and other data types:

// Shows how to assign default values to elements of different types

public @interface DefaultTest {

double d() default 12.89;

int num() default 12;

int[] x() default {1, 2};

String s() default "Hello";

String[] s2() default {"abc", "xyz"};

Class c() default Exception.class;

Class[] c2() default {Exception.class, java.io.IOException.class};

}

The default value for an element is not compiled with the annotation. It is read from the annotation type

definition when a program attempts to read the value of an element at runtime. For example, when you use

@Version(major=2), this annotation instance is compiled as is. It does not add minor element with its default value

as zero. In other words, this annotation is not modified to @Version(major=2, minor=0) at the time of compilation.

However, when you read the value of the minor element for this annotation at runtime, Java will detect that the value

for the minor element was not specified. It will consult the Version annotation type definition for its default value

and return the default value. The implication of this mechanism is that if you change the default value of an element,

the changed default value will be read whenever a program attempts to read it, even if the annotated program was

compiled before you changed the default value.

Annotation Type and Its Instances

I use the terms “annotation type” and “annotation” frequently. Annotation type is a type like an interface.

Theoretically, you can use annotation type wherever you can use an interface type. Practically, we limit its use only

to annotate program elements. You can declare a variable of an annotation type as shown:

Version v = null; // Here, Version is an annotation type

Like an interface, you can also implement an annotation type in a class. However, you are never supposed to do

that, as it will defeat the purpose of having an annotation type as a new construct. You should always implement an

interface in a class, not an annotation type. Technically, the code in Listing 1-3 for the DoNotUseIt class is valid. This is

just for the purpose of demonstration. Do not implement an annotation in a class even if it works.

Listing 1-3. A Class Implementing an Annotation Type

// DoNotUseIt.java

package com.jdojo.annotation;

import java.lang.annotation.Annotation;

public class DoNotUseIt implements Version {

// Implemented method from the Version annotation type

@Override

public int major() {

return 0;

}

CHAPTER 1 ■ ANNOTATIONS

// Implemented method from the Version annotation type

@Override

public int minor() {

return 0;

}

// Implemented method from the Annotation annotation type,

// which is the supertype of the Version annotation type

@Override

public Class<? extends Annotation> annotationType() {

return null;

}

The Java runtime implements the annotation type to a proxy class. It provides you with an object of a class that

implements your annotation type for each annotation you use in your program. You must distinguish between an

annotation type and instances (or objects) of that annotation type. In your example, Version is an annotation type.

Whenever you use it as @Version(major=2, minor=4), you are creating an instance of the Version annotation type.

An instance of an annotation type is simply referred to as an annotation. For example, we say that @Version(major=2,

minor=4) is an annotation or an instance of the Version annotation type. An annotation should be easy to use in a

program. The syntax @Version(...) is shorthand for creating a class, creating an object of that class, and setting the

values for its elements. I will cover how to get to the object of an annotation type at runtime later in this chapter.

Using Annotations

In this section, I will discuss the details of using different types of elements while declaring annotation types.

Remember that the supplied value for elements of an annotation must be a compile-time constant expression and

you cannot use null as the value for any type of element in an annotation.

Primitive Types

The data type of an element in an annotation type could be any of the primitive data types: byte, short, int, long,

float, double, boolean, and char. The Version annotation type declares two elements, major and minor, and both are

of int data type. The following code snippet declares an annotation type called PrimitiveAnnTest:

public @interface PrimitiveAnnTest {

byte a();

short b();

int c();

long d();

float e();

double f();

boolean g();

char h();

}

You can use an instance of the PrimitiveAnnTest type as

@PrimitiveAnnTest(a=1, b=2, c=3, d=4, e=12.34F, f=1.89, g=true, h='Y')

CHAPTER 1 ■ ANNOTATIONS

You can use a compile-time constant expression to specify the value for an element of an annotation.

The following two instances of the Version annotation are valid, and have the same values for their elements:

@Version(major=2+1, minor=(int)13.2)

@Version(major=3, minor=13)

String Types

You can use an element of the String type in an annotation type. Listing 1-4 contains the code for an annotation type

called Name. It has two elements, first and last, which are of the String type.

Listing 1-4. Name Annotation Type, Which Has Two Elements, first and last, of the String Type

package com.jdojo.annotation;

public @interface Name {

String first();

String last();

}

The following snippet of code shows how to use the Name annotation type in a program:

@Name(first="John", last="Jacobs")

public class NameTest {

@Name(first="Wally", last="Inman")

public void aMethod() {

// More code goes here...

}

It is valid to use the string concatenation operator (+) in the value expression for an element of a String type. The

following two annotations are equivalent:

@Name(first="Jo" + "hn", last="Ja" + "cobs")

@Name(first="John", last="Jacobs")

The following use of the @Name annotation is not valid because the expression new String("John") is not a

compile-time constant expression:

@Name(first=new String("John"), last="Jacobs")

Class Types

The benefits of using the Class type as an element in an annotation type are not obvious. Typically, it is used where

a tool/framework reads the annotations with elements of a class type and performs some specialized processing on

the element’s value or generates code. Let’s go through a simple example of using a class type element. Suppose you

are writing a test runner tool for running test cases for a Java program. Your annotation will be used in writing test

cases. If your test case must throw an exception when it is invoked by the test runner, you need to use an annotation to

indicate that. Let’s create a DefaultException class as shown in Listing 1-5.

CHAPTER 1 ■ ANNOTATIONS

Listing 1-5. A DefaultException Class That Is Inherited from the Throwable Exception Class

// DefaultException.java

package com.jdojo.annotation;

public class DefaultException extends java.lang.Throwable {

public DefaultException() {

}

public DefaultException(String msg) {

super(msg);

}

Listing 1-6 shows the code for a TestCase annotation type.

Listing 1-6. A TestCase Annotation Type Whose Instances Are Used to Annotate Test Case Methods

// TestCase.java

package com.jdojo.annotation;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.METHOD)

public @interface TestCase {

Class<? extends Throwable> willThrow() default DefaultException.class;

}

The return type of the willThrow element is defined as the wild card of the Throwable class, so that the user will

specify only the Throwable class or its subclasses as the element’s value. You could have used the Class type as the

type of your willThrow element. However, that would have allowed the users of this annotation type to pass any class

type as its value. Note that you have used two annotations, @Retention and @Target, for the TestCase annotation

type. The @Retention annotation type specified that the @TestCase annotation would be available at runtime. It is

necessary to use the retention policy of RUNTIME for your TestCase annotation type because it is meant for the test

runner tool to read it at runtime. The @Target annotation states that the TestCase annotation can be used only to

annotate methods. I will cover the @Retention and @Target annotation types in detail in later sections when I discuss

meta-annotations. Listing 1-7 shows the use of your TestCase annotation type.

Listing 1-7. A Test Case That Uses the TestCase Annotations

// PolicyTestCases.java

package com.jdojo.annotation;

import java.io.IOException;

public class PolicyTestCases {

// Must throw IOExceptionn

@TestCase(willThrow=IOException.class)

public static void testCase1(){

CHAPTER 1 ■ ANNOTATIONS

// Code goes here

}

// We are not expecting any exception

@TestCase()

public static void testCase2(){

// Code goes here

}

The testCase1() method specifies, using the @TestCase annotation, that it will throw an IOException. The test

runner tool will make sure that when it invokes this method, the method does throw an IOException. Otherwise,

it will fail the test case. The testCase2() method does not specify that it will throw an exception. If it throws an

exception when the test is run, the tool should fail this test case.

Enum Type

An annotation can have elements of an enum type. Suppose you want to declare an annotation type called Review that

can describe the code review status of a program element. Let’s assume that it has a status element and it can have

one of the four values: PENDING, FAILED, PASSED, and PASSEDWITHCHANGES. You can declare an enum as an annotation

type member. Listing 1-8 shows the code for a Review annotation type.

Listing 1-8. An Annotation Type, Which Uses an enum Type Element

// Review.java

package com.jdojo.annotation;

public @interface Review {

ReviewStatus status() default ReviewStatus.PENDING;

String comments() default "";

// ReviewStatus enum is a member of the Review annotation type

public enum ReviewStatus {PENDING, FAILED, PASSED, PASSEDWITHCHANGES};

}

The Review annotation type declares a ReviewStatus enum type and the four review statuses are the elements of

the enum. It has two elements, status and comments. The type of status element is the enum type ReviewStatus. The

default value for the status element is ReviewStatus.PENDING. You have an empty string as the default value for the

comments element.

Here are some of the instances of the Review annotation type. You will need to import the

com.jdojo.annotation.Review.ReviewStatus enum in your program to use the simple name of the ReviewStatus

enum type.

// Have default for status and comments. Maybe code is new

@Review()

// Leave status as Pending, but add some comments

@Review(comments="Have scheduled code review on June 3 2014")

// Fail the review with comments

@Review(status=ReviewStatus.FAILED, comments="Need to handle errors")

剩余689页未读，继续阅读

jerrylees2006

粉丝: 2
资源: 64

Java 8语言特性详解：从入门到精通

Beginning Java 8 Language Features

Apress.Beginning Java 8

beg-java-8-language-features:Kishori Sharan的“ Beginning Java 8 Language Features”源代码-java source code

Beginning C 17_From Novice to Professional-Apress(2018).epub

Beginning C++17_From Novice to Professional-Apress(2018).pdf

Beginning Scala Apress 2ed 2015

Beginning R(Apress,2ed,2015)

Beginning Python(Apress,3ed,2017)

Beginning Ethical Hacking with Python(Apress,2016)

Beginning iPhone Development with Swift 2(Apress,2015)

最新资源