Download the Full Version of textbook for Fast Typing at textbookfull.

com

Java 8 Recipes 2nd Edition Josh Juneau

https://textbookfull.com/product/java-8-recipes-2nd-edition-
josh-juneau/

OR CLICK BUTTON

DOWNLOAD NOW

Download More textbook Instantly Today - Get Yours Now at textbookfull.com

 Recommended digital products (PDF, EPUB, MOBI) that
you can download immediately if you are interested.

Java 9 Recipes: A Problem-Solution Approach 3rd Edition

Josh Juneau

https://textbookfull.com/product/java-9-recipes-a-problem-solution-
approach-3rd-edition-josh-juneau/

textboxfull.com

Java EE 7 Recipes A Problem Solution Approach 1st Edition

Juneau Josh

https://textbookfull.com/product/java-ee-7-recipes-a-problem-solution-
approach-1st-edition-juneau-josh/

textboxfull.com

Java 7 Recipes A Problem Solution Approach Juneau Josh

Beaty Mark Dea Carl Guime Freddy Oconner John

https://textbookfull.com/product/java-7-recipes-a-problem-solution-
approach-juneau-josh-beaty-mark-dea-carl-guime-freddy-oconner-john/

textboxfull.com

Introducing Java EE 7 A Look at What s New Juneau Josh

https://textbookfull.com/product/introducing-java-ee-7-a-look-at-what-
s-new-juneau-josh/

textboxfull.com
JavaServer Faces Introduction by Example Juneau Josh

https://textbookfull.com/product/javaserver-faces-introduction-by-
example-juneau-josh/

textboxfull.com

All About Java 8 Lambdas Introducing Java 8 Lambdas 1st

Edition Konda

https://textbookfull.com/product/all-about-java-8-lambdas-introducing-
java-8-lambdas-1st-edition-konda/

textboxfull.com

Java Performance In Depth Advice for Tuning and

Programming Java 8 11 and Beyond 2nd Edition Scott Oaks

https://textbookfull.com/product/java-performance-in-depth-advice-for-
tuning-and-programming-java-8-11-and-beyond-2nd-edition-scott-oaks/

textboxfull.com

Practical JSF in Java EE 8 Michael Müller

https://textbookfull.com/product/practical-jsf-in-java-ee-8-michael-
muller/

textboxfull.com

Java 8 Pocket Guide Instant Help for Java Programmers 1st

Edition Liguori Robert Liguori Patricia

https://textbookfull.com/product/java-8-pocket-guide-instant-help-for-
java-programmers-1st-edition-liguori-robert-liguori-patricia/

textboxfull.com
For your convenience Apress has placed some of the front
matter material after the index. Please use the Bookmarks
and Contents at a Glance links to access them.
Contents at a Glance

About the Author ................................................................................................................xli

About the Technical Reviewers ........................................................................................xliii
Acknowledgments ............................................................................................................. xlv
Introduction ..................................................................................................................... xlvii

N Chapter 1: Getting Started with Java 8 .............................................................................1

N Chapter 2: New Features of Java 8..................................................................................29
N Chapter 3: Strings............................................................................................................49
N Chapter 4: Numbers and Dates ........................................................................................65
N Chapter 5: Object-Oriented Java .....................................................................................97
N Chapter 6: Lambda Expressions ....................................................................................133
N Chapter 7: Data Structures and Collections ..................................................................153
N Chapter 8: Input and Output ..........................................................................................187
N Chapter 9: Exceptions and Logging ...............................................................................207
N Chapter 10: Concurrency ...............................................................................................223
N Chapter 11: Debugging and Unit Testing .......................................................................249
N Chapter 12: Unicode, Internationalization, and Currency Codes ...................................263
N Chapter 13: Working with Databases ............................................................................283
N Chapter 14: JavaFX Fundamentals ................................................................................331
N Chapter 15: Graphics with JavaFX ................................................................................405
N Chapter 16: Media with JavaFX .....................................................................................445

v
N CONTENTS AT A GLANCE

N Chapter 17: JavaFX on the Web .....................................................................................473

N Chapter 18: Nashorn and Scripting ...............................................................................505
N Chapter 19: E-mail.........................................................................................................527
N Chapter 20: XML Processing .........................................................................................537
N Chapter 21: Networking ...............................................................................................553
N Chapter 22: Security ......................................................................................................571

Index .................................................................................................................................579

vi
Introduction

The Java programming language was introduced in 1995 by Sun Microsystems. Derived from languages such as
C and C++, Java was designed to be more intuitive and easier to use than older languages, specifically due to its
simplistic object model and automated facilities such as memory management. At the time, Java drew the interest
of developers because of its object oriented, concurrent architecture; its excellent security and scalability; and
because applications developed in the Java language could run on any operating system that contained a Java Virtual
Machine (JVM). Since its inception, Java has been described as a language that allows developers to “write once, run
everywhere” as code is compiled into class files that contain bytecode, and the resulting class files can run on any
compliant JVM. This concept made Java an immediate success for desktop development, which later branched off into
different technological solutions over the years, including development of web-based applications and rich Internet
applications (RIAs). Today, Java is deployed on a broad range of devices, including mobile phones, printers, medical
devices, Blu-ray players, and so on.
The Java platform consists of a hierarchy of components, starting with the Java Development Kit (JDK), which
is composed of the Java Runtime Environment (JRE), the Java programming language, and platform tools that are
necessary to develop and run Java applications. The JRE contains the Java Virtual Machine (JVM), plus the Java
application programming interfaces (APIs) and libraries that assist in the development of Java applications. The JVM
is the base upon which compiled Java class files run and is responsible for interpreting compiled Java classes and
executing the code. Every operating system that is capable of running Java code has its own version of the JVM. To that
end, the JRE must be installed on any system that will be running local Java desktop or stand-alone Java applications.
Oracle provides JRE implementations for most of the major operating systems. Each operating system can have its
own flavor of the JRE. For instance, mobile devices can run a scaled down version of the full JRE that is optimized
to run Java Mobile Edition (ME) and Java SE embedded applications. The Java platform APIs and libraries are a
collection of predefined classes that are used by all Java applications. Any application that runs on the JVM makes
uses the Java platform APIs and libraries. This allows applications to use the functionality that has been predefined
and loaded into the JVM and leaves developers with more time to worry about the details of their specific application.
The classes that comprise the Java platform APIs and libraries allow Java applications to use one set of classes in order
to communicate with the underlying operating system. As such, the Java platform takes care of interpreting the set
of instructions provided by a Java application into operating system commands that are required for the machine on
which the application is being executed. This creates a facade for Java developers to write code against so that they can
develop applications that can be written once and ran on every machine that contains a relevant JVM.
The JVM and the Java platform APIs and libraries play key roles in the lifecycle of every Java application. Entire
books have been written that explore the platform and JVM. This book focuses on the Java language itself, which is
used to develop Java applications, although the JVM and Java platform APIs and libraries are referenced as needed.
The Java language is a robust, secure, and modern object oriented language that can be used to develop applications
to run on the JVM. The Java programming language has been refined over several iterations and it becomes more
powerful, secure, and modern with each new release. This book covers many features of the Java programming
language from those that were introduced in Java 1.0 through those that made their way to the language in Java 8.
In 2014, Oracle Corporation released Java 8, which was another milestone release for the Java ecosystem. Not only was
Java already the most modern, statically typed, object oriented language available for development, but Java 8 adds
important new enhancements to the language, such as lambda expressions, streams processing, and default methods.
JavaFX 8 was also released at the same time, advancing desktop Java applications more than ever. JavaFX 8 can be
used for developing rich desktop and Internet applications using the Java language, or any other language that runs

xlvii
N INTRODUCTION

on the JVM. It provides a rich set of graphical and media user interfaces to develop extraordinary visual applications.
This release is another nice update to the JavaFX platform, adding in features such as the Swing node and the
Print API.
This book covers the fundamentals of Java development, such as installing the JDK, writing classes, and running
applications. It delves into essential topics such as the development of object oriented constructs, exception handling,
unit testing, and localization. The book also provides solutions for desktop application development using the JavaFX,
and some web-based and database solutions. It covers JavaFX 8 in depth and is an essential guide for developers
beginning to use JavaFX 8. This book can be used as a guide for solving problems that ordinary Java developers may
encounter at some point. A broad range of topics is discussed, and the solutions to the problems that are covered
in this book are concise and to the point. If you are a novice Java developer, we hope that this book will help you get
started on your journey to working with one of the most advanced and widely used programming languages available
today. For those of you who have used the Java language for some time, we hope that this book will provide you with
updated material that is new to Java 8 and JavaFX 2.0 so that you can further refine your Java development skills.
We ensure that advanced Java application developers will also learn a thing or two regarding the new features of the
language and perhaps even stumble upon some techniques that were not used in the past. Whatever your skill level,
this book is good to have close at hand as a reference for solutions to those problems that you encounter in your daily
programming.

Who This Book Is For

This book is intended for all those who are interested in learning the Java programming language and/or already know
the language but would like some information regarding the new features included in Java SE 8 and JavaFX 8. Those
who have not yet programmed in the Java language can read this book, and it will allow them to start from scratch
to get up and running quickly. Intermediate and advanced Java developers who are looking to update their arsenal
with the latest features that Java SE 8 and JavaFX 8 make available to them can also read the book to quickly update
and refresh their skill set. Java desktop programmers will find this book useful for its content on developing desktop
applications using the JavaFX API. There are, of course, a myriad of other essential topics that will be useful to Java
developers of any type.

How This Book Is Structured

This book is structured so that it does not have to be read from cover to cover. In fact, it is structured so that developers
can chose which topics they want to read about and jump right to them. Each recipe contains a problem to solve,
one or more solutions to solve that problem, and a detailed explanation of how the solution works. Although some
recipes may build upon concepts that have been discussed in other recipes, they contain the appropriate references
so that the developer can find other related recipes that are beneficial to the solution. The book is designed to allow
developers to get up and running quickly with a solution so that they can be home in time for dinner.

xlviii
CHAPTER 1

Getting Started with Java 8

In this chapter we present a handful of recipes to help programmers who are new to the Java language, as well as
those having experience in other languages, become accustomed to Java 8. You will learn to install Java 8, and also
install an Interactive Development Environment (IDE) from which you’ll develop applications and experiment with
the solutions provided in this book. You will learn basics of Java such as how to create a class and how to accept
keyboard input. Documentation is often overlooked, but in this chapter you will quickly learn how to create great
documentation for your Java code.

N Note Java 8 Recipes is not intended as a complete tutorial. Rather, it covers key concepts of the Java language.
If you are truly new to Java, we recommend buying and reading one of the many Beginning Java books that are also
published by Apress.

1-1. Creating a Development Environment

Problem
You want to install Java and experiment with the language. You’d also like a reasonable IDE to use with it.

Solution
Install Java Development Kit 8 (JDK). That gives you the language and a compiler. Then install the NetBeans IDE to
provide a more productive working environment.
Java Standard Edition (Java SE) is sufficient for most recipes in this book. To download the release, visit the
following page on the Oracle Technology Network (OTN):

http://www.oracle.com/technetwork/java/javase/overview/index.html

Figure 1-1 shows the Downloads tab, and you can see the Java Platform download link and image prominently
on the page. Next to that link is an image for the NetBeans IDE, which provides the option of downloading the JDK
and NetBeans together. Choose the option that you prefer, download the release for your platform, and run the setup
wizard to install.

1
CHAPTER 1 N GETTING STARTED WITH JAVA 8

Figure 1-1. Java SE Downloads page on the Oracle Technology Network

N Note If you chose to only install the Java Platform (JDK) and not NetBeans, you can download NetBeans at a later
time by visiting netbeans.org.

How It Works
The name Java™ is a trademark owned by Oracle Corporation. The language itself is open source, and its evolution is
controlled by a process known as the Java Community Process SM (JCP SM). You can read more about that process at
www.jcp.org.
There are many editions of Java, such as the Mobile Edition (ME) and the Enterprise Edition (EE). Java SE
is the Standard Edition and represents the heart of the language. We’ve built the recipes in this book for Java SE
programmers. Those interested in the development of mobile or embedded applications may be interested in
learning more about Java ME. Similarly, those interested in developing web applications and working with enterprise
solutions may be interested in learning more about Java EE.

N Note Enterprise Edition programmers may want to buy and read a copy of Java EE 7 Recipes (Apress, 2013).

There are several good websites that you can visit to learn more about Java and keep up-to-date with the latest on
the platform. A good place to begin for all things Java is the following page on the Oracle Technology Network:

http://www.oracle.com/technetwork/java/index.html

The wealth of resources available from this page can be overwhelming at first, but it’s worth your time to look
around and get passingly familiar with the many links that are available.
One of the links will be to Java SE, which takes you to the page shown earlier in Figure 1-1. It is from there that
you can download Java SE and the NetBeans IDE. Also from there you have access to the official documentation,
to community resources such as forums and newsletters, and to training resources designed to help you build
knowledge in Java and become certified in the language.

2
 CHAPTER 1 N GETTING STARTED WITH JAVA 8

1-2. Getting to “Hello, World”

Problem
You’ve installed Java SE 8 and the NetBeans IDE. Now you want to run a simple Java program to verify that your
installation is working properly.

Solution
Begin by opening the NetBeans IDE. You should see a workspace resembling the one in Figure 1-2. You may see some
projects in the left-hand pane if you’ve already been working on projects within the IDE.

Figure 1-2. Opening the NetBeans IDE

3
CHAPTER 1 N GETTING STARTED WITH JAVA 8

Go to the File menu and select New Project. You’ll see the dialog in Figure 1-3. Choose the Java category, and
then Java Application. Click Next to advance to the dialog shown in Figure 1-4.

Figure 1-3. Creating a new Java SE project

4
 CHAPTER 1 N GETTING STARTED WITH JAVA 8

Figure 1-4. Naming the project

Give your project a name. For the project related to this book, use the name Java8Recipes. Enter that name into
the Project Name text box at the top of the dialog in Figure 1-4.
Then specify the name of your main class in the Create Main Class text box. Give the following name:

org.java8recipes.chapter01.recipe1_02.HelloWorld

Be sure to that you’ve entered the project name and class name just as we provide them here, because the code
to follow depends upon your doing so. Make sure the Project Name text box specifies Java8Recipes. Make sure the
Create Main Class text box specifies org.java8recipes.chapter01.recipe1_02.HelloWorld.

N Tip Pay attention to case, Java is case-sensitive.

Press Finish to complete the wizard and create a skeleton project. You should now be looking at a Java source file.
Skeleton code is generated for you, and your NetBeans IDE window should resemble the one in Figure 1-5.

5
CHAPTER 1 N GETTING STARTED WITH JAVA 8

Figure 1-5. Viewing the skeleton code generated by NetBeans

Place your cursor anywhere in the source code pane. Press CTRL-A to select all the skeleton code. Then press
Delete to get rid of it. Replace the deleted code with that from Listing 1-1.

Listing 1-1. A “Hello, World” Example

package org.java8recipes.chapter01.recipe1_02;

/* An object of this class will hold the message. */

class HelloMessage {
private String message = "";

public HelloMessage() {
this.message = "Default Message";
}

6
 CHAPTER 1 N GETTING STARTED WITH JAVA 8

public void setMessage (String m) {

this.message = m;
}

public String getMessage () {

return this.message.toUpperCase();
}

/* The main program begins in this class */

public class HelloWorld {

public static void main(String[] args) {

HelloMessage hm;
hm = new HelloMessage();

System.out.println(hm.getMessage());

hm.setMessage("Hello, World");

System.out.println(hm.getMessage());
}

You can find the code in Listing 1-1 as part of our example download for the book. It’s in the file HelloWorld.java,
and you’ll find that file within the NetBeans source package named org.java8recipes.chapter01.recipe1_02.
All recipe solutions of substance throughout this book are in that example download.
Make sure you have pasted (or typed) the code from Listing 1-1. Compile and run the program, and you should
see the following output:

run:
DEFAULT MESSAGE
HELLO, WORLD
BUILD SUCCESSFUL (total time: 1 second)

This output will appear in a new pane named “Output” that is opened by NetBeans at the bottom of the
IDE window.

How It Works
You can run almost all the solutions in this chapter using the same general technique shown in this recipe. We’ve
been painstakingly detailed for that reason, showing the step-by-step screenshots just this one time.

7
CHAPTER 1 N GETTING STARTED WITH JAVA 8

Packages
The solution example begins by creating a Java package:

package org.java8recipes.chapter01.recipe1_02;

Packages are a way of grouping related classes together into a shared namespace. The idea is to achieve universal
uniqueness by working your way down your organization’s domain name in reverse order. It is also customary to
write package names in all lowercase.
NetBeans will create a directory structure to mimic your package path. In this case, NetBeans created the
following directory path:

C:\Users\JonathanGennick\Documents\NetBeansProjects\
Java8Recipes\src\org\java8recipes\chapter01\recipe1_02

Following are some things to notice about this path:

u The front part is C:\Users\...\NetBeansProjects. NetBeans creates all projects under a
NetbeansProject directory unless you specify otherwise, which you can do from the dialog in
Figure 1-4. Many developers specify shorter paths.
u Next is the first occurrence of Java8Recipes. This occurrence corresponds to the project name
you gave when you filled in the Project Name text box from Figure 1-4.
u Any source files you create go into the src directory. NetBeans creates other directories at this
level. For example, NetBeans creates a build directory, and then underneath it is a classes
subdirectory to hold your compiled class files.
u Last are the directories mirroring the package path that you specify, in this case
org\java8recipes\chapter01\recipe1_02. When you compile your code, an identical
structure is created under the build\classes directory. Note that if using another IDE,
you may see differences in the directories that are created.
You do not need to explicitly create a package. If you do not create one, the Java compiler will create one for you,
and give it a name that is hidden from you. We prefer to be explicit, and you should too. Being thoughtful and explicit
about Java package names is de rigueur in the professional setting. Organization, as well as judiciously chosen naming
conventions, is important when developing any significant application.

JavaBeans-Style Classes
Next in the solution example you see a class definition following the JavaBeans pattern. The definition of
HelloMessage follows a pattern that you’ll encounter often in Java programming, and we include it for that reason.
The class is a simple one, capable of holding a single, string value named greeting.
Three methods are defined on the class:
HelloMessage(). This method, also known as the constructor, is named the same as the
class. In this case, it takes no arguments. It’s automatically invoked whenever you create a
new object of the class. Note that this is known as a “no-arg” constructor because it is typed
out within the class, and it takes no arguments. If you do not supply a constructor, the JVM
will supply a default constructor (also takes no arguments) automatically.
setMessage(String). This accessor method begins with the word set. It takes one
parameter. It specifies the message to be returned by the corresponding get method.
getMessage(). This accessor method returns the currently-defined message. In our
example, we choose to uppercase the message.

8
 CHAPTER 1 N GETTING STARTED WITH JAVA 8

N Note Accessor methods are used in JavaBeans classes to access any privately declared class members. In this case,
the private variable identified as message can be accessed using these methods. Accessor methods are more commonly
referred to as “getters” and “setters.”

Methods beginning with set and get are termed as setter and getter methods. The variable message is private to
the class, which means you have no direct access to message from outside of the class.
You’ll see the keyword this used in the class. It is a special keyword in Java used to reference the current object.
Its use is redundant in Listing 1-1, but would be needed if any of the methods happened to create variables of their
own that were also named message.
It is common in Java to mediate access to class variables through setter and getter methods like those in our
example. Those methods represent a contract of sorts with other classes and your main program. Their benefit is
that you can change the storage implementation of HelloMessage however you like. Other code that depends upon
HelloMessage will continue to work properly so long as you maintain the external behavior of setMessage() and
getMessage().

The Main Program

The incantation public static void main(...) is used from within a public class to denote the beginning point of a
Java program. That declaration begins an executable method named main. You must specify one parameter that is an
array of strings, and typically that parameter is defined as String[] args.
When you execute the currently selected class, NetBeans compiles the code to a set of binary files, and then
transfers control to the main() method. That method, in turn, does the following:
1. Executes HelloMessage hm to create a variable named hm that is capable of holding an
instance of the class HelloMessage. The variable hm is empty at this point.
2. Invokes new HelloMessage() to create an object of the class by that name. The no-arg
constructor will be executed, and "Default Message" is now the greeting text. The new
object is now stored in the variable hm.
3. Makes a call to System.out.println() to show that the object’s no-arg constructor
has indeed executed as expected. The greeting "DEFAULT MESSAGE" is displayed in the
“Output” pane.
4. Sets the message to be the traditional text "Hello, World".
5. Makes another call to System.out.println() to output the new message that has just
been set. Now you see the greeting "hello, world" added to the “Output” pane.
The pattern in the solution is common in Java programming. The main() method is where execution begins.
Variables are defined, and objects are created using the new operator. Object variables are often set and retrieved using
setter and getter methods.

N Tip Command-line apps are passé. System administrators and programmers sometimes write them as utilities, or
to batch-process large amounts of data. But in the main, today’s applications are GUI applications. JavaFX is the way
forward in writing those applications, and you can learn about it in Chapters 14 through 17. Recipe 14-1 provides what is
essentially a “Hello, World” application in GUI form.

9
CHAPTER 1 N GETTING STARTED WITH JAVA 8

1-3. Compiling and Executing from the Command-line Interpreter

Problem
You aren’t able to install an IDE, or you don’t want to do so. You want to compile and execute your Java programs from
the command-line.

Solution
Compile your programs using the javac command. Then execute them via the java command.
Begin by making sure you have your JDK’s bin directory in your execution path. You might need to execute a
command such as one of the following.
Windows:

path %path%C:\Program Files\Java\jdk1.8.0\bin

OS X:

export PATH=/Library/Java/JavaVirtualMachines/jdk1.8.0.jdk/Contents/Home/bin

Then make sure your CLASSPATH environment variable includes the directory containing your Java code. The
following is an example of setting the environment variable under Windows:

set CLASSPATH=<<path-to-my-Java>>

Now change your current working directory to be the one corresponding to your project. Recipe 1-2 had you
create a project named Java8Recipes. Change to that project’s directory on a Windows system as follows:

cd <path-to-project>\Java8Recipes

Descend one level into the src subdirectory:

cd src

From here, you can issue javac commands to compile any classes in your project. Prepend the appropriate
package name as part of your path leading to each source file to be compiled. Be sure to include the .java extension
after your file name. For example, issue the following command to compile the HelloWorld class from Recipe 1-2.
Windows:

javac org\java8recipes\chapter01\recipe1_02\HelloWorld.java

OS X:

javac org/java8recipes/chapter01/recipe1_02/HelloWorld.java

You should now have a .class file in the same directory as your .java file. For example:

dir org\java8recipes\chapter01\recipe1_02 /B

HelloMessage.class
HelloWorld.class
HelloWorld.java

10
 CHAPTER 1 N GETTING STARTED WITH JAVA 8

Compilation produces two files. One is for HelloMessage, and the other is for the class named HelloWorld
implementing the main() method.
Execute the main() method by issuing the java command to invoke the Java Virtual Machine (JVM). Pass the
fully-qualified class name as a parameter to the command. Qualify the class name by prepending the package name,
but this time use the same dot-notation as used in your source file. For example:

java org.java8recipes.chapter1.recipe1_02.HelloWorld

Do not specify .class at the end of the command. You are referencing HelloWorld now as a class name, and not
as a file name. You should see the same output as from Recipe 1-2.

N Tip One compiles source code. Source code is kept in files, so your operating-system’s file and directory-path
notation is appropriate. One executes a class. A class is an abstract concept in the language, so the language’s
dot-notation becomes appropriate. Keep this distinction in mind to help yourself remember when to use which notation.

How It Works
The first two solution steps are housekeeping steps. You must have the Java compiler and the virtual machine in your
execution path. It’s also necessary for any classes used by your program to be found somewhere along what is termed
the class path. One way to specify the class path is through the CLASSPATH environment variable.
The command java with no c at the end is for executing compiled code. Pass as a parameter the qualified
name of the class containing your main method. The JVM will interpret and execute the byte-code within that class,
beginning from the main method. The JVM will search along the class path for any additionally required classes such
as HelloMessage.
The compiler’s default behavior is to place each generated class file into the same directory as holds the
corresponding source file. You can override that behavior through the -d option. For example:

javac -d "<specify-different-location>" "<path-to-project>

\Java8Recipes\src\org\java8recipes\chapter1\recipe1_02\HelloWorld.java"

The -d option in this command specifies the same directory as NetBeans is using in our own environment as the
target for holding generated class files. The command also specifies the full path and file name of the source file. Thus,
the command can be executed with the same result regardless of the current working directory.

N Tip Configure your system so that your command-line environment has the execution path and class path set
correctly by default. The typical approach in Linux is to put appropriate commands into your .profile or .bash_profile
files. Under Windows you can specify environment variable defaults from the Control Panel applet named System, by
clicking on the Advanced system settings link, and then on the Environment Variables button.

There may be times when you need to specify a custom class path for a specific execution of the JVM. You can do
that through the -cp parameter, as follows:

java -cp ".;<path-to-project>\Java8Recipes\build\classes\org\java8recipes\chapter1\recipe1_02"

org.java8recipes.chapter1.recipe1_02.HelloWorld

11
CHAPTER 1 N GETTING STARTED WITH JAVA 8

This execution will search first in the current working directory (the leading dot in the class path), and then under
the specified package directory corresponding to where NetBeans would place the compiled classes.

N Note See Recipe 1-10 for more on configuring your class path.

1-4. Declaring Simple Variables

Problem
You want to create some variables and manipulate data within your program.

Solution
Java implements eight primitive data types. There is also special support for the String class type. Listing 1-2 shows
an example declaration of each. Draw from the example to declare the variables needed in your own application.

Listing 1-2. Declarations for Primitive and String Types

package org.java8recipes.chapter01.recipe1_04;

public class DeclarationsExample {

public static void main (String[] args) {
boolean BooleanVal = true; /* Default is false */

char charval = 'G'; /* Unicode UTF-16 */

charval = '\u0490'; /* Ukrainian letter Ghe(DZ) */

byte byteval; /* 8 bits, -127 to 127 */

short shortval; /* 16 bits, -32,768 to 32,768 */
int intval; /* 32 bits, -2147483648 to 2147483647 */
long longval; /* 64 bits, -(2^64) to 2^64 - 1 */

float floatval = 10.123456F; /* 32-bit IEEE 754 */

double doubleval = 10.12345678987654; /* 64-bit IEEE 754 */

String message = "Darken the corner where you are!";

message = message.replace("Darken", "Brighten");
}
}

Variables are subject to the concept of visibility. Those created in Listing 1-2 are visible from the main() method
after they have been created, and they are deallocated when the main() method ends. They have no “life” beyond the
main() method, and are not accessible from outside of main().
Variables created at the class level are a different story. Such variables can be termed as fields, as in fields of
the class. Use of a field can be restricted to objects of the class in which it is declared, to the package in which it is
declared, or it can be accessible from any class in any package. Listing 1-3 shows some of how to control visibility via
the private and public keywords.

12
 CHAPTER 1 N GETTING STARTED WITH JAVA 8

Listing 1-3. Visibility and the Concept of Fields

package org.java8recipes.chapter01.recipe1_04;

class TestClass {
private long visibleOnlyInThisClass;
double visibleFromEntirePackage;

void setLong (long val) {

visibleOnlyInThisClass = val;
}

long getLong () {
return visibleOnlyInThisClass;
}
}

public class VisibilityExample {

public static void main(String[] args) {
TestClass tc = new TestClass();
tc.setLong(32768);
tc.visibleFromEntirePackage = 3.1415926535;
System.out.println(tc.getLong());
System.out.println(tc.visibleFromEntirePackage);
}
}

Output:

32768
3.1415926535

Fields are typically tied to an object of a class. Each object of a class holds an instance of each field in the class.
However, you can define so-called static fields that occur just once, and with a single value shared by all objects of the
given class. Listing 1-4 illustrates the difference.

Listing 1-4. Static Fields

package org.java8recipes.chapter01.recipe1_04;

class StaticDemo {
public static boolean oneValueForAllObjects = false;
}

public class StaticFieldsExample {

public static void main (String[] args) {
StaticDemo sd1 = new StaticDemo();
StaticDemo sd2 = new StaticDemo();
System.out.println(sd1.oneValueForAllObjects);
System.out.println(sd2.oneValueForAllObjects);
sd1.oneValueForAllObjects = true;

13
CHAPTER 1 N GETTING STARTED WITH JAVA 8

System.out.println(sd1.oneValueForAllObjects);
System.out.println(sd2.oneValueForAllObjects);
}

Listing 1-4 produces the following output:

false
false
true
true

The field oneValueForAllObjects was set to true only for the class instance named sd1. Yet it is true for instance
sd2 also. This is because of the keyword static used in declaring that field. Static fields occur one time for all objects
of their class.

How It Works
Listing 1-2 illustrates the basic format of a variable declaration:

type variable;

It’s common to initialize variables when declaring them, so you’ll often see:

type variable = initialValue;

Field declarations can be preceded by modifiers. For example:

public static variable = initialValue;

private variable;

It’s common to put the visibility modifier — public or private — first, but you are free to list the modifiers in any
order you like. Be aware that there are additional modifiers that you will encounter and need to learn about as you get
deeper into the language.
The String type is special in Java. It’s really a class type, but syntactically you can treat it as a primitive type.
Java automatically creates a String object whenever you enclose a string of characters within double-quotes ("...").
You aren’t required to invoke a constructor, nor to specify the new keyword. Yet String is a class, and there are methods
in that class that are available to you. One such method is the replace() method shown at the end of Listing 1-2.
Strings are composed of characters. Java’s char type is a two-byte construct for storing a single character in
Unicode-s UTF-16 encoding. You can generate literals of the char type in two ways:
u If a character is easy to type, then enclose it within single quotes (e.g.: 'G').
u Otherwise, specify the four-digit UTF-16 code point value prefaced by \u (e.g.: '\u0490').
Some Unicode code points require five digits. These cannot be represented in a single char value. See Chapter 10
if you need more information on Unicode and internationalization.
Avoid using any of the primitive types for monetary values. Especially avoid either of the floating-point types for
that purpose. Refer instead to Chapter 4 and its recipe on using BigDecimal to calculate monetary amounts (Recipe 4-7).
BigDecimal is also useful anytime you need accurate, fixed-decimal arithmetic.

14
 CHAPTER 1 N GETTING STARTED WITH JAVA 8

If you are new to Java, you may be unfamiliar with the String[] array notation, as demonstrated in the examples.
Please see Chapter 7 for more information on arrays. It covers enumerations, arrays, and also generic data types. Also
in that chapter are examples showing how to write iterative code to work with collections of values such as an array.

N Note If you’re curious about the Ukrainian letter in Listing 1-2, it is the Cyrillic letter Ghe with upturn. You can read
about its history at: http://en.wikipedia.org/wiki/Ghe_with_upturn. You can find its code point value in the chart at
http://www.unicode.org/charts/PDF/U0400.pdf. And the URL http://www.unicode.org/charts/ is a good place to
start whenever you need to find the code point corresponding to a given character.

1-5. Converting to and from a String

Problem
You have a value in a primitive data type, and you want to represent that value as a human-readable string. Or, you
want to go in the other direction by converting a human-readable string into a primitive data type.

Solution
Follow one of the patterns from Listing 1-5. The listing shows conversion from a string to a double-precision
floating-point value, and shows two methods for getting back to a string again.

Listing 1-5. General Pattern for String Conversions

package org.java8recipes.chapter01.recipe1_05;

public class StringConversion {

public static void main (String[] args) {

double pi;
String strval;

pi = Double.parseDouble("3.14");
System.out.println(strval = String.valueOf(pi));
System.out.println(Double.toString(pi));
}

How It Works
The solution illustrates some conversion patterns that work for all the primitive types. First, there is the conversion of
a floating-point number from its human-readable representation into the IEEE 754 format used by the Java language
for floating-point arithmetic:

pi = Double.parseDouble("3.14");

15
CHAPTER 1 N GETTING STARTED WITH JAVA 8

Notice the pattern. You can replace Double with Float, or by Long, or by whatever other type is your target data
type. Each primitive type has a corresponding wrapper class by the same name but with the initial letter uppercase.
The primitive type here is double, and the corresponding wrapper is Double. The wrapper classes implement helper
methods such as Double.parseDouble(), Long.parseLong(), Boolean.parseBoolean(), and so forth. These parse
methods convert human-readable representations into values of the respective types.
Going the other way, it is often easiest to invoke String.valueOf(). The String class implements this method,
and it is overloaded for each of the primitive data types. Alternatively, the wrapper classes also implement toString()
methods that you can invoke to convert values of the underlying type into their human-readable forms. It’s your own
preference as to which approach to take.
Conversions targeting the numeric types require some exception handling to be practical. You generally need to
gracefully accommodate a case in which a character-string value is expected to be a valid numeric representation, but
it’s not. Chapter 9 covers exception-handling in detail, and the upcoming Recipe 1-7 provides a simple example to get
you started.

N Caution Literals for the Boolean type are "true" and "false". They are case-sensitive. Any value other than
these two is silently interpreted as false when converting from a String using the Boolean parseBoolean()
conversion method.

1-6. Passing Arguments via Command-Line Execution

Problem
You want to pass values into a Java application via the command-line.

Solution
Run the application using the java command, and specify the arguments that you want to pass into it after the
application name. If you’re passing more than one argument, each should be separated by a space. For example,
suppose you want to pass the arguments to the class created in Listing 1-6.

Listing 1-6. Example of Accessing Command-Line Arguments

package org.java8recipes.chapter01.recipe1_06;

public class PassingArguments {

public static void main(String[] args){
if(args.length > 0){
System.out.println("Arguments that were passed to the program: ");
for (String arg:args){
System.out.println(arg);
}
} else {
System.out.println("No arguments passed to the program.");
}
}
}

16
 CHAPTER 1 N GETTING STARTED WITH JAVA 8

First, make sure to compile the program so that you have a .class file to execute. You can do that from within
NetBeans by right-clicking the file and choosing the “Compile File” option from the context menu.
Next, open a Command Prompt or terminal window and traverse into the build\classes directory for your project.
(See Recipe 1-3 for an extensive discussion of executing from the command-line). For example:

cd <path-to-project>\Java8Recipes\build\classes

Now issue a java command to execute the class, and type some arguments on the command-line following the
class name. The following example passes two arguments:

java org.java8recipes.chapter01.recipe1_06.PassingArguments Upper Peninsula

You should see the following output:

Arguments that were passed to the program:

Upper
Penninsula

Spaces separate arguments. Enclose strings in double quotes when you want to pass an argument containing
spaces or other special characters. For example:

java org.java8recipes.chapter01.recipe1_06.PassingArguments "Upper Peninsula"

The output now shows just one argument:

Arguments that were passed to the program:

Upper Penninsula

The double quotes translate the string "Upper Peninsula" into a single argument.

How It Works
All Java classes that are executable from the command-line or terminal contain a main() method. If you look at the
signature for the main() method, you can see that it accepts a String[] argument. In other words, you can pass an
array of String objects into the main() method. Command-line interpreters such as the Windows Command Prompt
and the various Linux and Unix shells build an array of strings out of your command-line arguments, and pass that
array to the main() method on your behalf.
The main() method in the example displays each argument that is passed. First, the length of the array named
args is tested to see whether it is greater than zero. If it is, the method will loop through each of the arguments in the
array by executing a for loop, displaying each argument along the way. If there are no arguments passed, the length
of the args array will be zero, and a message indicating such will be printed. Otherwise, you see a different message
followed by a list of arguments.
Command-line interpreters recognize spaces and sometimes other characters as delimiters. It’s generally safe
to pass numeric values as arguments delimited by spaces without bothering to enclose each value within quotes.
However, you should get into the habit of enclosing character-string arguments in double quotes, as shown in the final
solution example. Do that to eliminate any ambiguity over where each argument begins and ends.

N Note All arguments are seen by Java as character strings. If you pass numeric values as parameters, they enter
Java as character strings in human-readable form. You can convert them into their appropriate numeric types using the
conversion methods shown in Recipe 1-5.

17
CHAPTER 1 N GETTING STARTED WITH JAVA 8

1-7. Accepting Input from the Keyboard

Problem
You are interested in writing a command-line or terminal application that will accept user input from the keyboard.

Solution
Make use of the java.io.BufferedReader and java.io.InputStreamReader classes to read keyboard entry and store
it into local variables. Listing 1-7 shows a program that will keep prompting for input until you enter some characters
that represent a valid value of type long.

Listing 1-7. Keyboard Input and Exception Handling

package org.java8recipes.chapter01.recipe1_07;

import java.io.*;

public class AcceptingInput {

public static void main(String[] args){
BufferedReader readIn = new BufferedReader(
new InputStreamReader(System.in)
);
String numberAsString = "";
long numberAsLong = 0;

boolean numberIsValid = false;

do {
/* Ask the user for a number. */
System.out.println("Please enter a number: ");
try {
numberAsString = readIn.readLine();
System.out.println("You entered " + numberAsString);
} catch (IOException ex){
System.out.println(ex);
}

/* Convert the number into binary form. */

try {
numberAsLong = Long.parseLong(numberAsString);
numberIsValid = true;
} catch (NumberFormatException nfe) {
System.out.println ("Not a number!");
}
} while (numberIsValid == false);
}
}

18
 CHAPTER 1 N GETTING STARTED WITH JAVA 8

Following is an example run of this program:

Please enter a number:

No
You entered No
Not a number!
Please enter a number:
Yes
You entered Yes
Not a number!
Please enter a number:
42
You entered 42
BUILD SUCCESSFUL (total time: 11 seconds)

The first two inputs did not represent valid values in the long data type. The third value was valid, and the
run ended.

How It Works
Quite often our applications need to accept user input of some kind. Granted, most applications are not used from
the command-line or terminal nowadays, but having the ability to create an application that reads input from the
command-line or terminal helps to lay a good foundation, and may be useful in some applications. Terminal input
can also be useful in developing administrative applications that you or a system administrator may use.
Two helper classes were used in the solution to this recipe. They are java.io.BufferedReader and
java.io.InputStreamReader. The early portion of the code that’s using those classes is especially important to
understand:

BufferedReader readIn = new BufferedReader(

new InputStreamReader(System.in)
);

The innermost object in this statement is System.in. It represents the keyboard. You do not need to declare
System.in. Java’s runtime environment creates the object for you. It is simply “there” to be used.
System.in provides access to raw bytes of data from the input device, which is the keyboard in our example. It is
the job of the InputStreamReader class to take those bytes and convert them into characters in your current character
set. System.in is passed to the InputStreamReader() constructor to create an InputStreamReader object.
InputStreamReader knows about characters, but not about lines. It is the BufferedReader class’s job to detect
line breaks in the input stream, and to enable you to conveniently read a line at a time. BufferedReader also aids
efficiency by allowing physical reads from the input device to be done in different-size chunks than by which your
application consumes the data. This aspect can make a difference when the input stream is a large file rather than the
keyboard.
Following is how the program in Listing 1-7 makes use of an instance (named readIn) of the BufferedReader
class to read a line of input from the keyboard:

numberAsString = readIn.readLine();

Executing this statement triggers the following sequence:

1. System.in returns a sequence of bytes.
2. InputStreamReader converts those bytes into characters.

19
CHAPTER 1 N GETTING STARTED WITH JAVA 8

3. BufferedReader breaks the character stream into lines of input.

4. readLine() returns one line of input to the application.
I/O calls must be wrapped in try...catch blocks. These blocks catch any exceptions that may occur. The try part
in the example will fail in the event a conversion is unsuccessful. A failure prevents the numberIsValid flag from being
set to true, which causes the do loop to make another iteration so that the user can try again at entering a valid value.
The following statement at the top of Listing 1-7 deserves some mention:

import java.io.*;

This statement makes available the classes and methods defined in the java.io package. These include
InputStreamReader and BufferedReader. Also included is the IOException class used in the first try...catch block.

1-8. Documenting Your Code

Problem
You want to document some of your Java classes to assist in future maintenance.

Solution
Use Javadoc to place comments before any class, method, or field that you want to document. To begin such a
comment, write the characters /**. Then begin each subsequent line with an asterisk (*). Lastly, close the comment
with the characters */ on a line by themselves at the end. Listing 1-8 shows a method commented with Javadoc.

Listing 1-8. Comments Made in Javadoc Form

package org.java8recipes.chapter01.recipe1_08;

import java.math.BigInteger;

public class JavadocExample {

/**
* Accepts an unlimited number of values and
* returns the sum.
*
* @param nums Must be an array of BigInteger values.
* @return Sum of all numbers in the array.
*/
public static BigInteger addNumbers(BigInteger[] nums) {
BigInteger result = new BigInteger("0");
for (BigInteger num:nums){
result = result.add(num);
}

return result;
}
/**
Test the addNumbers method.
* @param args not used
*/

20
 CHAPTER 1 N GETTING STARTED WITH JAVA 8

public static void main (String[] args) {

BigInteger[] someValues = {BigInteger.TEN, BigInteger.ONE};
System.out.println(addNumbers(someValues));
}
}

Comments can be added to the beginning of classes and fields in the same way. The comments are helpful to
you and other programmers maintaining the code, and their specific format enables easy generation of an HTML
reference to your code.
Generate the HTML reference by invoking the tool named Javadoc. This is a command-line tool that parses a
named Java source file and formulates HTML documentation based upon the defined class elements and Javadoc
comments. For example:

javadoc JavadocExample.java

This command will produce several HTML files containing the documentation for the class, methods, and fields.
If no Javadoc comments exist within the source, some default documentation will still be produced. To view the
documentation, load the following file into your browser:

index.html

The file will be in the same directory as the class or package that you are documenting. There will also be an
index-all.html file giving a strict alphabetical listing of documented entities.
Keep in mind that the same rules apply when using the Javadoc tool as when using javac. You must reside within
the same directory as the source file, or prepend the name of the file with the path to where the file is located.

How It Works
Generating documentation for applications from scratch can be quite tedious. Maintaining documentation can be even
more troublesome. The JDK comes packaged with an extensive system for documentation known as Javadoc. Placing
some special comments throughout your code source and running a simple command-line tool makes it easy to generate
useful documentation and keep it current. Moreover, even if some of the classes, methods, or fields in an application are
not commented specifically for the Javadoc utility, default documentation will still be produced for such elements.

Formatting the Documentation

To create a Javadoc comment, begin with the characters /**. Although optional since Java 1.4, a common practice is to
include an asterisk as the first character of every subsequent line within the comment. Another good practice is to indent
the comment so that it aligns with the code that is being documented. Lastly, close the comment with the characters */.
Javadoc comments should begin with a short description of the class or method. Fields are rarely commented
using Javadoc, unless they are declared public static final (constants), in which case it is a good idea to supply a
comment. A comment can be several lines in length, and can even contain more than one paragraph. If you want to
break comments into paragraphs, then separate those paragraphs using the <p> tag. Comments can include several
tags that indicate various details regarding the method or class that is being commented. Javadoc tags begin with an
ampersand (@), and some of the common tags are as follows:

@param: Name and description of a parameter

@return: What is returned from the method
@see: Reference to another piece of code

21
CHAPTER 1 N GETTING STARTED WITH JAVA 8

You may also include inline links within Javadoc to reference URLs. To include an inline link, use the tag
{@link My Link}, where link is the actual URL that you want to point at and My Link is the text that you want to have
appear. There are also many other tags that can be used within Javadoc comments, including {@literal}, {@code},
{@value org}, and many others. For a complete listing, see the Javadoc reference on the Oracle Technology
Network website.

Executing the Tool

The Javadoc tool can also be run against entire packages or source. Simply pass a package name to the Javadoc tool
rather than individual source file names. For instance, if an application includes a package named org.juneau.beans,
all source files within that package can be documented by running the tool as follows:

javadoc org.juneau.beans

To generate Javadoc for more than one package at a time, separate the package names with spaces as follows:

javadoc org.juneau.beans org.juneau.entity

Another option is to specify the path to the source files using the –sourcepath flag. For example:

javadoc –sourcepath /java/src

By default, the Javadoc tool will generate HTML and place it into the same package as the code being documented.
That result can become a cluttered nightmare if you like to have source files separate from documentation. You can
instead set up a destination for the generated documentation by passing the –d flag to the Javadoc tool.

1-9. Organizing Code with Packages

Problem
Your application consists of a set of Java classes, interfaces, and other types. You want to organize these source files to
make them easier to maintain and avoid potential class-naming conflicts.

Solution
Create Java packages and place source files within them much like a filing system. Java packages can be used to
organize logical groups of source files within an application. Packages can help to organize code, reduce naming
conflicts among different classes and other Java type files, and provide access control. To create a package, simply
create a directory within the root of your application source folder and name it. Packages are usually nested
within each other and conform to a standard naming convention. For the purposes of this recipe, assume that the
organization is named Juneau and that the organization makes widgets. To organize all the code for the widget
application, create a group of nested packages conforming to the following directory structure:

/org/juneau

Any source files that are placed within a package must contain the package statement as the first line in the
source. The package statement lists the name of the package in which the source file is contained. For instance,
suppose that the main class for the widget application is named JuneauWidgets.java. To place this class into a

22
 CHAPTER 1 N GETTING STARTED WITH JAVA 8

package named org.juneau, physically move the source file into a directory named juneau, which resides within
the org directory, which in turn resides within the root of the source folder for the application. The directory structure
should look like the following:

/org/juneau/JuneauWidgets.java

The source for JuneauWidgets.java is as follows:

package org.juneau;

/**
* The main class for the Juneau Widgets application.
* @author juneau
*/
public class JuneauWidgets {
public static void main(String[] args){
System.out println("Welcome to my app!");
}
}

The first line in the source contains the package statement, which lists the name of the package that the source file
is located within. The entire package path is listed in the statement, and the names in the path are separated by dots.

N Note A package statement must be the first statement listed within the Java source. However, there may be a
comment or Javadoc comment written before the package statement.

An application can consist of any number of packages. If the widget application contains a few classes that
represent widget objects, they could be placed within the org.juneau.widget package. The application may have
interfaces that can be used to interact with the widget objects. In this case, a package named org.juneau.interfaces
may also exist to contain any such interfaces.

How It Works
Java packages are useful for organizing source files, controlling access to different classes, and ensuring that there are
no naming conflicts. Packages are represented by a series of physical directories on a file system, and they can contain
any number of Java source files. Each source file must contain a package statement before any other statements in the
file. This package statement lists the name of the package in which the source file resides. In the solution to this recipe,
the source included the following package statement:

package org.juneau;

This package statement indicates that the source file resides within a directory named juneau, and that directory
resides within another directory named org. Package-naming conventions can vary by company or organization.
However, it is important that words are in lowercase so they do not conflict with any Java class file names. Many
companies or organizations will use the reverse of their domain name for package naming. However, if a domain
name includes hyphens, underscores should be used instead.

23
Random documents with unrelated
content Scribd suggests to you:
 143. Th. Ruggles, author of a History of the Poor, reprinted
afterwards from the Annals of Agriculture. Many passages were
omitted, in accordance with the wishes of Pitt.—Lowndes.
144. Dr. Burney’s daughter, Madame d’Arblay.
145. Arthur Young’s daughter Elizabeth, the first wife of Rev.
Samuel Hoole.
146. Th. Mace, author of Music’s Monument.
147. T. Playford, author of Music’s Delight, &c., 1668, 1676.
148. C. Simpson, author of The Division Viol, 1687.
149. See the Travels in France, Bohn’s Library, p. 335 et seq.,
for the views therein set forth.
150. All the public charges on 4,000 acres amounted only to
14l.
151. His daughter Sarah, the writer of several ingenious and
interesting works.—A. Y.
152. By Act of Parliament, 1793.
153. This recantation of Arthur Young’s former democratic
utterances was published in June 1793.
154. Marquis de Castries and Maréchal of France. Joined the
émigrés on the Revolution, and served in Condé’s army.
155. Village Politics, by Will Chip, 1793; price 2d.
156. William Coxe, 1747-1828, author of Travels into Poland,
Russia, Sweden, and Denmark, &c. &c.
157. Evidently an allusion to some work of the writer.
158. Career, general course of action or procedure.—Webster.
159. This appears to have been the place lately known as the
Thatched House Club, St. James’s Street, Piccadilly.
160. 1715-1804. Author of numerous works on speculative
history, in one of which he denied the existence of Troy.
161. Probably an allusion to A. Y.’s habit of air baths.
162. Prefer, to set forth, propose.—Webster.
163. Israel Mauduit, son of a Dissenting minister; at first the
same, afterwards merchant; published Considerations on the
German War, 1760, &c. &c. See Chalmers’ Biog. Dict.
164. No note is to be found among papers concerning this
visit.
 165. Enclosure Bill. ‘At the Revolution of 1688 more than half
the kingdom was believed to consist of moorland, forest, and fen,
and vast commons and wastes covered the greater part of
England north of the Humber. But the numerous Enclosure Bills
which began with the reign of George II., and especially marked
that of his successor, changed the whole face of the country. Ten
thousand square miles of untilled land have been [? had been]
added, under their operation, to the area of cultivation.’—Green’s
History of the English People.
166. Abolished (saving the rights of the then holders of office)
in 1812. 52 Geo. III. c. xi.
167. Now fourteen years old.
168. This passage has been crossed out with a pencil, but is
given as showing the régime of young ladies’ schools a hundred
years ago. In another note occurs the sentence, ‘Brought my
dear little girl from Camden House to London.’ Presumably
Camden Town is meant, at that time being less than suburban.
169. The county belle, Betsey Plampin, married some years
before to Mr. Orbell Oakes.
170. Lady Mary Hervey, the beautiful daughter of the Earl of
Bristol, Bishop of Derry. Her portrait, by Gainsborough, was on
show at Agnew’s in 1896.
171. Some medical questions the child wishes put to her
London doctor are here omitted.
172. John Jortin, D.D., born 1696, died 1770. His numerous
theological and historical works have been frequently reprinted.
173. Henry More, D.D., born 1614, died 1687. In 1640
published Psycho-Zoia; or, the Life of the Soul. His philosophical
and theological works have been reprinted.
174. Th. Secker, Archbishop of Canterbury, born 1693, died
1768.
175. Samuel Ogden, D.D., born 1716, died 1778.
176. Adam Littleton, D.D., born 1627, died 1674.
177. Samuel Clarke, D.D., born 1675, died 1729. The piece
alluded to was the first Boyle Lecture. Of his works Dr. Johnson
remarked, ‘I should recommend Dr. Clarke’s works were he
orthodox.’
 178. John Conybeare, D.D., born 1691, died 1755. ‘A great
champion of revelation.’
179. Plymer; in Redgrave’s Dictionary of Artists written
‘Plimer.’ Two brothers therein mentioned, Andrew and Nathaniel,
both miniature painters and exhibitors at the R.A.; born 1763,
died 1837; born 1767, died 1822.
180. Practical View of the Prevailing System of Professed
Christians in the Higher and Middle Ranks in this Country,
Contrasted with Real Christianity. Published 1797, and frequently
reprinted.
181. Th. Scott—the friend of Cowper—born 1747, died 1821,
chaplain to the Lock Hospital.
182. Th. Newton, born 1704, died 1782; edited Paradise Lost.
183. Alluding to the movement suggested by A. Y., and
ultimately carried out, of forming regiments of volunteer cavalry,
in view of the menacing attitude of France.
184. Carnot, the ‘organiser of victory,’ grandfather of the late
lamented President of the French Republic. Almost alone of the
Senate, Carnot refused to sanction the coup d’état of Napoleon,
1799.
185. J. F. Ostervald, Swiss Protestant divine, born 1683, died
1747. All his works have been translated into English.
186. These ‘Observations,’ above referred to, are inserted in
vol. xxix Annals of Agriculture.
187. Assessed taxes. On December 4, 1797, Mr. Pitt
introduced a Bill for trebling the amount of assessed taxes. This
was again debated in the House of Commons in January 1798,
and finally passed. See Hansard’s Parliamentary History.
188. In a memorandum-book of the preceding year occur the
following entries: ‘Receipts, 901l.; debts, Dec. 31, 986l.’ Debts
seem to have been a burden throughout A. Y.’s long life.
189. A. O’Connor, concerned with others in an address to the
Directory France; tried for treason at Maidstone, 1798; found not
guilty. See Annual Register, 1798.
190. These dinners to poor children were given in memory of
Bobbin.
191. Née Betsy Plampin.
 192. Referring to a long letter from the great Wilberforce on
‘Original Sin.’
193. The Letters of Maria Josepha Holroyd give an amusing
account of the events here described.
194. On November 4, 1794, Souvarow took Warsaw, when
8,000 soldiers and 12,000 men, women, and children were
massacred in cold blood. See L’histoire générale de Lavisse et
Rambaud, vol. viii. p. 358. It is to be hoped that Dr. Burney was
in ignorance of this.
195. Note by A. Y. at close of year’s diary: ‘In the summer,’ in
consequence of much conversation with Lord Carrington on the
importance of enclosures, I proposed to him that I should take a
tour expressly for the purpose of ascertaining what the effect had
really been in practice. He approved of the idea, and desired me
to execute it; and, in regard to the expense, I told him that if he
would allow 100l., I would expend it in travelling, and report to
him the country travelled and the enclosures examined, and then
he might extend or not the undertaking at his pleasure. He
approved the plan, and I accordingly employed twenty weeks on
the journey.’
196. In the Annals of Agriculture, vol. xxxv. p. 432, occurs the
following: ‘If a farming traveller comes to Kimbolton, and forgets
its mistress, may his sheep rot and crops blight! A young
duchess, ever in the country, loving it, and free from a wish for
London—a character that, if I was to give my pen scope, it would
run wild on such a subject.’
197. Full accounts of these tours are given in the Annals of
Agriculture.
198. These letters are inserted in the Annals of Agriculture,
vol. xxxv. p. 459.
199. Lord Sheffield published Remarks on the Deficiency of
Grain 1799-1800, and Observations on the Exportation of Wool
from Great Britain to Ireland. 1800.
200. The Elements of Agriculture.
201. Mrs. Oakes, née Betsy Plampin.
202. A Collection of Theological Tracts, by the Bishop of
Llandaff, 6 vols.
 203. This seems to have been an anticipation of table-turning.
204. Samuel Horsley, born 1733, died 1806, Bishop of St.
Asaph’s, St. David’s, and Rochester; celebrated for his
controversy with Dr. Priestley.
205. The Anti-Jacobin, or Weekly Examiner, was started by
Canning, J. H. Frere, and others; the editor was W. Gifford. It ran
from November 20, 1797, to July 9, 1798.
206. I print this as written, but can find no allusion in works of
reference to the circumstance mentioned.
207. C. de l’Héritier, born 1746, died 1800; botanist, and
member of the Académie des Sciences.
208. Cornelia Knight, author of Dinarbas, a continuation of
Rasselas, 1790, and other works.
209. Celebrated French geologist. Accompanied Napoleon to
Egypt; on his return was taken prisoner and confined at Messina
by the King of Sicily; on peace being made with Naples was
liberated.
210. Robert Smith, son of a banker at Nottingham; M.P. for
that town from 1770 to 1796; supporter and friend of Pitt; raised
to the Irish peerage in 1796, to the English peerage in 1797.
211. Mrs. Orbell Oakes, the beautiful Betty Plampin of former
flirtations, is ‘the friend’ henceforth constantly alluded to.
212. Isaac Milner, 1751-1820, son of a poor weaver (brother of
the no less remarkable Joseph Milner), Dean of Carlisle, and
Professor of Mathematics at Cambridge.
213. John Russell, sixth Duke, ‘the great Duke of Bedford,’
who did so much for agriculture, and in 1830 rebuilt Covent
Garden Market at a cost of 40,000l. Died 1839.
214. J. Overton, officer in the Excise; made telescopes, and
had a private press, where he printed books, mostly theological.
Died 1838. See Annual Register for that year.
215. L. W. Otto, Count of Morlay, was a German diplomatist in
the French service, and lived 1752-1817. See Didot, Biographie
Universelle.
216. This was not, perhaps, impossible. See the following note
from the Daily News Paris correspondent three or four years
ago:
 ‘An account of Napoleon I.’s visit to Breda in 1810 is now
appearing, for the first time, in the Débats, and is deeply
interesting. It will be seen that Napoleon I. at the zenith of his
power was on the point of becoming a Protestant.
‘The Emperor, after receiving several Deputies, went up to the
Catholic Vicar, who had written a speech, and proceeded to read
it. The Emperor, without replying, asked where were the
Protestant ministers. Then M. Ten Oever, in his robes, followed
by the entire Protestant clergy, was presented by the Prince de
Wagram, and read an address. The Emperor remarked with
satisfaction that the Protestant ministers wore their robes. Then,
turning to the Roman Catholic clergy, he asked, “How is it that
you are not wearing your frocks? What! I come to a Department
[Holland had been annexed to France] where the majority are
Catholics, who were formerly oppressed, and who have received
more liberty from the King, my brother, and myself, and your first
act is to show me disrespect! I have always found my
Protestants faithful subjects. I have six thousand at Paris and
eight hundred thousand in my empire, and I have no cause for
complaint against a single one. Fools that you are! If the
Concordat had not been accepted by the Pope, I should have
turned Protestant, and thirty million Frenchmen would have
followed my example. [The italics are my own.] You have
calumniated Protestants, representing them as men teaching
principles contrary to the rights of sovereigns. I have no better
subjects. They serve in my palace in Paris. It was not Luther, nor
Calvin, but the German princes who declined to submit to your
fanatical yoke. The English were quite right to part company with
you. You would like to set up scaffolds and stakes, but I will
prevent you. All authority comes from God.”’
217. D. Bogue, D.D., On the Divine Authority of the New
Testament, 1801.
218. Bishop of Cloyne, Alciphron; or, the Minute Philosopher,
1732.
219. C. Leslie, died 1722, author of The Rehearsals: Tracts
against the Deists and Socinians, 4 vols.
 220. Voyage en Amérique, 2 vols. 1800. It seems that the
French émigrés, after being most hospitably treated in England,
showed little return in the way of graciousness. See Letters of
Maria Josepha Holroyd; also the Jerningham Letters.
221. Ambrose Marie Arnault, French economist, 1750-1812.
See Vapereau.
222. See Chap. IV. ‘Ireland,’ for this curious bargain, by which
A. Y., instead of a sum total of 700l., in 1776 was to receive 72l.
per annum!
223. Mrs. Oakes.
224. This recalls Goethe’s line, ‘Der Augenblick ist Ewigkeit.’
225. Ch. Simeon, 1759-1836, an eminent divine of the
Evangelical school. His works, consisting of 2,536 sermons, &c.,
were published in twenty-one volumes in 1832.
226. Orbell Oakes, husband of ‘my friend,’ the beautiful Betsy.
227. J. Townsend, 1740-1816, English divine, and author of A
Journey through Spain, 2nd edit. 1792.
228. John Owen, D.D., 1616-1683, the great Nonconformist
divine who accompanied Cromwell to Scotland. In 1817 A. Y.
published Oweniana (or selections from his works).
229. John Flavel, Nonconformist divine, 1627-1662, author of
numerous works.
230. By Walter Marshall, 1692; frequently reprinted.
231. Joseph Skinner, Present State of Peru, 1805.
232. ‘There is now with us a Mr. Van Couver, of Vancouver’s
Island, who would entertain you very much. He is making an
agricultural tour in Sussex.’—Letters of Maria Josepha Holroyd,
p. 326.
233. Nicholas Vansittart, Lord Bexley, sometime Governor of
Bengal of great financial reputation.
234. W. Marshall, 1778-1817, a voluminous writer on
agriculture, Minutes of Agriculture, &c. &c.
235. Evidently alluding to Sir Nathaniel Wraxall, a voluminous
writer in France, whose works are now forgotten.
236. J. Blackadder, lieut.-colonel, afterwards minister, died in
prison 1685.
 237. ‘Cock’s foot grass, considered valuable as a pasture
grass in light soils.’—Loudon.
238. See Hansard.
239. ‘No cards, because cards are employed in gaming; no
assemblies, because many dissipated persons pass their lives in
assemblies. Carry this but a little further, and we must say—no
wine, because of drunkenness; no meat, because of gluttony; no
use, that there may be no abuse.’—Sydney Smith on Hannah
More.
240. Voyages and Travels in India, Ceylon, &c., 1809.
241. A pathetic interest attaches to this sentence. Here A. Y.’s
fine hold handwriting (of late rather painting in black ink) ceases.
A few desperate splashes, and we seem to see the pen
despairingly cast aside and the journalising handed over to his
secretary.
242. Still addressed to Jane Young.
243. Written from London.
244. This is explained in a letter from Mary Young to her
brother Arthur, dated March 27; no year added, but evidently
written in 1811. The Duke of Grafton died March 14, 1811. ‘It
seems that the poor patient was very intractable, and that the
operator said, “Indeed, sir, if you are not more patient I must
leave you.”... Mr. Wilberforce, with the best wishes imaginable,
called [after the couching], and was shown up to his bedroom;
and the very first words he said were, “So we have lost the poor
Duke of Grafton!” then began and continued in his mild, soft
manner a most pathetic dissertation on the duke’s pious
resignation, &c. &c., till your father burst into tears, which was,
Phipps (the oculist) vowed, the worst thing possible, and which
anyone knew in his lamentable state of inflammation was
destruction. It flung him back, being only a week after the
operation. Oh, Ar., as I greatly believe he will be entirely blind, do
try to come to him.’
245. ‘Citrine ointment: a mercurial ointment, the unguentum
hydrargyri nitralis.’—Webster.
246. A selection from the writings of Baxter, by A. Y.
247. This lady afterwards became assistant secretary to A. Y.
 248. This must be a mistake of the French secretary. Surely
Baring is intended.
249. A selection from the works of J. Owen, D.D., by A. Y.
250. A. F. Baron de, 1762-1851, celebrated agriculturist and
member of the Institut.
251. Sir Walter Scott and other historians of Napoleon refer to
a vague rumour that in 1814 and 1815 the Allied Powers had a
secret design to remove Napoleon from Elba to St. Helena. He
affected to believe the rumour, and frequently mentioned it.
 Transcriber’s Note
In the Table of Contents, the page for Chapter I was
missing and has been supplied. The page given for
Chapter III was ‘4’ and has been replaced by the
correct page 44.
The Index has frequent references to footnotes,
mentioning the page and number on those pages.
Since all footnotes have been renumbered
sequentially, for uniqueness, across the text, the
Index references have been modified to reflect the
new numbers.
On p. 223, Young includes a memorandum from
August 21, opening with a quotation mark which is
never closed. Judging from the tone of the
memorandum, it is likely that it closes at the end of a
long paragraph on p. 224 (see below).
Errors deemed most likely to be the printer’s have
been corrected, and are noted here. The references
are to the page and line in the original.
32.23 [I ]shall make the tea Added.
58.13 were the numbers Removed.
ascertained.[’]
187.30 quoted particulars o[f] Restored.
yearly expenses
211.11 ‘Last night, in[s]tead of Inserted.
reading
213.13 on the p[oli/la]ce of corn Probable.
and capital employed
224.22 secretaryship of the Board. Added.
[’]
284.26 dwells upon the present.[’] Added.
306 the study of polite letters[.] Added.
315.27 the same answer was Restored.
[r]eturned
 381.16 I have taken places[.] Added.
393.31 ‘Der Augenblick ist Added.
Ewigkeit.[’]
459.12 general anxiety and Inserted.
app[r]ehension
Transcription of Manuscript Letter after p. 188
The following is a transcription of a letter from
Arthur Young to his wife Mary. There are several
place names that resist transcription in indicated with
bracketed dashes.
No 82
Besançon July 27. 89
Dear Mary
I expected a Lr here, but was disappointed How
comes yt: I hope not to be so at Dijon.
I think I wrote you fro Strasbourg: the day after
at yt place 20,000 mob pillaged the Hotel d. Ville a
house 3 times as big as the Angel & almost tore it in
pieces: It was well furnished, but all turn’d out of
windows in sight of 6 Regim.ts who could not or w’d
not do anything to save it. From yt time to this moment
all has been riot in every place I have been at. I spent
a day at Schelestad with the Ct. de la Rochefoucauld
who was very civil & obliging but on ye qui vive for
populace who are every where in motion At one place
I was near being knocked on the head for want of a
Tiers etat Cockade; and at another saved by self
being an englishn. by explaining how ye Tiers etat pd
no taxes but the Seigneurs all in England; proposing
to them to do the same in France, they relished this,
and believed yt I was not a Seigneur, but an honest
fellow.
In this country worse & worse—they are burning
and plundering chateaus, & hunt down the Seigneurs
like wild beasts—some have been shot, others
hanged, and hundreds driven out of the Country &
ruined. You see by ye papers I suppose that the King
is at Versailles bereft of Guards power, family & all but
claps and huzzas: the Queen shut up at St Cyr; the
Count d’Artois gone to Spain it is said but first to
[————]; and all the Queen’s friends fled the
Kingdom to escape halters. Never was such a
revolution known or heard off. The towns are every
where arming the tiers etat, so it will very soon be too
late for the nobility to stir in their defence.
Pray tell Hyde to take Care that the acre in Grav
P.field yt is to be inclosed be well dunged & sowed
with cabbage seed I ordered fro [——] thro Bess—
witht fail by the 20th. august in fine order. Write me
how the Cabbages are, fro a little bed in [——] past
Round garden; How does Cooper go on? I desire that
Arthur may lose no time at home, but take Mr
Symonds directions when to go to C. I have not had a
Lr from him of 11 months; I suppose because I
expressly desired one once a fortnight: But nothing
surprizes me that come fro him; Eton has I hope has
done so much for his head that it leaves nothing for
his heart—God send it may prove so; & yt I have not
impoverished myself for nothing.
Give my dear Bobbin a Kiss for me & tell her I shall
write her a Lr next.
Adieu Yr affectt AY
Remr me to yr Mother
Say nothing to Arth. abt writing; I had much rather
have no Lr than such as those hints bring: observe
this:
Miss Young
Bradfield Hall
Bury
Suffolk
Angleterre
 *** END OF THE PROJECT GUTENBERG EBOOK THE
AUTOBIOGRAPHY OF ARTHUR YOUNG ***

Updated editions will replace the previous one—the old editions

will be renamed.

Creating the works from print editions not protected by U.S.

copyright law means that no one owns a United States copyright
in these works, so the Foundation (and you!) can copy and
distribute it in the United States without permission and without
paying copyright royalties. Special rules, set forth in the General
Terms of Use part of this license, apply to copying and
distributing Project Gutenberg™ electronic works to protect the
PROJECT GUTENBERG™ concept and trademark. Project
Gutenberg is a registered trademark, and may not be used if
you charge for an eBook, except by following the terms of the
trademark license, including paying royalties for use of the
Project Gutenberg trademark. If you do not charge anything for
copies of this eBook, complying with the trademark license is
very easy. You may use this eBook for nearly any purpose such
as creation of derivative works, reports, performances and
research. Project Gutenberg eBooks may be modified and
printed and given away—you may do practically ANYTHING in
the United States with eBooks not protected by U.S. copyright
law. Redistribution is subject to the trademark license, especially
commercial redistribution.

START: FULL LICENSE

THE FULL PROJECT GUTENBERG LICENSE
 PLEASE READ THIS BEFORE YOU DISTRIBUTE OR USE THIS WORK

To protect the Project Gutenberg™ mission of promoting the

free distribution of electronic works, by using or distributing this
work (or any other work associated in any way with the phrase
“Project Gutenberg”), you agree to comply with all the terms of
the Full Project Gutenberg™ License available with this file or
online at www.gutenberg.org/license.

Section 1. General Terms of Use and

Redistributing Project Gutenberg™
electronic works
1.A. By reading or using any part of this Project Gutenberg™
electronic work, you indicate that you have read, understand,
agree to and accept all the terms of this license and intellectual
property (trademark/copyright) agreement. If you do not agree to
abide by all the terms of this agreement, you must cease using
and return or destroy all copies of Project Gutenberg™
electronic works in your possession. If you paid a fee for
obtaining a copy of or access to a Project Gutenberg™
electronic work and you do not agree to be bound by the terms
of this agreement, you may obtain a refund from the person or
entity to whom you paid the fee as set forth in paragraph 1.E.8.

1.B. “Project Gutenberg” is a registered trademark. It may only

be used on or associated in any way with an electronic work by
people who agree to be bound by the terms of this agreement.
There are a few things that you can do with most Project
Gutenberg™ electronic works even without complying with the
full terms of this agreement. See paragraph 1.C below. There
are a lot of things you can do with Project Gutenberg™
electronic works if you follow the terms of this agreement and
help preserve free future access to Project Gutenberg™
electronic works. See paragraph 1.E below.
1.C. The Project Gutenberg Literary Archive Foundation (“the
Foundation” or PGLAF), owns a compilation copyright in the
collection of Project Gutenberg™ electronic works. Nearly all the
individual works in the collection are in the public domain in the
United States. If an individual work is unprotected by copyright
law in the United States and you are located in the United
States, we do not claim a right to prevent you from copying,
distributing, performing, displaying or creating derivative works
based on the work as long as all references to Project
Gutenberg are removed. Of course, we hope that you will
support the Project Gutenberg™ mission of promoting free
access to electronic works by freely sharing Project
Gutenberg™ works in compliance with the terms of this
agreement for keeping the Project Gutenberg™ name
associated with the work. You can easily comply with the terms
of this agreement by keeping this work in the same format with
its attached full Project Gutenberg™ License when you share it
without charge with others.

1.D. The copyright laws of the place where you are located also
govern what you can do with this work. Copyright laws in most
countries are in a constant state of change. If you are outside
the United States, check the laws of your country in addition to
the terms of this agreement before downloading, copying,
displaying, performing, distributing or creating derivative works
based on this work or any other Project Gutenberg™ work. The
Foundation makes no representations concerning the copyright
status of any work in any country other than the United States.

1.E. Unless you have removed all references to Project

Gutenberg:

1.E.1. The following sentence, with active links to, or other

immediate access to, the full Project Gutenberg™ License must
appear prominently whenever any copy of a Project
Gutenberg™ work (any work on which the phrase “Project
Gutenberg” appears, or with which the phrase “Project
Gutenberg” is associated) is accessed, displayed, performed,
viewed, copied or distributed:

This eBook is for the use of anyone anywhere in the United

States and most other parts of the world at no cost and with
almost no restrictions whatsoever. You may copy it, give it
away or re-use it under the terms of the Project Gutenberg
License included with this eBook or online at
www.gutenberg.org. If you are not located in the United
States, you will have to check the laws of the country where
you are located before using this eBook.

1.E.2. If an individual Project Gutenberg™ electronic work is

derived from texts not protected by U.S. copyright law (does not
contain a notice indicating that it is posted with permission of the
copyright holder), the work can be copied and distributed to
anyone in the United States without paying any fees or charges.
If you are redistributing or providing access to a work with the
phrase “Project Gutenberg” associated with or appearing on the
work, you must comply either with the requirements of
paragraphs 1.E.1 through 1.E.7 or obtain permission for the use
of the work and the Project Gutenberg™ trademark as set forth
in paragraphs 1.E.8 or 1.E.9.

1.E.3. If an individual Project Gutenberg™ electronic work is

posted with the permission of the copyright holder, your use and
distribution must comply with both paragraphs 1.E.1 through
1.E.7 and any additional terms imposed by the copyright holder.
Additional terms will be linked to the Project Gutenberg™
License for all works posted with the permission of the copyright
holder found at the beginning of this work.

1.E.4. Do not unlink or detach or remove the full Project

Gutenberg™ License terms from this work, or any files
containing a part of this work or any other work associated with
Project Gutenberg™.
 1.E.5. Do not copy, display, perform, distribute or redistribute
this electronic work, or any part of this electronic work, without
prominently displaying the sentence set forth in paragraph 1.E.1
with active links or immediate access to the full terms of the
Project Gutenberg™ License.

1.E.6. You may convert to and distribute this work in any binary,
compressed, marked up, nonproprietary or proprietary form,
including any word processing or hypertext form. However, if
you provide access to or distribute copies of a Project
Gutenberg™ work in a format other than “Plain Vanilla ASCII” or
other format used in the official version posted on the official
Project Gutenberg™ website (www.gutenberg.org), you must, at
no additional cost, fee or expense to the user, provide a copy, a
means of exporting a copy, or a means of obtaining a copy upon
request, of the work in its original “Plain Vanilla ASCII” or other
form. Any alternate format must include the full Project
Gutenberg™ License as specified in paragraph 1.E.1.

1.E.7. Do not charge a fee for access to, viewing, displaying,

performing, copying or distributing any Project Gutenberg™
works unless you comply with paragraph 1.E.8 or 1.E.9.

1.E.8. You may charge a reasonable fee for copies of or

providing access to or distributing Project Gutenberg™
electronic works provided that:

• You pay a royalty fee of 20% of the gross profits you derive from
the use of Project Gutenberg™ works calculated using the
method you already use to calculate your applicable taxes. The
fee is owed to the owner of the Project Gutenberg™ trademark,
but he has agreed to donate royalties under this paragraph to
the Project Gutenberg Literary Archive Foundation. Royalty
payments must be paid within 60 days following each date on
which you prepare (or are legally required to prepare) your
periodic tax returns. Royalty payments should be clearly marked
as such and sent to the Project Gutenberg Literary Archive
Foundation at the address specified in Section 4, “Information
 about donations to the Project Gutenberg Literary Archive
Foundation.”

• You provide a full refund of any money paid by a user who

notifies you in writing (or by e-mail) within 30 days of receipt that
s/he does not agree to the terms of the full Project Gutenberg™
License. You must require such a user to return or destroy all
copies of the works possessed in a physical medium and
discontinue all use of and all access to other copies of Project
Gutenberg™ works.

• You provide, in accordance with paragraph 1.F.3, a full refund of

any money paid for a work or a replacement copy, if a defect in
the electronic work is discovered and reported to you within 90
days of receipt of the work.

• You comply with all other terms of this agreement for free
distribution of Project Gutenberg™ works.

1.E.9. If you wish to charge a fee or distribute a Project

Gutenberg™ electronic work or group of works on different
terms than are set forth in this agreement, you must obtain
permission in writing from the Project Gutenberg Literary
Archive Foundation, the manager of the Project Gutenberg™
trademark. Contact the Foundation as set forth in Section 3
below.

1.F.

1.F.1. Project Gutenberg volunteers and employees expend

considerable effort to identify, do copyright research on,
transcribe and proofread works not protected by U.S. copyright
law in creating the Project Gutenberg™ collection. Despite
these efforts, Project Gutenberg™ electronic works, and the
medium on which they may be stored, may contain “Defects,”
such as, but not limited to, incomplete, inaccurate or corrupt
data, transcription errors, a copyright or other intellectual
property infringement, a defective or damaged disk or other
medium, a computer virus, or computer codes that damage or
cannot be read by your equipment.

1.F.2. LIMITED WARRANTY, DISCLAIMER OF DAMAGES -

Except for the “Right of Replacement or Refund” described in
paragraph 1.F.3, the Project Gutenberg Literary Archive
Foundation, the owner of the Project Gutenberg™ trademark,
and any other party distributing a Project Gutenberg™ electronic
work under this agreement, disclaim all liability to you for
damages, costs and expenses, including legal fees. YOU
AGREE THAT YOU HAVE NO REMEDIES FOR NEGLIGENCE,
STRICT LIABILITY, BREACH OF WARRANTY OR BREACH
OF CONTRACT EXCEPT THOSE PROVIDED IN PARAGRAPH
1.F.3. YOU AGREE THAT THE FOUNDATION, THE
TRADEMARK OWNER, AND ANY DISTRIBUTOR UNDER
THIS AGREEMENT WILL NOT BE LIABLE TO YOU FOR
ACTUAL, DIRECT, INDIRECT, CONSEQUENTIAL, PUNITIVE
OR INCIDENTAL DAMAGES EVEN IF YOU GIVE NOTICE OF
THE POSSIBILITY OF SUCH DAMAGE.

1.F.3. LIMITED RIGHT OF REPLACEMENT OR REFUND - If

you discover a defect in this electronic work within 90 days of
receiving it, you can receive a refund of the money (if any) you
paid for it by sending a written explanation to the person you
received the work from. If you received the work on a physical
medium, you must return the medium with your written
explanation. The person or entity that provided you with the
defective work may elect to provide a replacement copy in lieu
of a refund. If you received the work electronically, the person or
entity providing it to you may choose to give you a second
opportunity to receive the work electronically in lieu of a refund.
If the second copy is also defective, you may demand a refund
in writing without further opportunities to fix the problem.

1.F.4. Except for the limited right of replacement or refund set

forth in paragraph 1.F.3, this work is provided to you ‘AS-IS’,
WITH NO OTHER WARRANTIES OF ANY KIND, EXPRESS
Welcome to our website – the ideal destination for book lovers and
knowledge seekers. With a mission to inspire endlessly, we offer a
vast collection of books, ranging from classic literary works to
specialized publications, self-development books, and children's
literature. Each book is a new journey of discovery, expanding
knowledge and enriching the soul of the reade

Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.

Let us accompany you on the journey of exploring knowledge and

personal growth!

textbookfull.com