From e64bb748aec7ac61f4a4e1df38ad340d7e4e3548 Mon Sep 17 00:00:00 2001 From: Andreas Schildbach Date: Sun, 11 Mar 2018 16:42:14 +0100 Subject: [PATCH] JavaDoc: Replace with {@code}. --- .../java/org/bitcoinj/core/PeerGroup.java | 6 +- .../org/bitcoinj/core/PeerSocketHandler.java | 2 +- .../core/UnsafeByteArrayOutputStream.java | 10 +- .../core/VersionedChecksummedBytes.java | 6 +- .../org/bitcoinj/crypto/DeterministicKey.java | 4 +- .../org/bitcoinj/crypto/HDKeyDerivation.java | 8 +- .../channels/IPaymentChannelClient.java | 4 +- .../org/bitcoinj/utils/BlockFileLoader.java | 2 +- .../org/bitcoinj/utils/BtcAutoFormat.java | 6 +- .../org/bitcoinj/utils/BtcFixedFormat.java | 10 +- .../java/org/bitcoinj/utils/BtcFormat.java | 228 +++++++++--------- .../wallet/DeterministicKeyChain.java | 4 +- .../org/bitcoinj/wallet/MarriedKeyChain.java | 2 +- .../channels/ChannelConnectionTest.java | 4 +- .../channels/PaymentChannelStateTest.java | 2 +- 15 files changed, 149 insertions(+), 149 deletions(-) diff --git a/core/src/main/java/org/bitcoinj/core/PeerGroup.java b/core/src/main/java/org/bitcoinj/core/PeerGroup.java index 40b49880..b98bd2c0 100644 --- a/core/src/main/java/org/bitcoinj/core/PeerGroup.java +++ b/core/src/main/java/org/bitcoinj/core/PeerGroup.java @@ -1261,10 +1261,10 @@ public class PeerGroup implements TransactionBroadcaster { * than the current chain head, the relevant parts of the chain won't be redownloaded for you.

* *

This method invokes {@link PeerGroup#recalculateFastCatchupAndFilter(FilterRecalculateMode)}. - * The return value of this method is the ListenableFuture returned by that invocation.

+ * The return value of this method is the {@code ListenableFuture} returned by that invocation.

* - * @return a future that completes once each Peer in this group has had its - * BloomFilter (re)set. + * @return a future that completes once each {@code Peer} in this group has had its + * {@code BloomFilter} (re)set. */ public ListenableFuture addPeerFilterProvider(PeerFilterProvider provider) { lock.lock(); diff --git a/core/src/main/java/org/bitcoinj/core/PeerSocketHandler.java b/core/src/main/java/org/bitcoinj/core/PeerSocketHandler.java index 0301e93c..5674eed8 100644 --- a/core/src/main/java/org/bitcoinj/core/PeerSocketHandler.java +++ b/core/src/main/java/org/bitcoinj/core/PeerSocketHandler.java @@ -39,7 +39,7 @@ import static com.google.common.base.Preconditions.*; /** * Handles high-level message (de)serialization for peers, acting as the bridge between the - * org.bitcoinj.net classes and {@link Peer}. + * {@code org.bitcoinj.net} classes and {@link Peer}. */ public abstract class PeerSocketHandler extends AbstractTimeoutHandler implements StreamConnection { private static final Logger log = LoggerFactory.getLogger(PeerSocketHandler.class); diff --git a/core/src/main/java/org/bitcoinj/core/UnsafeByteArrayOutputStream.java b/core/src/main/java/org/bitcoinj/core/UnsafeByteArrayOutputStream.java index e6dd0214..0ac2e199 100644 --- a/core/src/main/java/org/bitcoinj/core/UnsafeByteArrayOutputStream.java +++ b/core/src/main/java/org/bitcoinj/core/UnsafeByteArrayOutputStream.java @@ -56,8 +56,8 @@ public class UnsafeByteArrayOutputStream extends ByteArrayOutputStream { } /** - * Writes len bytes from the specified byte array - * starting at offset off to this byte array output stream. + * Writes {@code len} bytes from the specified byte array + * starting at offset {@code off} to this byte array output stream. * * @param b the data. * @param off the start offset in the data. @@ -82,7 +82,7 @@ public class UnsafeByteArrayOutputStream extends ByteArrayOutputStream { /** * Writes the complete contents of this byte array output stream to * the specified output stream argument, as if by calling the output - * stream's write method using out.write(buf, 0, count). + * stream's write method using {@code out.write(buf, 0, count)}. * * @param out the output stream to which to write the data. * @throws IOException if an I/O error occurs. @@ -93,7 +93,7 @@ public class UnsafeByteArrayOutputStream extends ByteArrayOutputStream { } /** - * Resets the count field of this byte array output + * Resets the {@code count} field of this byte array output * stream to zero, so that all currently accumulated output in the * output stream is discarded. The output stream can be used again, * reusing the already allocated buffer space. @@ -121,7 +121,7 @@ public class UnsafeByteArrayOutputStream extends ByteArrayOutputStream { /** * Returns the current size of the buffer. * - * @return the value of the count field, which is the number + * @return the value of the {@code count} field, which is the number * of valid bytes in this output stream. * @see java.io.ByteArrayOutputStream#count */ diff --git a/core/src/main/java/org/bitcoinj/core/VersionedChecksummedBytes.java b/core/src/main/java/org/bitcoinj/core/VersionedChecksummedBytes.java index 38141490..038cbea5 100644 --- a/core/src/main/java/org/bitcoinj/core/VersionedChecksummedBytes.java +++ b/core/src/main/java/org/bitcoinj/core/VersionedChecksummedBytes.java @@ -87,8 +87,8 @@ public class VersionedChecksummedBytes implements Serializable, Cloneable, Compa /** * {@inheritDoc} * - * This implementation narrows the return type to VersionedChecksummedBytes - * and allows subclasses to throw CloneNotSupportedException even though it + * This implementation narrows the return type to {@code VersionedChecksummedBytes} + * and allows subclasses to throw {@code CloneNotSupportedException} even though it * is never thrown by this implementation. */ @Override @@ -99,7 +99,7 @@ public class VersionedChecksummedBytes implements Serializable, Cloneable, Compa /** * {@inheritDoc} * - * This implementation uses an optimized Google Guava method to compare bytes. + * This implementation uses an optimized Google Guava method to compare {@code bytes}. */ @Override public int compareTo(VersionedChecksummedBytes o) { diff --git a/core/src/main/java/org/bitcoinj/crypto/DeterministicKey.java b/core/src/main/java/org/bitcoinj/crypto/DeterministicKey.java index 4f3a8f87..e951f759 100644 --- a/core/src/main/java/org/bitcoinj/crypto/DeterministicKey.java +++ b/core/src/main/java/org/bitcoinj/crypto/DeterministicKey.java @@ -440,9 +440,9 @@ public class DeterministicKey extends ECKey { } /** - * Derives a child at the given index using hardened derivation. Note: index is + * Derives a child at the given index using hardened derivation. Note: {@code index} is * not the "i" value. If you want the softened derivation, then use instead - * HDKeyDerivation.deriveChildKey(this, new ChildNumber(child, false)). + * {@code HDKeyDerivation.deriveChildKey(this, new ChildNumber(child, false))}. */ public DeterministicKey derive(int child) { return HDKeyDerivation.deriveChildKey(this, new ChildNumber(child, true)); diff --git a/core/src/main/java/org/bitcoinj/crypto/HDKeyDerivation.java b/core/src/main/java/org/bitcoinj/crypto/HDKeyDerivation.java index 8640617c..bc7fea49 100644 --- a/core/src/main/java/org/bitcoinj/crypto/HDKeyDerivation.java +++ b/core/src/main/java/org/bitcoinj/crypto/HDKeyDerivation.java @@ -94,11 +94,11 @@ public final class HDKeyDerivation { /** * Derives a key given the "extended" child number, ie. the 0x80000000 bit of the value that you - * pass for childNumber will determine whether to use hardened derivation or not. + * pass for {@code childNumber} will determine whether to use hardened derivation or not. * Consider whether your code would benefit from the clarity of the equivalent, but explicit, form - * of this method that takes a ChildNumber rather than an int, for example: - * deriveChildKey(parent, new ChildNumber(childNumber, true)) - * where the value of the hardened bit of childNumber is zero. + * of this method that takes a {@code ChildNumber} rather than an {@code int}, for example: + * {@code deriveChildKey(parent, new ChildNumber(childNumber, true))} + * where the value of the hardened bit of {@code childNumber} is zero. */ public static DeterministicKey deriveChildKey(DeterministicKey parent, int childNumber) { return deriveChildKey(parent, new ChildNumber(childNumber)); diff --git a/core/src/main/java/org/bitcoinj/protocols/channels/IPaymentChannelClient.java b/core/src/main/java/org/bitcoinj/protocols/channels/IPaymentChannelClient.java index 398cf2ce..0fbef16d 100644 --- a/core/src/main/java/org/bitcoinj/protocols/channels/IPaymentChannelClient.java +++ b/core/src/main/java/org/bitcoinj/protocols/channels/IPaymentChannelClient.java @@ -127,10 +127,10 @@ public interface IPaymentChannelClient { /** - *

Queries if the expire time proposed by server is acceptable. If false is return the channel + *

Queries if the expire time proposed by server is acceptable. If {@code false} is return the channel * will be closed with a {@link org.bitcoinj.protocols.channels.PaymentChannelCloseException.CloseReason#TIME_WINDOW_UNACCEPTABLE}.

* @param expireTime The time, in seconds, when this channel will be closed by the server. Note this is in absolute time, i.e. seconds since 1970-01-01T00:00:00. - * @return true if the proposed time is acceptable false otherwise. + * @return {@code true} if the proposed time is acceptable {@code false} otherwise. */ boolean acceptExpireTime(long expireTime); diff --git a/core/src/main/java/org/bitcoinj/utils/BlockFileLoader.java b/core/src/main/java/org/bitcoinj/utils/BlockFileLoader.java index 77869e79..e4d41724 100644 --- a/core/src/main/java/org/bitcoinj/utils/BlockFileLoader.java +++ b/core/src/main/java/org/bitcoinj/utils/BlockFileLoader.java @@ -36,7 +36,7 @@ import java.util.NoSuchElementException; * blocks together. Importing block data with this tool can be a lot faster than syncing over the network, if you * have the files available.

* - *

In order to comply with Iterator<Block>, this class swallows a lot of IOExceptions, which may result in a few + *

In order to comply with {@link Iterator}, this class swallows a lot of {@link IOException}s, which may result in a few * blocks being missed followed by a huge set of orphan blocks.

* *

To blindly import all files which can be found in Bitcoin Core (version >= 0.8) datadir automatically, diff --git a/core/src/main/java/org/bitcoinj/utils/BtcAutoFormat.java b/core/src/main/java/org/bitcoinj/utils/BtcAutoFormat.java index 0ac08c20..b48d4a9a 100644 --- a/core/src/main/java/org/bitcoinj/utils/BtcAutoFormat.java +++ b/core/src/main/java/org/bitcoinj/utils/BtcAutoFormat.java @@ -40,10 +40,10 @@ import java.util.Locale; * of consecutive zeros in the number that is displayed, and includes either a currency code or * symbol in the formatted value to indicate which denomination was chosen. * - *

When parsing String representations of Bitcoin monetary values, instances of + *

When parsing {@code String} representations of Bitcoin monetary values, instances of * this class automatically recognize units indicators consisting of currency codes and * symbols, including including those containing currency or metric prefixes such as - * "¢" or "c" to indicate hundredths, and interpret each number being + * {@code "¢"} or {@code "c"} to indicate hundredths, and interpret each number being * parsed in accordance with the recognized denominational units. * *

A more detailed explanation, including examples, is in the documentation for the {@link @@ -171,7 +171,7 @@ public final class BtcAutoFormat extends BtcFormat { return places; } - /** Returns the int value indicating coin denomination. This is what causes + /** Returns the {@code int} value indicating coin denomination. This is what causes * the number in a parsed value that lacks a units indicator to be interpreted as a quantity * of bitcoins. */ @Override diff --git a/core/src/main/java/org/bitcoinj/utils/BtcFixedFormat.java b/core/src/main/java/org/bitcoinj/utils/BtcFixedFormat.java index 8e7a2a8d..4ee39891 100644 --- a/core/src/main/java/org/bitcoinj/utils/BtcFixedFormat.java +++ b/core/src/main/java/org/bitcoinj/utils/BtcFixedFormat.java @@ -82,7 +82,7 @@ public final class BtcFixedFormat extends BtcFormat { } /** Return the decimal-place shift for this object's unit-denomination. For example, if - * the denomination is millibitcoins, this method will return the value 3. As + * the denomination is millibitcoins, this method will return the value {@code 3}. As * a side-effect, prefixes the currency signs of the underlying NumberFormat object. This * method is invoked by the superclass when formatting. The arguments are ignored because * the denomination is fixed regardless of the value being formatted. @@ -94,14 +94,14 @@ public final class BtcFixedFormat extends BtcFormat { } /** Return the decimal-place shift for this object's fixed unit-denomination. For example, if - * the denomination is millibitcoins, this method will return the value 3. */ + * the denomination is millibitcoins, this method will return the value {@code 3}. */ @Override public int scale() { return scale; } /** * Return the currency code that identifies the units in which values formatted and * (by-default) parsed by this instance are denominated. For example, if the formatter's - * denomination is millibitcoins, then this method will return "mBTC", + * denomination is millibitcoins, then this method will return {@code "mBTC"}, * assuming the default base currency-code is not overridden using a * {@link BtcFormat.Builder}. */ public String code() { return prefixCode(coinCode(), scale); } @@ -109,12 +109,12 @@ public final class BtcFixedFormat extends BtcFormat { /** * Return the currency symbol that identifies the units in which values formatted by this * instance are denominated. For example, when invoked on an instance denominated in - * millibitcoins, this method by default returns "₥฿", depending on the + * millibitcoins, this method by default returns {@code "₥฿"}, depending on the * locale. */ public String symbol() { return prefixSymbol(coinSymbol(), scale); } /** Return the fractional decimal-placing used when formatting. This method returns an - * int array. The value of the first element is the minimum number of + * {@code int} array. The value of the first element is the minimum number of * decimal places to be used in all cases, limited to a precision of satoshis. The value * of each successive element is the size of an optional place-group that will be applied, * possibly partially, if useful for expressing precision. The actual size of each group diff --git a/core/src/main/java/org/bitcoinj/utils/BtcFormat.java b/core/src/main/java/org/bitcoinj/utils/BtcFormat.java index 00c5e728..540ae5b1 100644 --- a/core/src/main/java/org/bitcoinj/utils/BtcFormat.java +++ b/core/src/main/java/org/bitcoinj/utils/BtcFormat.java @@ -69,7 +69,7 @@ import java.util.regex.Pattern; *

  • Construct a new formatter object using one of the factory methods. *
  • Format a value by passing it as an argument to the * {@link BtcFormat#format(Object)} method. - *
  • Parse a value by passing a String-type + *
  • Parse a value by passing a {@code String}-type * representation of it to the {@link BtcFormat#parse(String)} method. * *

    For example, depending on your locale, values might be formatted @@ -96,10 +96,10 @@ import java.util.regex.Pattern; * auto-denominating formatter is defined by its style, specified by one of the enumerated * values of {@link BtcAutoFormat.Style}. There are two styles constants: {@link * BtcAutoFormat.Style#CODE} (the default), and {@link BtcAutoFormat.Style#SYMBOL}. The - * difference is that the CODE style uses an internationally-distinct currency - * code, such as "BTC", to indicate the units of denomination, while the - * SYMBOL style uses a possibly-ambiguous currency symbol such as - * "฿". + * difference is that the {@code CODE} style uses an internationally-distinct currency + * code, such as {@code "BTC"}, to indicate the units of denomination, while the + * {@code SYMBOL} style uses a possibly-ambiguous currency symbol such as + * {@code "฿"}. * *

    The denomination used when formatting will be either bitcoin, millicoin * or microcoin, depending on the value being represented, chosen so as to minimize the number @@ -114,9 +114,9 @@ import java.util.regex.Pattern; * defined by its scale, which is the number of places one must shift the decimal point in * increasing precision to convert the representation of a given quantity of bitcoins into a * representation of the same value denominated in the formatter's units. For example, a scale - * value of 3 specifies a denomination of millibitcoins, because to represent - * 1.0000 BTC, or one bitcoin, in millibitcoins, one shifts the decimal point - * three places, that is, to 1000.0 mBTC. + * value of {@code 3} specifies a denomination of millibitcoins, because to represent + * {@code 1.0000 BTC}, or one bitcoin, in millibitcoins, one shifts the decimal point + * three places, that is, to {@code 1000.0 mBTC}. * *

    Construction

    * @@ -125,7 +125,7 @@ import java.util.regex.Pattern; *
  • Use a {@link BtcFormat.Builder} object. * *

    The factory methods are appropriate for basic use where the default - * configuration is either used or modified. The Builder + * configuration is either used or modified. The {@link Builder} * class provides more control over the configuration, and gives * access to some features not available through the factory methods, * such as using custom formatting patterns and currency symbols. @@ -134,14 +134,14 @@ import java.util.regex.Pattern; * * Although formatting and parsing is performed by one of the concrete * subclasses, you can obtain formatters using the various static factory - * methods of this abstract base class BtcFormat. There + * methods of this abstract base class {@link BtcFormat}. There * are a variety of overloaded methods that allow you to obtain a * formatter that behaves according to your needs. * *

    The primary distinction is between automatic- and * fixed-denomination formatters. By default, the - * getInstance() method with no arguments returns a new, - * automatic-denominating BtcAutoFormat instance for your + * {@code getInstance()} method with no arguments returns a new, + * automatic-denominating {@link BtcAutoFormat} instance for your * default locale that will display exactly two fractional decimal * places and a currency code. For example, if you happen to be in * the USA: @@ -151,10 +151,10 @@ import java.util.regex.Pattern; * String s = f.format(Coin.COIN); // "BTC 1.00" * * - *

    The first argument to getInstance() can determine + *

    The first argument to {@code getInstance()} can determine * whether you get an auto- or fixed-denominating formatter. If the - * type of the first argument is an int, then the value - * of that int will be interpreted as the decimal-place scale of + * type of the first argument is an {@code int}, then the value + * of that {@code int} will be interpreted as the decimal-place scale of * the {@link BtcFixedFormat} instance that is returned, and thus will * determine its denomination. For example, if you want to format * values in units of microbitcoins: @@ -168,9 +168,9 @@ import java.util.regex.Pattern; * 

    BtcFormat milliFormat = BtcFormat.getInstance(MILLICOIN_SCALE);
    * *

    Alternatively, if the type of the first argument to - * getInstance() is one of the enumerated values of the - * {@link BtcAutoFormat.Style} type, either CODE or - * SYMBOL, then you will get a {@link BtcAutoFormat} + * {@code getInstance()} is one of the enumerated values of the + * {@link BtcAutoFormat.Style} type, either {@link BtcAutoFormat.Style#CODE} or + * {@link BtcAutoFormat.Style#SYMBOL}, then you will get a {@link BtcAutoFormat} * instance that uses either a currency code or symbol, respectively, * to indicate the results of its auto-denomination. * @@ -185,15 +185,15 @@ import java.util.regex.Pattern; * is to use one of the factory methods that is named to indicate that characteristics of the * new instance returned. For fixed-denomination formatters, these methods are {@link * #getCoinInstance()}, {@link #getMilliInstance()}, and {@link #getMicroInstance()}. These - * three methods are equivalent to invoking getInstance() with a first argument of - * 0, 3 and 6, respectively. For auto-denominating + * three methods are equivalent to invoking {@code getInstance()} with a first argument of + * {@code 0}, {@code 3} and {@code 6}, respectively. For auto-denominating * formatters the relevant factory methods are {@link #getCodeInstance()} and {@link - * #getSymbolInstance()}, which are equivalent to getInstance(Style.CODE), and - * getInstance(Style.SYMBOL). + * #getSymbolInstance()}, which are equivalent to {@code getInstance(Style.CODE)}, and + * {@code getInstance(Style.SYMBOL)}. * *

    Regardless of how you specify whether your new formatter is to be of automatic- or * fixed-denomination, the next (and possibly first) parameter to each of the factory methods - * is an optional Locale value. + * is an optional {@link Locale} value. * * For example, here we construct four instances for the same locale that each format * differently the same one-bitcoin value: @@ -209,33 +209,33 @@ import java.util.regex.Pattern; * BtcFormat.getInstance(4, Locale.GERMANY).format(Coin.COIN); * * - * Omitting such a Locale parameter will give you a + * Omitting such a {@link Locale} parameter will give you a * formatter for your default locale. * *

    The final (and possibly only) arguments to the factory methods serve to set the default * number of fractional decimal places that will be displayed when formatting monetary values. - * In the case of an auto-denominating formatter, this can be a single int value, + * In the case of an auto-denominating formatter, this can be a single {@code int} value, * which will determine the number of fractional decimal places to be used in all cases, except * where either (1) doing so would provide a place for fractional satoshis, or (2) that default - * value is overridden when invoking the format() method as described below. + * value is overridden when invoking the {@code format()} method as described below. * *

    In the case of a fixed-denomination formatter, you can pass any number of - * int values. The first will determine the minimum number of fractional decimal - * places, and each following int value specifies the size of an optional group of + * {@code int} values. The first will determine the minimum number of fractional decimal + * places, and each following {@code int} value specifies the size of an optional group of * decimal-places to be displayed only if useful for expressing precision. As with auto-denominating * formatters, numbers will never be formatted with a decimal place that represents a * fractional quantity of satoshis, and these defaults can be overridden by arguments to the - * format() method. See below for examples. + * {@code format()} method. See below for examples. * - *

    The Builder Class
    + *
    The {@link Builder} Class
    * * A new {@link BtcFormat.Builder} instance is returned by the {@link #builder()} method. Such - * an object has methods that set the configuration parameters of a BtcFormat - * object. Its {@link Builder#build()} method constructs and returns a BtcFormat instance + * an object has methods that set the configuration parameters of a {@link BtcFormat} + * object. Its {@link Builder#build()} method constructs and returns a {@link BtcFormat} instance * configured according to those settings. * *

    In addition to setter-methods that correspond to the factory-method parameters explained - * above, a Builder also allows you to specify custom formatting and parsing + * above, a {@link Builder} also allows you to specify custom formatting and parsing * patterns and currency symbols and codes. For example, rather than using the default * currency symbol, which has the same unicode character point as the national currency symbol of * Thailand, some people prefer to use a capital letter "B" with a vertical overstrike. @@ -248,7 +248,7 @@ import java.util.regex.Pattern; * String out = f.format(COIN); // "B⃦1.00" depending on locale * * - * The Builder methods are chainable. So, for example, if you are + * The {@link Builder} methods are chainable. So, for example, if you are * deferential to ISO 4217, you might construct a formatter in a single line this way: * * 

    @@ -267,18 +267,18 @@ import java.util.regex.Pattern;
  * number of satoshis, while a {@link java.math.BigDecimal} is interpreted as representing a
  * number of bitcoins.  A value having a fractional amount of satoshis is rounded to the
  * nearest whole satoshi at least, and possibly to a greater unit depending on the number of
- * fractional decimal-places displayed.  The format() method will not accept an
- * argument whose type is String, Float nor Double.
+ * fractional decimal-places displayed.  The {@code format()} method will not accept an
+ * argument whose type is {@link String}, {@link Float} nor {@link Double}.
  *
  * 
    Subsequent to the monetary value to be formatted, the {@link #format(Object)} method also
- * accepts as arguments optional int values that specify the number of decimal
+ * accepts as arguments optional {@code int} values that specify the number of decimal
  * places to use to represent the fractional portion of the number.  This overrides the
  * default, and enables a single formatter instance to be reused, formatting different values
  * that require different numbers of fractional decimal places.  These parameters have the same
  * meaning as those that set the default values in the factory methods as described above.
- * Namely, a single int value determines the minimum number of fractional decimal
+ * Namely, a single {@code int} value determines the minimum number of fractional decimal
  * places that will be used in all cases, to a precision limit of satoshis.  Instances of
- * {@link BtcFixedFormat} also accept a variable-length sequence of additional int
+ * {@link BtcFixedFormat} also accept a variable-length sequence of additional {@code int}
  * values, each of which specifies the size of a group of fractional decimal-places to be used
  * in addition to all preceding places, only if useful to express precision, and only to a
  * maximum precision of satoshis.  For example:
@@ -330,8 +330,8 @@ import java.util.regex.Pattern;
  *
    * *

    When using a fixed-denomination formatter whose scale can be expressed as a standard - * "metric" prefix, you can invoke the code() and symbol() methods to - * obtain a String whose value is the appropriate currency code or symbol, + * "metric" prefix, you can invoke the {@code code()} and {@code symbol()} methods to + * obtain a {@link String} whose value is the appropriate currency code or symbol, * respectively, for that formatter. * * 

    @@ -392,11 +392,11 @@ import java.util.regex.Pattern;
  *
  * 
    Parsing
    
  *
- * 
    The {@link #parse(String)} method accepts a String argument, and returns a
+ * 
    The {@link #parse(String)} method accepts a {@link String} argument, and returns a
  * {@link Coin}-type value.  The difference in parsing behavior between instances of {@link
  * BtcFixedFormat} and {@link BtcAutoFormat} is analogous to the difference in formatting
  * behavior between instances of those classes.  Instances of {@link BtcAutoFormat} recognize
- * currency codes and symbols in the String being parsed, and interpret them as
+ * currency codes and symbols in the {@link String} being parsed, and interpret them as
  * indicators of the units in which the number being parsed is denominated.  On the other hand,
  * instances of {@link BtcFixedFormat} by default recognize no codes nor symbols, but rather
  * interpret every number as being denominated in the units that were specified when
@@ -408,21 +408,21 @@ import java.util.regex.Pattern;
  * {@link BtcAutoFormat} configured with applicable non-default pattern) will recognize a
  * variety of currency symbols and codes, including all standard international (metric)
  * prefixes from micro to mega.  For example, denominational units of microcoins may be
- * specified by µ฿, u฿, µB⃦, µɃ,
- * µBTC or other appropriate permutations of those characters.  Additionally, if
+ * specified by {@code µ฿}, {@code u฿}, {@code µB⃦}, {@code µɃ},
+ * {@code µBTC} or other appropriate permutations of those characters.  Additionally, if
  * either or both of a custom currency code or symbol is configured using {@link
  * BtcFormat.Builder#code} or {@link BtcFormat.Builder#code}, then such code or symbol will
  * be recognized in addition to those recognized by default..
  *
  * 
    Instances of this class that recognize currency signs will recognize both currency
  * symbols and codes, regardless of which that instance uses for formatting.  However, if the
- * style is CODE (and unless overridden by a custom pattern) then a space character must
- * separate the units indicator from the number.  When parsing with a SYMBOL-style
- * BtcFormat instance, on the other hand, whether or not the units indicator must
+ * style is {@code CODE} (and unless overridden by a custom pattern) then a space character must
+ * separate the units indicator from the number.  When parsing with a {@code SYMBOL}-style
+ * {@code BtcFormat} instance, on the other hand, whether or not the units indicator must
  * be separated by a space from the number is determined by the locale.  The {@link
  * BtcFormat#pattern()} method returns a representation of the pattern that
  * can be examined to determine whether a space must separate currency signs from numbers in
- * parsed Strings.
+ * parsed {@link String}s.
  *
  * 
    When parsing, if the currency-units indicator is absent, then a {@link BtcAutoFormat}
  * instance will infer a denomination of bitcoins while a {@link BtcFixedFormat} will infer the
@@ -431,10 +431,10 @@ import java.util.regex.Pattern;
  * units indicator, that space must be present in the String to be parsed, even if the units
  * indicator is absent.
  *
- * 
    The parse() method returns an instance of the
+ * 
    The {@code parse()} method returns an instance of the
  * {@link Coin} class.  Therefore, attempting to parse a value greater
- * than the maximum that a Coin object can represent will
- * raise a ParseException, as will any other detected
+ * than the maximum that a {@code Coin} object can represent will
+ * raise a {@code ParseException}, as will any other detected
  * parsing error.
  *
  *  
    Limitations
    
@@ -505,16 +505,16 @@ public abstract class BtcFormat extends Format {
     protected final List decimalGroups;
 
     /* Scale is the number of decimal-places difference from same value in bitcoins */
-    /** A constant useful for specifying a denomination of bitcoins, the int value
-     *  0. */
+    /** A constant useful for specifying a denomination of bitcoins, the {@code int} value
+     *  {@code 0}. */
     public static final int COIN_SCALE = 0;
 
-    /** A constant useful for specifying a denomination of millibitcoins, the int
-     *  value 3. */
+    /** A constant useful for specifying a denomination of millibitcoins, the {@code int}
+     *  value {@code 3}. */
     public static final int MILLICOIN_SCALE = 3;
 
-    /** A constant useful for specifying a denomination of microbitcoins, the int
-     *  value 6. */
+    /** A constant useful for specifying a denomination of microbitcoins, the {@code int}
+     *  value {@code 6}. */
     public static final int MICROCOIN_SCALE = 6;
 
     /** Return the number of decimal places by which any value denominated in the
@@ -526,12 +526,12 @@ public abstract class BtcFormat extends Format {
     /**
      * 
    This class constructs new instances of {@link BtcFormat}, allowing for the
      * configuration of those instances before they are constructed.  After obtaining a
-     * Builder object from the {@link BtcFormat#builder()} method, invoke the
+     * {@code Builder} object from the {@link BtcFormat#builder()} method, invoke the
      * necessary setter methods to obtain your desired configuration.  Finaly, the {@link
-     * #build()} method returns a new BtcFormat object that has the specified
+     * #build()} method returns a new {@code BtcFormat} object that has the specified
      * configuration.
      *
-     * 
    All the setter methods override defaults.  Invoking build() without invoking any
+     * 
    All the setter methods override defaults.  Invoking {@code build()} without invoking any
      * of the setting methods is equivalent to invoking {@link BtcFormat#getInstance()} with no arguments.
      *
      * 
    Each setter methods returns the same instance on which it is invoked,
@@ -562,11 +562,11 @@ public abstract class BtcFormat extends Format {
 
         private Builder() {}
 
-        /** Specify the new BtcFormat is to be automatically-denominating.
-         * The argument determines which of either codes or symbols the new BtcFormat
+        /** Specify the new {@code BtcFormat} is to be automatically-denominating.
+         * The argument determines which of either codes or symbols the new {@code BtcFormat}
          * will use by default to indicate the denominations it chooses when formatting values.
          *
-         * 
    Note that the Style argument specifies the
+         * 
    Note that the {@code Style} argument specifies the
          * default style, which is overridden by invoking
          * either {@link #pattern(String)} or {@link #localizedPattern(String)}.
          *
@@ -584,24 +584,24 @@ public abstract class BtcFormat extends Format {
          * This is equivalent to the {@link #minimumFractionDigits(int)} method, but named
          * appropriately for the context of generating {@link BtcAutoFormat} instances.
          *
-         *  
    If neither this method nor minimumFactionDigits() is invoked, the default value
-         *  will be 2. */
+         *  
    If neither this method nor {@code minimumFactionDigits()} is invoked, the default value
+         *  will be {@code 2}. */
         public Builder fractionDigits(int val) { return minimumFractionDigits(val); }
 
         /** Specify a fixed-denomination of units to use when formatting and parsing values.
          *  The argument specifies the number of decimal places, in increasing
          *  precision, by which each formatted value will differ from that same value
          *  denominated in bitcoins.  For example, a denomination of millibitcoins is specified
-         *  with a value of 3.
+         *  with a value of {@code 3}.
          *
-         * 
    The BtcFormat class provides appropriately named
-         * int-type constants for the three common values, {@link BtcFormat#COIN_SCALE},
+         * 
    The {@code BtcFormat} class provides appropriately named
+         * {@code int}-type constants for the three common values, {@link BtcFormat#COIN_SCALE},
          * {@link BtcFormat#MILLICOIN_SCALE} {@link BtcFormat#MICROCOIN_SCALE}.
          *
          * 
    If neither this method nor {@link #style(BtcAutoFormat.Style)} is invoked on a
-         * Builder, then the BtcFormat will default to a
+         * {@link Builder}, then the {@link BtcFormat} will default to a
          * fixed-denomination of bitcoins, equivalent to invoking this method with an argument
-         * of 0. */
+         * of {@code 0}. */
         public Builder scale(int val) {
             if (variant == Variant.AUTO)
                 throw new IllegalStateException("You cannot invoke both scale() and style()");
@@ -614,8 +614,8 @@ public abstract class BtcFormat extends Format {
          *  This method is equivalent to {@link #fractionDigits(int)}, but named appropriately for
          *  the context of generating a fixed-denomination formatter.
          *
-         *  
    If neither this method nor fractionDigits() is invoked, the default value
-         *  will be 2.  */
+         *  
    If neither this method nor {@code fractionDigits()} is invoked, the default value
+         *  will be {@code 2}.  */
         public Builder minimumFractionDigits(int val) { minimumFractionDigits = val;  return this; }
 
         /** Specify the sizes of a variable number of optional decimal-place groups in the
@@ -625,7 +625,7 @@ public abstract class BtcFormat extends Format {
          *  satoshis.
          *
          *  
    If this method is not invoked, then the number of fractional decimal places will
-         *  be limited to the value passed to {@link #minimumFractionDigits}, or 2
+         *  be limited to the value passed to {@link #minimumFractionDigits}, or {@code 2}
          *  if that method is not invoked. */
         public Builder fractionGroups(int... val) { fractionGroups = val; return this; }
 
@@ -635,7 +635,7 @@ public abstract class BtcFormat extends Format {
 
         /** Specify a currency symbol to be used in the denomination-unit indicators
          *  of formatted values.  This method only sets the symbol, but does not cause
-         *  it to be used.  You must also invoke either style(SYMBOL), or else apply
+         *  it to be used.  You must also invoke either {@code style(SYMBOL)}, or else apply
          *  a custom pattern that includes a single currency-sign character by invoking either
          *  {@link #pattern(String)} or {@link #localizedPattern(String)}.
          *
@@ -645,7 +645,7 @@ public abstract class BtcFormat extends Format {
 
         /** Specify a custom currency code to be used in the denomination-unit indicators
          *  of formatted values.  This method only sets the code, but does not cause
-         *  it to be used.  You must also invoke either style(CODE), or else apply
+         *  it to be used.  You must also invoke either {@code style(CODE)}, or else apply
          *  a custom pattern that includes a double currency-sign character by invoking either
          *  {@link #pattern(String)} or {@link #localizedPattern(String)}.
          *
@@ -684,7 +684,7 @@ public abstract class BtcFormat extends Format {
          *  pattern is identical to the patterns used by the {@link java.text.DecimalFormat}
          *  class.
          *
-         *  
    The pattern is localized according to the locale of the BtcFormat
+         *  
    The pattern is localized according to the locale of the {@code BtcFormat}
          *  instance, the symbols for which can be examined by inspecting the {@link
          *  java.text.DecimalFormatSymbols} object returned by {@link BtcFormat#symbols()}.
          *  So, for example, if you are in Germany, then the non-localized pattern of
@@ -715,7 +715,7 @@ public abstract class BtcFormat extends Format {
         }
 
         /** Return a new {@link BtcFormat} instance.  The object returned will be configured according
-         *  to the state of this Builder instance at the time this method is invoked. */
+         *  to the state of this {@code Builder} instance at the time this method is invoked. */
         public BtcFormat build() {
             BtcFormat f = variant.newInstance(this);
             if (symbol != "" || code != "") { synchronized(f.numberFormat) {
@@ -762,7 +762,7 @@ public abstract class BtcFormat extends Format {
     /**
      * Return a new instance of this class using all defaults.  The returned formatter will
      * auto-denominate values so as to minimize zeros without loss of precision and display a
-     * currency code, for example "BTC", to indicate that denomination.  The
+     * currency code, for example "{@code BTC}", to indicate that denomination.  The
      * returned object will uses the default locale for formatting the number and placement of
      * the currency-code.  Two fractional decimal places will be displayed in all formatted numbers.
      */
@@ -770,14 +770,14 @@ public abstract class BtcFormat extends Format {
 
     /**
      * Return a new auto-denominating instance that will indicate units using a currency
-     * symbol, for example, "฿".  Formatting and parsing will be done
+     * symbol, for example, {@code "฿"}.  Formatting and parsing will be done
      * according to the default locale.
      */
     public static BtcFormat getSymbolInstance() { return getSymbolInstance(defaultLocale()); }
 
     /**
      * Return a new auto-denominating instance that will indicate units using a currency
-     * code, for example, "BTC".  Formatting and parsing will be done
+     * code, for example, {@code "BTC"}.  Formatting and parsing will be done
      * according to the default locale.
      */
     public static BtcFormat getCodeInstance() { return getCodeInstance(defaultLocale()); }
@@ -785,7 +785,7 @@ public abstract class BtcFormat extends Format {
     /**
      * Return a new symbol-style auto-formatter with the given number of fractional decimal
      * places.  Denominational units will be indicated using a currency symbol, for example,
-     * "฿".  The returned object will format the fraction-part of numbers using
+     * {@code "฿"}.  The returned object will format the fraction-part of numbers using
      * the given number of decimal places, or fewer as necessary to avoid giving a place to
      * fractional satoshis.  Formatting and parsing will be done according to the default
      * locale.
@@ -797,7 +797,7 @@ public abstract class BtcFormat extends Format {
     /**
      * Return a new code-style auto-formatter with the given number of fractional decimal
      * places.  Denominational units will be indicated using a currency code, for example,
-     * "BTC".  The returned object will format the fraction-part of numbers using
+     * {@code "BTC"}.  The returned object will format the fraction-part of numbers using
      * the given number of decimal places, or fewer as necessary to avoid giving a place to
      * fractional satoshis.  Formatting and parsing will be done according to the default
      * locale.
@@ -809,14 +809,14 @@ public abstract class BtcFormat extends Format {
     /**
      * Return a new code-style auto-formatter for the given locale.  The returned object will
      * select denominational units based on each value being formatted, and will indicate those
-     * units using a currency code, for example, "mBTC".
+     * units using a currency code, for example, {@code "mBTC"}.
      */
     public static BtcFormat getInstance(Locale locale) { return getCodeInstance(locale); }
 
     /**
      * Return a new code-style auto-formatter for the given locale.  The returned object will
      * select denominational units based on each value being formatted, and will indicate those
-     * units using a currency code, for example, "mBTC".
+     * units using a currency code, for example, {@code "mBTC"}.
      */
     public static BtcFormat getCodeInstance(Locale locale) { return getInstance(CODE, locale); }
 
@@ -824,7 +824,7 @@ public abstract class BtcFormat extends Format {
      * Return a new code-style auto-formatter for the given locale with the given number of
      * fraction places.  The returned object will select denominational units based on each
      * value being formatted, and will indicate those units using a currency code, for example,
-     * "mBTC".  The returned object will format the fraction-part of numbers using
+     * {@code "mBTC"}.  The returned object will format the fraction-part of numbers using
      * the given number of decimal places, or fewer as necessary to avoid giving a place to
      * fractional satoshis.
      */
@@ -836,7 +836,7 @@ public abstract class BtcFormat extends Format {
      * Return a new code-style auto-formatter for the given locale with the given number of
      * fraction places.  The returned object will select denominational units based on each
      * value being formatted, and will indicate those units using a currency code, for example,
-     * "mBTC".  The returned object will format the fraction-part of numbers using
+     * {@code "mBTC"}.  The returned object will format the fraction-part of numbers using
      * the given number of decimal places, or fewer as necessary to avoid giving a place to
      * fractional satoshis.
      */
@@ -847,7 +847,7 @@ public abstract class BtcFormat extends Format {
     /**
      * Return a new symbol-style auto-formatter for the given locale.  The returned object will
      * select denominational units based on each value being formatted, and will indicate those
-     * units using a currency symbol, for example, "µ฿".
+     * units using a currency symbol, for example, {@code "µ฿"}.
      */
     public static BtcFormat getSymbolInstance(Locale locale) {
 	return getInstance(SYMBOL, locale);
@@ -857,7 +857,7 @@ public abstract class BtcFormat extends Format {
      * Return a new symbol-style auto-formatter for the given locale with the given number of
      * fraction places.  The returned object will select denominational units based on each
      * value being formatted, and will indicate those units using a currency symbol, for example,
-     * "µ฿".  The returned object will format the fraction-part of numbers using
+     * {@code "µ฿"}.  The returned object will format the fraction-part of numbers using
      * the given number of decimal places, or fewer as necessary to avoid giving a place to
      * fractional satoshis.
      */
@@ -868,7 +868,7 @@ public abstract class BtcFormat extends Format {
     /**
      * Return a new auto-denominating formatter.  The returned object will indicate the
      * denominational units of formatted values using either a currency symbol, such as,
-     * "฿", or code, such as "mBTC", depending on the value of
+     * {@code "฿"}, or code, such as {@code "mBTC"}, depending on the value of
      * the argument.  Formatting and parsing will be done according to the default locale.
      */
     public static BtcFormat getInstance(Style style) { return getInstance(style, defaultLocale()); }
@@ -876,8 +876,8 @@ public abstract class BtcFormat extends Format {
     /**
      * Return a new auto-denominating formatter with the given number of fractional decimal
      * places.  The returned object will indicate the denominational units of formatted values
-     * using either a currency symbol, such as, "฿", or code, such as
-     * "mBTC", depending on the value of the first argument.  The returned object
+     * using either a currency symbol, such as, {@code "฿"}, or code, such as
+     * {@code "mBTC"}, depending on the value of the first argument.  The returned object
      * will format the fraction-part of numbers using the given number of decimal places, or
      * fewer as necessary to avoid giving a place to fractional satoshis.  Formatting and
      * parsing will be done according to the default locale.
@@ -890,7 +890,7 @@ public abstract class BtcFormat extends Format {
      * Return a new auto-formatter with the given style for the given locale.
      * The returned object that will auto-denominate each formatted value, and
      * will indicate that denomination using either a currency code, such as
-     * "BTC", or symbol, such as "฿", depending on the value
+     * {@code "BTC"}, or symbol, such as {@code "฿"}, depending on the value
      * of the first argument. 
      * 
    The number of fractional decimal places in formatted number will be two, or fewer
      * as necessary to avoid giving a place to fractional satoshis.
@@ -903,7 +903,7 @@ public abstract class BtcFormat extends Format {
      * Return a new auto-formatter for the given locale with the given number of fraction places.
      * The returned object will automatically-denominate each formatted
      * value, and will indicate that denomination using either a currency code,
-     * such as "mBTC", or symbol, such as "฿",
+     * such as {@code "mBTC"}, or symbol, such as {@code "฿"},
      * according to the given style argument.  It will format each number
      * according to the given locale.
      *
@@ -936,7 +936,7 @@ public abstract class BtcFormat extends Format {
      * returned object will format and parse values according to the default locale, and will
      * format the fraction part of numbers with at least two decimal places.  The sizes of
      * additional groups of decimal places can be specified by a variable number of
-     * int arguments.  Each optional decimal-place group will be applied only if
+     * {@code int} arguments.  Each optional decimal-place group will be applied only if
      * useful for expressing precision, and will be only partially applied if necessary to
      * avoid giving a place to fractional satoshis.
      */
@@ -1099,7 +1099,7 @@ public abstract class BtcFormat extends Format {
      * of the shift from coin-denomination in increasingly-precise decimal places.  The third
      * parameter is the minimum number of fractional decimal places to use.  The third argument
      * specifies the minimum number of fractional decimal places in formatted numbers.  The
-     * last argument is a List of Integer values, each of which
+     * last argument is a {@code List} of {@link Integer} values, each of which
      * specifies the size of an additional group of fractional decimal places to use as
      * necessary to avoid rounding, down to a maximum precision of satoshis.
      */
@@ -1131,13 +1131,13 @@ public abstract class BtcFormat extends Format {
     /**
      * Formats a bitcoin value as a number and possibly a units indicator and appends the
      * resulting text to the given string buffer.  The type of monetary value argument can be
-     * any one of any of the following classes: {@link Coin},
-     * Integer, Long, BigInteger,
-     * BigDecimal.  Numeric types that can represent only an integer are interpreted
-     * as that number of satoshis.  The value of a BigDecimal is interpreted as that
+     * any one of any of the following classes: {@link Coin},
+     * {@link Integer}, {@link Long}, {@link BigInteger},
+     * {@link BigDecimal}.  Numeric types that can represent only an integer are interpreted
+     * as that number of satoshis.  The value of a {@link BigDecimal} is interpreted as that
      * number of bitcoins, rounded to the nearest satoshi as necessary.
      *
-     * @return the StringBuffer passed in as toAppendTo
+     * @return the {@link StringBuffer} passed in as {@code toAppendTo}
      */
     @Override
     public StringBuffer format(Object qty, StringBuffer toAppendTo, FieldPosition pos) {
@@ -1146,11 +1146,11 @@ public abstract class BtcFormat extends Format {
 
     /**
      * Formats a bitcoin value as a number and possibly a units indicator to a
-     * String.The type of monetary value argument can be any one of any of the
-     * following classes: {@link Coin}, Integer, Long,
-     * BigInteger, BigDecimal.  Numeric types that can represent only
+     * {@link String}.The type of monetary value argument can be any one of any of the
+     * following classes: {@link Coin}, {@link Integer}, {@link Long},
+     * {@link BigInteger}, {@link BigDecimal}.  Numeric types that can represent only
      * an integer are interpreted as that number of satoshis.  The value of a
-     * BigDecimal is interpreted as that number of bitcoins, rounded to the
+     * {@link BigDecimal} is interpreted as that number of bitcoins, rounded to the
      * nearest satoshi as necessary.
      *
      * @param minDecimals The minimum number of decimal places in the fractional part of the formatted number
@@ -1164,10 +1164,10 @@ public abstract class BtcFormat extends Format {
     /**
      * Formats a bitcoin value as a number and possibly a units indicator and appends the
      * resulting text to the given string buffer.  The type of monetary value argument can be
-     * any one of any of the following classes: {@link Coin},
-     * Integer, Long, BigInteger,
-     * BigDecimal.  Numeric types that can represent only an integer are interpreted
-     * as that number of satoshis.  The value of a BigDecimal is interpreted as that
+     * any one of any of the following classes: {@link Coin},
+     * {@link Integer}, {@link Long}, {@link BigInteger},
+     * {@link BigDecimal}.  Numeric types that can represent only an integer are interpreted
+     * as that number of satoshis.  The value of a {@link BigDecimal} is interpreted as that
      * number of bitcoins, rounded to the nearest satoshi as necessary.
      *
      * @param minDecimals The minimum number of decimal places in the fractional part of the formatted number
@@ -1195,7 +1195,7 @@ public abstract class BtcFormat extends Format {
     }    
 
     /**
-     * Return the denomination for formatting the given value.  The returned int
+     * Return the denomination for formatting the given value.  The returned {@code int}
      * is the size of the decimal-place shift between the given Bitcoin-value denominated in
      * bitcoins and that same value as formatted.  A fixed-denomination formatter will ignore
      * the arguments.
@@ -1296,7 +1296,7 @@ public abstract class BtcFormat extends Format {
     // ****** PARSING *****
 
     /**
-      * Parse a String representation of a Bitcoin monetary value.  Returns a
+      * Parse a {@link String} representation of a Bitcoin monetary value.  Returns a
       * {@link org.bitcoinj.core.Coin} object that represents the parsed value.
       * @see java.text.NumberFormat */
     @Override
@@ -1338,7 +1338,7 @@ public abstract class BtcFormat extends Format {
     }
 
     /** Set both the currency symbol and international code of the underlying {@link
-      * java.text.NumberFormat} object to the value of the given String.
+      * java.text.NumberFormat} object to the value of the given {@link String}.
       * This method is invoked in the process of parsing, not formatting.
       *
       * Only invoke this from code synchronized on the value of the first argument, and don't
@@ -1384,7 +1384,7 @@ public abstract class BtcFormat extends Format {
         );
     }
 
-    /** Parse a String representation of a Bitcoin monetary value.  If this
+    /** Parse a {@link String} representation of a Bitcoin monetary value.  If this
      * object's pattern includes a currency sign, either symbol or code, as by default is true
      * for instances of {@link BtcAutoFormat} and false for instances of {@link
      * BtcFixedFormat}, then denominated (i.e., prefixed) currency signs in the parsed String
@@ -1438,7 +1438,7 @@ public abstract class BtcFormat extends Format {
         return coin;
     }
 
-    /** Parse a String representation of a Bitcoin monetary value.  If this
+    /** Parse a {@link String} representation of a Bitcoin monetary value.  If this
      * object's pattern includes a currency sign, either symbol or code, as by default is true
      * for instances of {@link BtcAutoFormat} and false for instances of {@link
      * BtcFixedFormat}, then denominated (i.e., prefixed) currency signs in the parsed String
diff --git a/core/src/main/java/org/bitcoinj/wallet/DeterministicKeyChain.java b/core/src/main/java/org/bitcoinj/wallet/DeterministicKeyChain.java
index 735b6863..4d51725b 100644
--- a/core/src/main/java/org/bitcoinj/wallet/DeterministicKeyChain.java
+++ b/core/src/main/java/org/bitcoinj/wallet/DeterministicKeyChain.java
@@ -326,7 +326,7 @@ public class DeterministicKeyChain implements EncryptableKeyChain {
     }
 
     /**
-     * 
    Creates a deterministic key chain with the given watch key. If isFollowing flag is set then this keychain follows
+     * 
    Creates a deterministic key chain with the given watch key. If {@code isFollowing} flag is set then this keychain follows
      * some other keychain. In a married wallet following keychain represents "spouse's" keychain.
    
      * 
    Watch key has to be an account key.
    
      */
@@ -618,7 +618,7 @@ public class DeterministicKeyChain implements EncryptableKeyChain {
     }
 
     /**
-     * 
    An alias for getKeyByPath(getAccountPath()).
    
+     * 
    An alias for {@code getKeyByPath(getAccountPath())}.
    
      *
      * 
    Use this when you would like to create a watching key chain that follows this one, but can't spend money from it.
      * The returned key can be serialized and then passed into {@link #watch(org.bitcoinj.crypto.DeterministicKey)}
diff --git a/core/src/main/java/org/bitcoinj/wallet/MarriedKeyChain.java b/core/src/main/java/org/bitcoinj/wallet/MarriedKeyChain.java
index 5499b938..5b240df1 100644
--- a/core/src/main/java/org/bitcoinj/wallet/MarriedKeyChain.java
+++ b/core/src/main/java/org/bitcoinj/wallet/MarriedKeyChain.java
@@ -80,7 +80,7 @@ public class MarriedKeyChain extends DeterministicKeyChain {
         }
 
         /**
-         * Threshold, or (followingKeys.size() + 1) / 2 + 1) (majority) if unspecified.
    
+         * Threshold, or {@code (followingKeys.size() + 1) / 2 + 1)} (majority) if unspecified.
    
          * 
    IMPORTANT: As of Bitcoin Core 0.9 all multisig transactions which require more than 3 public keys are non-standard
          * and such spends won't be processed by peers with default settings, essentially making such transactions almost
          * nonspendable
    
diff --git a/core/src/test/java/org/bitcoinj/protocols/channels/ChannelConnectionTest.java b/core/src/test/java/org/bitcoinj/protocols/channels/ChannelConnectionTest.java
index ad909503..5117236a 100644
--- a/core/src/test/java/org/bitcoinj/protocols/channels/ChannelConnectionTest.java
+++ b/core/src/test/java/org/bitcoinj/protocols/channels/ChannelConnectionTest.java
@@ -85,14 +85,14 @@ public class ChannelConnectionTest extends TestWithWallet {
     public PaymentChannelClient.VersionSelector versionSelector;
 
     /**
-     * Returns true if we are using a protocol version that requires the exchange of refunds.
+     * Returns {@code true} if we are using a protocol version that requires the exchange of refunds.
      */
     private boolean useRefunds() {
         return versionSelector == PaymentChannelClient.VersionSelector.VERSION_1;
     }
 
     /**
-     * Returns true if the contract being used is a multisig contract
+     * Returns {@code true} if the contract being used is a multisig contract
      * @return
      */
     private boolean isMultiSigContract() {
diff --git a/core/src/test/java/org/bitcoinj/protocols/channels/PaymentChannelStateTest.java b/core/src/test/java/org/bitcoinj/protocols/channels/PaymentChannelStateTest.java
index 708b472b..218b734a 100644
--- a/core/src/test/java/org/bitcoinj/protocols/channels/PaymentChannelStateTest.java
+++ b/core/src/test/java/org/bitcoinj/protocols/channels/PaymentChannelStateTest.java
@@ -70,7 +70,7 @@ public class PaymentChannelStateTest extends TestWithWallet {
     public PaymentChannelClient.VersionSelector versionSelector;
 
     /**
-     * Returns true if we are using a protocol version that requires the exchange of refunds.
+     * Returns {@code true} if we are using a protocol version that requires the exchange of refunds.
      */
     private boolean useRefunds() {
         return versionSelector == PaymentChannelClient.VersionSelector.VERSION_1;