diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/EolAwareOutputStream.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/EolAwareOutputStream.java
index 1ddac18..e44970a 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/EolAwareOutputStream.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/EolAwareOutputStream.java
@@ -79,12 +79,14 @@ boolean isBeginln() {
 		return bol;
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public void write(int val) throws IOException {
 		out.write(val);
 		bol = (val == '\n');
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public void write(byte[] buf, int pos, int cnt) throws IOException {
 		if (cnt > 0) {
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeAlgorithm.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeAlgorithm.java
index 04c65ef..dd42e43 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeAlgorithm.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeAlgorithm.java
@@ -57,14 +57,15 @@
 
 /**
  * Provides the merge algorithm which does a three-way merge on content provided
- * as RawText. By default {@link HistogramDiff} is used as diff algorithm.
+ * as RawText. By default {@link org.eclipse.jgit.diff.HistogramDiff} is used as
+ * diff algorithm.
  */
 public final class MergeAlgorithm {
 	private final DiffAlgorithm diffAlg;
 
 	/**
-	 * Creates a new MergeAlgorithm which uses {@link HistogramDiff} as diff
-	 * algorithm
+	 * Creates a new MergeAlgorithm which uses
+	 * {@link org.eclipse.jgit.diff.HistogramDiff} as diff algorithm
 	 */
 	public MergeAlgorithm() {
 		this(new HistogramDiff());
@@ -88,8 +89,6 @@ public MergeAlgorithm(DiffAlgorithm diff) {
 	/**
 	 * Does the three way merge between a common base and two sequences.
 	 *
-	 * @param <S>
-	 *            type of sequence.
 	 * @param cmp comparison method for this execution.
 	 * @param base the common base sequence
 	 * @param ours the first sequence to be merged
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeChunk.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeChunk.java
index 72857ff..3867eea 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeChunk.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeChunk.java
@@ -97,7 +97,8 @@ public enum ConflictState {
 	 *            merge result. All elements between begin (including begin) and
 	 *            this element are added.
 	 * @param conflictState
-	 *            the state of this chunk. See {@link ConflictState}
+	 *            the state of this chunk. See
+	 *            {@link org.eclipse.jgit.merge.MergeChunk.ConflictState}
 	 */
 	protected MergeChunk(int sequenceIndex, int begin, int end,
 			ConflictState conflictState) {
@@ -108,7 +109,9 @@ protected MergeChunk(int sequenceIndex, int begin, int end,
 	}
 
 	/**
-	 * @return the index of the sequence to which sequence this chunks belongs
+	 * Get the index of the sequence to which this sequence chunks belongs to.
+	 *
+	 * @return the index of the sequence to which this sequence chunks belongs
 	 *         to. Same as in {@link org.eclipse.jgit.merge.MergeResult#add}
 	 */
 	public int getSequenceIndex() {
@@ -116,6 +119,9 @@ public int getSequenceIndex() {
 	}
 
 	/**
+	 * Get the first element from the specified sequence which should be
+	 * included in the merge result.
+	 *
 	 * @return the first element from the specified sequence which should be
 	 *         included in the merge result. Indexes start with 0.
 	 */
@@ -124,17 +130,22 @@ public int getBegin() {
 	}
 
 	/**
-	 * @return the end of the range of this chunk. The element this index
-	 *         points to is the first element which not added to the merge
-	 *         result. All elements between begin (including begin) and this
-	 *         element are added.
+	 * Get the end of the range of this chunk.
+	 *
+	 * @return the end of the range of this chunk. The element this index points
+	 *         to is the first element which not added to the merge result. All
+	 *         elements between begin (including begin) and this element are
+	 *         added.
 	 */
 	public int getEnd() {
 		return end;
 	}
 
 	/**
-	 * @return the state of this chunk. See {@link ConflictState}
+	 * Get the state of this chunk.
+	 *
+	 * @return the state of this chunk. See
+	 *         {@link org.eclipse.jgit.merge.MergeChunk.ConflictState}
 	 */
 	public ConflictState getConflictState() {
 		return conflictState;
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeConfig.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeConfig.java
index d059391..cdbe3cd 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeConfig.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeConfig.java
@@ -58,7 +58,10 @@
 public class MergeConfig {
 
 	/**
+	 * Get merge configuration for the current branch of the repository
+	 *
 	 * @param repo
+	 *            a {@link org.eclipse.jgit.lib.Repository} object.
 	 * @return merge configuration for the current branch of the repository
 	 */
 	public static MergeConfig getConfigForCurrentBranch(Repository repo) {
@@ -74,10 +77,14 @@ public static MergeConfig getConfigForCurrentBranch(Repository repo) {
 	}
 
 	/**
+	 * Get a parser for use with
+	 * {@link org.eclipse.jgit.lib.Config#get(SectionParser)}
+	 *
 	 * @param branch
 	 *            short branch name to get the configuration for, as returned
-	 *            e.g. by {@link Repository#getBranch()}
-	 * @return a parser for use with {@link Config#get(SectionParser)}
+	 *            e.g. by {@link org.eclipse.jgit.lib.Repository#getBranch()}
+	 * @return a parser for use with
+	 *         {@link org.eclipse.jgit.lib.Config#get(SectionParser)}
 	 */
 	public static final SectionParser<MergeConfig> getParser(
 			final String branch) {
@@ -104,6 +111,8 @@ private MergeConfig() {
 	}
 
 	/**
+	 * Get the fast forward mode configured for this branch
+	 *
 	 * @return the fast forward mode configured for this branch
 	 */
 	public FastForwardMode getFastForwardMode() {
@@ -111,6 +120,9 @@ public FastForwardMode getFastForwardMode() {
 	}
 
 	/**
+	 * Whether merges into this branch are configured to be squash merges, false
+	 * otherwise
+	 *
 	 * @return true if merges into this branch are configured to be squash
 	 *         merges, false otherwise
 	 */
@@ -119,8 +131,10 @@ public boolean isSquash() {
 	}
 
 	/**
-	 * @return false if --no-commit is configured for this branch, true
-	 *         otherwise (event if --squash is configured)
+	 * Whether {@code --no-commit} option is not set.
+	 *
+	 * @return {@code false} if --no-commit is configured for this branch,
+	 *         {@code true} otherwise (even if --squash is configured)
 	 */
 	public boolean isCommit() {
 		return commit;
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeFormatter.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeFormatter.java
index 43876a6..036917e 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeFormatter.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeFormatter.java
@@ -55,11 +55,12 @@
  */
 public class MergeFormatter {
 	/**
-	 * Formats the results of a merge of {@link RawText} objects in a Git
-	 * conformant way. This method also assumes that the {@link RawText} objects
-	 * being merged are line oriented files which use LF as delimiter. This
-	 * method will also use LF to separate chunks and conflict metadata,
-	 * therefore it fits only to texts that are LF-separated lines.
+	 * Formats the results of a merge of {@link org.eclipse.jgit.diff.RawText}
+	 * objects in a Git conformant way. This method also assumes that the
+	 * {@link org.eclipse.jgit.diff.RawText} objects being merged are line
+	 * oriented files which use LF as delimiter. This method will also use LF to
+	 * separate chunks and conflict metadata, therefore it fits only to texts
+	 * that are LF-separated lines.
 	 *
 	 * @param out
 	 *            the outputstream where to write the textual presentation
@@ -67,13 +68,13 @@ public class MergeFormatter {
 	 *            the merge result which should be presented
 	 * @param seqName
 	 *            When a conflict is reported each conflicting range will get a
-	 *            name. This name is following the "&lt;&lt;&lt;&lt;&lt;&lt;&lt; " or "&gt;&gt;&gt;&gt;&gt;&gt;&gt; "
-	 *            conflict markers. The names for the sequences are given in
-	 *            this list
+	 *            name. This name is following the "&lt;&lt;&lt;&lt;&lt;&lt;&lt;
+	 *            " or "&gt;&gt;&gt;&gt;&gt;&gt;&gt; " conflict markers. The
+	 *            names for the sequences are given in this list
 	 * @param charsetName
 	 *            the name of the characterSet used when writing conflict
 	 *            metadata
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 */
 	public void formatMerge(OutputStream out, MergeResult<RawText> res,
 			List<String> seqName, String charsetName) throws IOException {
@@ -81,13 +82,14 @@ public void formatMerge(OutputStream out, MergeResult<RawText> res,
 	}
 
 	/**
-	 * Formats the results of a merge of exactly two {@link RawText} objects in
-	 * a Git conformant way. This convenience method accepts the names for the
-	 * three sequences (base and the two merged sequences) as explicit
-	 * parameters and doesn't require the caller to specify a List
+	 * Formats the results of a merge of exactly two
+	 * {@link org.eclipse.jgit.diff.RawText} objects in a Git conformant way.
+	 * This convenience method accepts the names for the three sequences (base
+	 * and the two merged sequences) as explicit parameters and doesn't require
+	 * the caller to specify a List
 	 *
 	 * @param out
-	 *            the {@link OutputStream} where to write the textual
+	 *            the {@link java.io.OutputStream} where to write the textual
 	 *            presentation
 	 * @param res
 	 *            the merge result which should be presented
@@ -100,7 +102,7 @@ public void formatMerge(OutputStream out, MergeResult<RawText> res,
 	 * @param charsetName
 	 *            the name of the characterSet used when writing conflict
 	 *            metadata
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 */
 	@SuppressWarnings("unchecked")
 	public void formatMerge(OutputStream out, MergeResult res, String baseName,
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeResult.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeResult.java
index ff3c8ab..062d86f 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeResult.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeResult.java
@@ -51,14 +51,14 @@
 import org.eclipse.jgit.util.IntList;
 
 /**
- * The result of merging a number of {@link Sequence} objects. These sequences
- * have one common predecessor sequence. The result of a merge is a list of
- * MergeChunks. Each MergeChunk contains either a range (a subsequence) from
- * one of the merged sequences, a range from the common predecessor or a
- * conflicting range from one of the merged sequences. A conflict will be
- * reported as multiple chunks, one for each conflicting range. The first chunk
- * for a conflict is marked specially to distinguish the border between two
- * consecutive conflicts.
+ * The result of merging a number of {@link org.eclipse.jgit.diff.Sequence}
+ * objects. These sequences have one common predecessor sequence. The result of
+ * a merge is a list of MergeChunks. Each MergeChunk contains either a range (a
+ * subsequence) from one of the merged sequences, a range from the common
+ * predecessor or a conflicting range from one of the merged sequences. A
+ * conflict will be reported as multiple chunks, one for each conflicting range.
+ * The first chunk for a conflict is marked specially to distinguish the border
+ * between two consecutive conflicts.
  * <p>
  * This class does not know anything about how to present the merge result to
  * the end-user. MergeFormatters have to be used to construct something human
@@ -80,7 +80,8 @@ public class MergeResult<S extends Sequence> implements Iterable<MergeChunk> {
 	 * @param sequences
 	 *            contains the common predecessor sequence at position 0
 	 *            followed by the merged sequences. This list should not be
-	 *            modified anymore during the lifetime of this {@link MergeResult}.
+	 *            modified anymore during the lifetime of this
+	 *            {@link org.eclipse.jgit.merge.MergeResult}.
 	 */
 	public MergeResult(List<S> sequences) {
 		this.sequences = sequences;
@@ -129,10 +130,7 @@ public List<S> getSequences() {
 
 	static final ConflictState[] states = ConflictState.values();
 
-	/**
-	 * @return an iterator over the MergeChunks. The iterator does not support
-	 * the remove operation
-	 */
+	/** {@inheritDoc} */
 	@Override
 	public Iterator<MergeChunk> iterator() {
 		return new Iterator<MergeChunk>() {
@@ -160,6 +158,8 @@ public void remove() {
 	}
 
 	/**
+	 * Whether this merge result contains conflicts
+	 *
 	 * @return true if this merge result contains conflicts
 	 */
 	public boolean containsConflicts() {
@@ -173,6 +173,8 @@ public boolean containsConflicts() {
 	 * markers!) as new conflict-free content
 	 *
 	 * @param containsConflicts
+	 *            whether this merge should be seen as containing a conflict or
+	 *            not.
 	 * @since 3.5
 	 */
 	protected void setContainsConflicts(boolean containsConflicts) {
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeStrategy.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeStrategy.java
index af3d5ca..520ea6e 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeStrategy.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeStrategy.java
@@ -97,7 +97,7 @@ public abstract class MergeStrategy {
 	 *
 	 * @param imp
 	 *            the strategy to register.
-	 * @throws IllegalArgumentException
+	 * @throws java.lang.IllegalArgumentException
 	 *             a strategy by the same name has already been registered.
 	 */
 	public static void register(final MergeStrategy imp) {
@@ -111,7 +111,7 @@ public static void register(final MergeStrategy imp) {
 	 *            name the strategy can be looked up under.
 	 * @param imp
 	 *            the strategy to register.
-	 * @throws IllegalArgumentException
+	 * @throws java.lang.IllegalArgumentException
 	 *             a strategy by the same name has already been registered.
 	 */
 	public static synchronized void register(final String name,
@@ -146,7 +146,11 @@ public static synchronized MergeStrategy get(final String name) {
 		return r;
 	}
 
-	/** @return default name of this strategy implementation. */
+	/**
+	 * Get default name of this strategy implementation.
+	 *
+	 * @return default name of this strategy implementation.
+	 */
 	public abstract String getName();
 
 	/**
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/Merger.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/Merger.java
index 0c4488c..cd19d69 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/Merger.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/Merger.java
@@ -68,7 +68,8 @@
 import org.eclipse.jgit.treewalk.CanonicalTreeParser;
 
 /**
- * Instance of a specific {@link MergeStrategy} for a single {@link Repository}.
+ * Instance of a specific {@link org.eclipse.jgit.merge.MergeStrategy} for a
+ * single {@link org.eclipse.jgit.lib.Repository}.
  */
 public abstract class Merger {
 	/**
@@ -138,6 +139,8 @@ protected Merger(ObjectInserter oi) {
 	}
 
 	/**
+	 * Get the repository this merger operates on.
+	 *
 	 * @return the repository this merger operates on.
 	 */
 	@Nullable
@@ -146,8 +149,10 @@ public Repository getRepository() {
 	}
 
 	/**
+	 * Get non-null repository instance
+	 *
 	 * @return non-null repository instance
-	 * @throws NullPointerException
+	 * @throws java.lang.NullPointerException
 	 *             if the merger was constructed without a repository.
 	 * @since 4.8
 	 */
@@ -159,8 +164,11 @@ protected Repository nonNullRepo() {
 	}
 
 	/**
-	 * @return an object writer to create objects, writing objects to {@link
-	 * #getRepository()} (if a repository was provided).
+	 * Get an object writer to create objects, writing objects to
+	 * {@link #getRepository()}
+	 *
+	 * @return an object writer to create objects, writing objects to
+	 *         {@link #getRepository()} (if a repository was provided).
 	 */
 	public ObjectInserter getObjectInserter() {
 		return inserter;
@@ -203,7 +211,7 @@ public void setObjectInserter(ObjectInserter oi) {
 	 * @throws IncorrectObjectTypeException
 	 *             one of the input objects is not a commit, but the strategy
 	 *             requires it to be a commit.
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 *             one or more sources could not be read, or outputs could not
 	 *             be written to the Repository.
 	 */
@@ -231,7 +239,7 @@ public boolean merge(final AnyObjectId... tips) throws IOException {
 	 * @throws IncorrectObjectTypeException
 	 *             one of the input objects is not a commit, but the strategy
 	 *             requires it to be a commit.
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 *             one or more sources could not be read, or outputs could not
 	 *             be written to the Repository.
 	 */
@@ -267,6 +275,8 @@ public boolean merge(final boolean flush, final AnyObjectId... tips)
 	}
 
 	/**
+	 * Get the ID of the commit that was used as merge base for merging
+	 *
 	 * @return the ID of the commit that was used as merge base for merging, or
 	 *         null if no merge base was used or it was set manually
 	 * @since 3.2
@@ -281,9 +291,9 @@ public boolean merge(final boolean flush, final AnyObjectId... tips)
 	 * @param b
 	 *            the second commit in {@link #sourceObjects}.
 	 * @return the merge base of two commits
-	 * @throws IncorrectObjectTypeException
+	 * @throws org.eclipse.jgit.errors.IncorrectObjectTypeException
 	 *             one of the input objects is not a commit.
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 *             objects are missing or multiple merge bases were found.
 	 * @since 3.0
 	 */
@@ -313,9 +323,9 @@ protected RevCommit getBaseCommit(RevCommit a, RevCommit b)
 	 * @param treeId
 	 *            the tree to scan; must be a tree (not a treeish).
 	 * @return an iterator for the tree.
-	 * @throws IncorrectObjectTypeException
+	 * @throws org.eclipse.jgit.errors.IncorrectObjectTypeException
 	 *             the input object is not a tree.
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 *             the tree object is not found or cannot be read.
 	 */
 	protected AbstractTreeIterator openTree(final AnyObjectId treeId)
@@ -336,13 +346,15 @@ protected AbstractTreeIterator openTree(final AnyObjectId treeId)
 	 * @throws IncorrectObjectTypeException
 	 *             one of the input objects is not a commit, but the strategy
 	 *             requires it to be a commit.
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 *             one or more sources could not be read, or outputs could not
 	 *             be written to the Repository.
 	 */
 	protected abstract boolean mergeImpl() throws IOException;
 
 	/**
+	 * Get resulting tree.
+	 *
 	 * @return resulting tree, if {@link #merge(AnyObjectId[])} returned true.
 	 */
 	public abstract ObjectId getResultTreeId();
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/RecursiveMerger.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/RecursiveMerger.java
index 1375cd3..a621a05 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/RecursiveMerger.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/RecursiveMerger.java
@@ -83,6 +83,7 @@
  * - uses "Lists" instead of Arrays for chained types
  *
  * - recursively merges the merge bases together to compute a usable base
+ *
  * @since 3.0
  */
 public class RecursiveMerger extends ResolveMerger {
@@ -97,7 +98,9 @@ public class RecursiveMerger extends ResolveMerger {
 	 * inCore
 	 *
 	 * @param local
+	 *            a {@link org.eclipse.jgit.lib.Repository} object.
 	 * @param inCore
+	 *            a boolean.
 	 */
 	protected RecursiveMerger(Repository local, boolean inCore) {
 		super(local, inCore);
@@ -106,7 +109,7 @@ protected RecursiveMerger(Repository local, boolean inCore) {
 	/**
 	 * Normal recursive merge, implies not inCore
 	 *
-	 * @param local
+	 * @param local a {@link org.eclipse.jgit.lib.Repository} object.
 	 */
 	protected RecursiveMerger(Repository local) {
 		this(local, false);
@@ -116,7 +119,9 @@ protected RecursiveMerger(Repository local) {
 	 * Normal recursive merge, implies inCore.
 	 *
 	 * @param inserter
+	 *            an {@link org.eclipse.jgit.lib.ObjectInserter} object.
 	 * @param config
+	 *            the repository configuration
 	 * @since 4.8
 	 */
 	protected RecursiveMerger(ObjectInserter inserter, Config config) {
@@ -124,12 +129,11 @@ protected RecursiveMerger(ObjectInserter inserter, Config config) {
 	}
 
 	/**
+	 * {@inheritDoc}
+	 * <p>
 	 * Get a single base commit for two given commits. If the two source commits
 	 * have more than one base commit recursively merge the base commits
 	 * together until you end up with a single base commit.
-	 *
-	 * @throws IOException
-	 * @throws IncorrectObjectTypeException
 	 */
 	@Override
 	protected RevCommit getBaseCommit(RevCommit a, RevCommit b)
@@ -151,7 +155,7 @@ protected RevCommit getBaseCommit(RevCommit a, RevCommit b)
 	 * @return the merge base of two commits. If a criss-cross merge required a
 	 *         synthetic merge base this commit is visible only the merger's
 	 *         RevWalk and will not be in the repository.
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 * @throws IncorrectObjectTypeException
 	 *             one of the input objects is not a commit.
 	 * @throws NoMergeBaseException
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/ResolveMerger.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/ResolveMerger.java
index 83b8363..5646529 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/ResolveMerger.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/ResolveMerger.java
@@ -299,8 +299,12 @@ private static int getInCoreLimit(Config config) {
 	}
 
 	/**
+	 * Constructor for ResolveMerger.
+	 *
 	 * @param local
+	 *            the {@link org.eclipse.jgit.lib.Repository}.
 	 * @param inCore
+	 *            a boolean.
 	 */
 	protected ResolveMerger(Repository local, boolean inCore) {
 		super(local);
@@ -319,15 +323,22 @@ protected ResolveMerger(Repository local, boolean inCore) {
 	}
 
 	/**
+	 * Constructor for ResolveMerger.
+	 *
 	 * @param local
+	 *            the {@link org.eclipse.jgit.lib.Repository}.
 	 */
 	protected ResolveMerger(Repository local) {
 		this(local, false);
 	}
 
 	/**
+	 * Constructor for ResolveMerger.
+	 *
 	 * @param inserter
+	 *            an {@link org.eclipse.jgit.lib.ObjectInserter} object.
 	 * @param config
+	 *            the repository configuration
 	 * @since 4.8
 	 */
 	protected ResolveMerger(ObjectInserter inserter, Config config) {
@@ -339,6 +350,7 @@ protected ResolveMerger(ObjectInserter inserter, Config config) {
 		dircache = DirCache.newInCore();
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	protected boolean mergeImpl() throws IOException {
 		if (implicitDirCache)
@@ -379,9 +391,9 @@ private void checkout() throws NoWorkTreeException, IOException {
 	 * contained only stage 0. In case if inCore operation just clear the
 	 * history of modified files.
 	 *
-	 * @throws IOException
-	 * @throws CorruptObjectException
-	 * @throws NoWorkTreeException
+	 * @throws java.io.IOException
+	 * @throws org.eclipse.jgit.errors.CorruptObjectException
+	 * @throws org.eclipse.jgit.errors.NoWorkTreeException
 	 * @since 3.4
 	 */
 	protected void cleanUp() throws NoWorkTreeException,
@@ -482,16 +494,15 @@ private DirCacheEntry keep(DirCacheEntry e) {
 	 *            the file in the working tree
 	 * @param ignoreConflicts
 	 *            see
-	 *            {@link ResolveMerger#mergeTrees(AbstractTreeIterator, RevTree, RevTree, boolean)}
+	 *            {@link org.eclipse.jgit.merge.ResolveMerger#mergeTrees(AbstractTreeIterator, RevTree, RevTree, boolean)}
 	 * @return <code>false</code> if the merge will fail because the index entry
 	 *         didn't match ours or the working-dir file was dirty and a
 	 *         conflict occurred
-	 * @throws MissingObjectException
-	 * @throws IncorrectObjectTypeException
-	 * @throws CorruptObjectException
-	 * @throws IOException
+	 * @throws org.eclipse.jgit.errors.MissingObjectException
+	 * @throws org.eclipse.jgit.errors.IncorrectObjectTypeException
+	 * @throws org.eclipse.jgit.errors.CorruptObjectException
+	 * @throws java.io.IOException
 	 * @since 3.5
-	 * @deprecated
 	 */
 	@Deprecated
 	protected boolean processEntry(CanonicalTreeParser base,
@@ -538,16 +549,16 @@ protected boolean processEntry(CanonicalTreeParser base,
 	 *            the file in the working tree
 	 * @param ignoreConflicts
 	 *            see
-	 *            {@link ResolveMerger#mergeTrees(AbstractTreeIterator, RevTree, RevTree, boolean)}
+	 *            {@link org.eclipse.jgit.merge.ResolveMerger#mergeTrees(AbstractTreeIterator, RevTree, RevTree, boolean)}
 	 * @param attributes
 	 *            the attributes defined for this entry
 	 * @return <code>false</code> if the merge will fail because the index entry
 	 *         didn't match ours or the working-dir file was dirty and a
 	 *         conflict occurred
-	 * @throws MissingObjectException
-	 * @throws IncorrectObjectTypeException
-	 * @throws CorruptObjectException
-	 * @throws IOException
+	 * @throws org.eclipse.jgit.errors.MissingObjectException
+	 * @throws org.eclipse.jgit.errors.IncorrectObjectTypeException
+	 * @throws org.eclipse.jgit.errors.CorruptObjectException
+	 * @throws java.io.IOException
 	 * @since 4.9
 	 */
 	protected boolean processEntry(CanonicalTreeParser base,
@@ -977,12 +988,15 @@ private static boolean isGitLink(final int mode) {
 		return FileMode.GITLINK.equals(mode);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public ObjectId getResultTreeId() {
 		return (resultTree == null) ? null : resultTree.toObjectId();
 	}
 
 	/**
+	 * Set the names of the commits as they would appear in conflict markers
+	 *
 	 * @param commitNames
 	 *            the names of the commits as they would appear in conflict
 	 *            markers
@@ -992,6 +1006,8 @@ public void setCommitNames(String[] commitNames) {
 	}
 
 	/**
+	 * Get the names of the commits as they would appear in conflict markers.
+	 *
 	 * @return the names of the commits as they would appear in conflict
 	 *         markers.
 	 */
@@ -1000,17 +1016,22 @@ public void setCommitNames(String[] commitNames) {
 	}
 
 	/**
-	 * @return the paths with conflicts. This is a subset of the files listed
-	 *         by {@link #getModifiedFiles()}
+	 * Get the paths with conflicts. This is a subset of the files listed by
+	 * {@link #getModifiedFiles()}
+	 *
+	 * @return the paths with conflicts. This is a subset of the files listed by
+	 *         {@link #getModifiedFiles()}
 	 */
 	public List<String> getUnmergedPaths() {
 		return unmergedPaths;
 	}
 
 	/**
-	 * @return the paths of files which have been modified by this merge. A
-	 *         file will be modified if a content-merge works on this path or if
-	 *         the merge algorithm decides to take the theirs-version. This is a
+	 * Get the paths of files which have been modified by this merge.
+	 *
+	 * @return the paths of files which have been modified by this merge. A file
+	 *         will be modified if a content-merge works on this path or if the
+	 *         merge algorithm decides to take the theirs-version. This is a
 	 *         superset of the files listed by {@link #getUnmergedPaths()}.
 	 */
 	public List<String> getModifiedFiles() {
@@ -1018,6 +1039,10 @@ public List<String> getModifiedFiles() {
 	}
 
 	/**
+	 * Get a map which maps the paths of files which have to be checked out
+	 * because the merge created new fully-merged content for this file into the
+	 * index.
+	 *
 	 * @return a map which maps the paths of files which have to be checked out
 	 *         because the merge created new fully-merged content for this file
 	 *         into the index. This means: the merge wrote a new stage 0 entry
@@ -1028,6 +1053,8 @@ public Map<String, DirCacheEntry> getToBeCheckedOut() {
 	}
 
 	/**
+	 * Get the mergeResults
+	 *
 	 * @return the mergeResults
 	 */
 	public Map<String, MergeResult<? extends Sequence>> getMergeResults() {
@@ -1035,6 +1062,9 @@ public Map<String, MergeResult<? extends Sequence>> getMergeResults() {
 	}
 
 	/**
+	 * Get list of paths causing this merge to fail (not stopped because of a
+	 * conflict).
+	 *
 	 * @return lists paths causing this merge to fail (not stopped because of a
 	 *         conflict). <code>null</code> is returned if this merge didn't
 	 *         fail.
@@ -1059,10 +1089,10 @@ public boolean failed() {
 	 * not set explicitly and if this merger doesn't work in-core, this merger
 	 * will implicitly get and lock a default DirCache. If the DirCache is
 	 * explicitly set the caller is responsible to lock it in advance. Finally
-	 * the merger will call {@link DirCache#commit()} which requires that the
-	 * DirCache is locked. If the {@link #mergeImpl()} returns without throwing
-	 * an exception the lock will be released. In case of exceptions the caller
-	 * is responsible to release the lock.
+	 * the merger will call {@link org.eclipse.jgit.dircache.DirCache#commit()}
+	 * which requires that the DirCache is locked. If the {@link #mergeImpl()}
+	 * returns without throwing an exception the lock will be released. In case
+	 * of exceptions the caller is responsible to release the lock.
 	 *
 	 * @param dc
 	 *            the DirCache to set
@@ -1092,8 +1122,12 @@ public void setWorkingTreeIterator(WorkingTreeIterator workingTreeIterator) {
 	 * The resolve conflict way of three way merging
 	 *
 	 * @param baseTree
+	 *            a {@link org.eclipse.jgit.treewalk.AbstractTreeIterator}
+	 *            object.
 	 * @param headTree
+	 *            a {@link org.eclipse.jgit.revwalk.RevTree} object.
 	 * @param mergeTree
+	 *            a {@link org.eclipse.jgit.revwalk.RevTree} object.
 	 * @param ignoreConflicts
 	 *            Controls what to do in case a content-merge is done and a
 	 *            conflict is detected. The default setting for this should be
@@ -1110,11 +1144,11 @@ public void setWorkingTreeIterator(WorkingTreeIterator workingTreeIterator) {
 	 *            other stages are filled. Means: there is no conflict on that
 	 *            path but the new content (including conflict markers) is
 	 *            stored as successful merge result. This is needed in the
-	 *            context of {@link RecursiveMerger} where when determining
-	 *            merge bases we don't want to deal with content-merge
-	 *            conflicts.
+	 *            context of {@link org.eclipse.jgit.merge.RecursiveMerger}
+	 *            where when determining merge bases we don't want to deal with
+	 *            content-merge conflicts.
 	 * @return whether the trees merged cleanly
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 * @since 3.5
 	 */
 	protected boolean mergeTrees(AbstractTreeIterator baseTree,
@@ -1177,9 +1211,9 @@ protected boolean mergeTrees(AbstractTreeIterator baseTree,
 	 *            The walk to iterate over.
 	 * @param ignoreConflicts
 	 *            see
-	 *            {@link ResolveMerger#mergeTrees(AbstractTreeIterator, RevTree, RevTree, boolean)}
+	 *            {@link org.eclipse.jgit.merge.ResolveMerger#mergeTrees(AbstractTreeIterator, RevTree, RevTree, boolean)}
 	 * @return Whether the trees merged cleanly.
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 * @since 3.5
 	 */
 	protected boolean mergeTreeWalk(TreeWalk treeWalk, boolean ignoreConflicts)
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategyOneSided.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategyOneSided.java
index 2224dbc..979685c 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategyOneSided.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategyOneSided.java
@@ -76,21 +76,25 @@ protected StrategyOneSided(final String name, final int index) {
 		treeIndex = index;
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public String getName() {
 		return strategyName;
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public Merger newMerger(final Repository db) {
 		return new OneSide(db, treeIndex);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public Merger newMerger(final Repository db, boolean inCore) {
 		return new OneSide(db, treeIndex);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public Merger newMerger(final ObjectInserter inserter, final Config config) {
 		return new OneSide(inserter, treeIndex);
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategyRecursive.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategyRecursive.java
index 56128dd..716b136 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategyRecursive.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategyRecursive.java
@@ -54,21 +54,25 @@
  */
 public class StrategyRecursive extends StrategyResolve {
 
+	/** {@inheritDoc} */
 	@Override
 	public ThreeWayMerger newMerger(Repository db) {
 		return new RecursiveMerger(db, false);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public ThreeWayMerger newMerger(Repository db, boolean inCore) {
 		return new RecursiveMerger(db, inCore);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public ThreeWayMerger newMerger(ObjectInserter inserter, Config config) {
 		return new RecursiveMerger(inserter, config);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public String getName() {
 		return "recursive"; //$NON-NLS-1$
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategyResolve.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategyResolve.java
index 17044b5..e836719 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategyResolve.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategyResolve.java
@@ -52,24 +52,25 @@
  */
 public class StrategyResolve extends ThreeWayMergeStrategy {
 
+	/** {@inheritDoc} */
 	@Override
 	public ThreeWayMerger newMerger(Repository db) {
 		return new ResolveMerger(db, false);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public ThreeWayMerger newMerger(Repository db, boolean inCore) {
 		return new ResolveMerger(db, inCore);
 	}
 
-	/**
-	 * @since 4.8
-	 */
+	/** {@inheritDoc} */
 	@Override
 	public ThreeWayMerger newMerger(ObjectInserter inserter, Config config) {
 		return new ResolveMerger(inserter, config);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public String getName() {
 		return "resolve"; //$NON-NLS-1$
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategySimpleTwoWayInCore.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategySimpleTwoWayInCore.java
index cd427bd..5739d58 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategySimpleTwoWayInCore.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategySimpleTwoWayInCore.java
@@ -69,30 +69,33 @@
  * file contents.
  */
 public class StrategySimpleTwoWayInCore extends ThreeWayMergeStrategy {
-	/** Create a new instance of the strategy. */
+	/**
+	 * Create a new instance of the strategy.
+	 */
 	protected StrategySimpleTwoWayInCore() {
 		//
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public String getName() {
 		return "simple-two-way-in-core"; //$NON-NLS-1$
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public ThreeWayMerger newMerger(final Repository db) {
 		return new InCoreMerger(db);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public ThreeWayMerger newMerger(Repository db, boolean inCore) {
 		// This class is always inCore, so ignore the parameter
 		return newMerger(db);
 	}
 
-	/**
-	 * @since 4.8
-	 */
+	/** {@inheritDoc} */
 	@Override
 	public ThreeWayMerger newMerger(ObjectInserter inserter, Config config) {
 		return new InCoreMerger(inserter);
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/ThreeWayMergeStrategy.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/ThreeWayMergeStrategy.java
index c71590b..7d185ec 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/ThreeWayMergeStrategy.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/ThreeWayMergeStrategy.java
@@ -45,11 +45,15 @@
 
 import org.eclipse.jgit.lib.Repository;
 
-/** A merge strategy to merge 2 trees, using a common base ancestor tree. */
+/**
+ * A merge strategy to merge 2 trees, using a common base ancestor tree.
+ */
 public abstract class ThreeWayMergeStrategy extends MergeStrategy {
+	/** {@inheritDoc} */
 	@Override
 	public abstract ThreeWayMerger newMerger(Repository db);
 
+	/** {@inheritDoc} */
 	@Override
 	public abstract ThreeWayMerger newMerger(Repository db, boolean inCore);
 }
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/ThreeWayMerger.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/ThreeWayMerger.java
index b3ef0fb..3f28820 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/ThreeWayMerger.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/ThreeWayMerger.java
@@ -57,7 +57,9 @@
 import org.eclipse.jgit.treewalk.AbstractTreeIterator;
 import org.eclipse.jgit.treewalk.EmptyTreeIterator;
 
-/** A merge of 2 trees, using a common base ancestor tree. */
+/**
+ * A merge of 2 trees, using a common base ancestor tree.
+ */
 public abstract class ThreeWayMerger extends Merger {
 	private RevTree baseTree;
 
@@ -103,11 +105,11 @@ protected ThreeWayMerger(ObjectInserter inserter) {
 	 *            common base treeish; null to automatically compute the common
 	 *            base from the input commits during
 	 *            {@link #merge(AnyObjectId...)}.
-	 * @throws IncorrectObjectTypeException
+	 * @throws org.eclipse.jgit.errors.IncorrectObjectTypeException
 	 *             the object is not a treeish.
-	 * @throws MissingObjectException
+	 * @throws org.eclipse.jgit.errors.MissingObjectException
 	 *             the object does not exist.
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 *             the object could not be read.
 	 */
 	public void setBase(final AnyObjectId id) throws MissingObjectException,
@@ -119,6 +121,7 @@ public void setBase(final AnyObjectId id) throws MissingObjectException,
 		}
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public boolean merge(final AnyObjectId... tips) throws IOException {
 		if (tips.length != 2)
@@ -126,6 +129,7 @@ public boolean merge(final AnyObjectId... tips) throws IOException {
 		return super.merge(tips);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public ObjectId getBaseCommitId() {
 		return baseCommitId;
@@ -136,7 +140,7 @@ public ObjectId getBaseCommitId() {
 	 *
 	 * @return an iterator over the caller-specified merge base, or the natural
 	 *         merge base of the two input commits.
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 */
 	protected AbstractTreeIterator mergeBase() throws IOException {
 		if (baseTree != null)