diff --git a/commons-rdf-api/src/main/java/org/apache/commons/rdf/api/RDFSyntax.java b/commons-rdf-api/src/main/java/org/apache/commons/rdf/api/RDFSyntax.java
index 3ad7c24..00b9408 100644
--- a/commons-rdf-api/src/main/java/org/apache/commons/rdf/api/RDFSyntax.java
+++ b/commons-rdf-api/src/main/java/org/apache/commons/rdf/api/RDFSyntax.java
@@ -99,12 +99,11 @@
     static RDFSyntax TRIG = W3CRDFSyntax.TRIG;
 
     /**
-     * A short name of the RDF Syntax.
+     * A short name of the RDF Syntax e.g. <code>JSONLD</code>.
      * <p>
-     * The name is specific to Commons RDF and carries no particular meaning. 
-     * 
-     * @return Short name for RDF syntax, e.g. <code>JSONLD</code>.
-     * @see #byName(String)
+     * The name is specific to Commons RDF and carries no particular meaning.
+     *
+     * @return Short name for RDF syntax
      */
     String name();
 
@@ -113,30 +112,27 @@
      * <p>
      * This is generally the title of the corresponding standard,
      * e.g. <em>RDF 1.1 Turtle</em>.
-     * 
-     * @return Title of RDF Syntax, e.g. <code>RDF 1.1 Turtle</code>.
+     *
+     * @return Title of RDF Syntax
      */
     String title();
 
     /**
-     * The IANA media type for the RDF syntax.
+     * The <a href="https://tools.ietf.org/html/rfc2046">IANA media type</a> for
+     * the RDF syntax.
      * <p>
      * The media type can be used as part of <code>Content-Type</code> and
      * <code>Accept</code> for <em>content negotiation</em> in the
      * <a href="https://tools.ietf.org/html/rfc7231#section-3.1.1.1">HTTP
      * protocol</a>.
-     * 
-     * @return IANA media type, e.g. <code>text/turtle</code>
-     *  
-     * @see #mediaTypes()
-     * @see #byMediaType(String)
-     * @see <a href="https://tools.ietf.org/html/rfc2046">IANA media type</a>
+     *
+     * @return The registered media type of the RDF Syntax
      */
     String mediaType();
 
     /**
-     * Set of IANA media types that
-     * covers this RDF syntax, including any non-official media types. 
+     * Set of <a href="https://tools.ietf.org/html/rfc2046">IANA media types</a> that
+     * covers this RDF syntax, including any non-official media types.
      * <p>
      * The media type can be used as part of <code>Content-Type</code> and
      * <code>Accept</code> for <em>content negotiation</em> in the
@@ -145,10 +141,8 @@
      * <p>
      * The returned Set MUST include the value {@link #mediaType()}; this is the
      * behaviour of the default implementation.
-     * 
-     * @return Set of IANA media types
-     * @see #mediaType()
-     * @see <a href="https://tools.ietf.org/html/rfc2046">IANA media types</a>
+     *
+     * @return The media types corresponding to the RDF Syntax
      */
     default Set<String> mediaTypes() {
         return Collections.singleton(mediaType());
@@ -157,10 +151,10 @@
     /**
      * The <a href="https://tools.ietf.org/html/rfc2046">IANA-registered</a>
      * file extension.
-     * 
-     * @return File extension including the leading period, e.g. <code>.jsonld</code>
-     * @see #fileExtensions()
-     * @see #byFileExtension(String)
+     * <p>
+     * The file extension includes the leading period, e.g. <code>.jsonld</code>
+     *
+     * @return The registered file extension of the RDF Syntax
      */
     String fileExtension();
 
@@ -171,10 +165,8 @@
      * <p>
      * The returned Set MUST include the value from {@link #fileExtension()}; this is
      * the behaviour of the default implementation.
-     * 
-     * @return Set of file extensions
-     * @see #fileExtension()
-     * @see #byFileExtension(String)
+     *
+     * @return The file extensions corresponding to the RDF Syntax
      */
     default Set<String> fileExtensions() {
         return Collections.singleton(fileExtension());
@@ -184,8 +176,8 @@
      * Indicate if this RDF syntax supports
      * <a href="https://www.w3.org/TR/rdf11-concepts/#section-dataset">RDF
      * Datasets</a>.
-     * 
-     * @return <code>true</code> if this syntax supports datasets, otherwise <code>false</code>.
+     *
+     * @return true if this RDF Syntax supports datasets; false otherwise
      */
     boolean supportsDataset();
 
@@ -207,9 +199,10 @@
      * {@link #mediaType()}s are equal when compared as lower case strings
      * according to {@link String#toLowerCase(Locale)} with the locale
      * {@link Locale#ROOT}.
-     * <p>
-     * {@inheritDoc}
-s     */
+     *
+     * @param obj the object with which to compare
+     * @return true if this object is the same as the obj argument; false otherwise
+     */
     @Override
     boolean equals(Object obj);
 
@@ -267,8 +260,6 @@
      *         a matching {@link RDFSyntax#mediaType()}, otherwise
      *         {@link Optional#empty()} indicating that no matching syntax was
      *         found.
-     * @see #mediaTypes()
-     *         
      */
     static Optional<RDFSyntax> byMediaType(final String mediaType) {
         final String type = mediaType.toLowerCase(Locale.ROOT).split("\\s*;", 2)[0];
@@ -291,7 +282,6 @@
      *         a matching {@link RDFSyntax#fileExtension()}, otherwise
      *         {@link Optional#empty()} indicating that no matching file
      *         extension was found.
-     * @see #fileExtensions()
      */
     static Optional<RDFSyntax> byFileExtension(final String fileExtension) {
         final String ext = fileExtension.toLowerCase(Locale.ROOT);
