Read the source-jdk8-FunctionalInterface annotation

package java.lang;

import java.lang.annotation.*;

/**
 * An informative annotation type used to indicate that an interface
 * type declaration is intended to be a <i>functional interface</i> as
 * defined by the Java Language Specification.
 *
 * Conceptually, a functional interface has exactly one abstract
 * method.  Since {@linkplain java.lang.reflect.Method#isDefault()
 * default methods} have an implementation, they are not abstract.  If
 * an interface declares an abstract method overriding one of the
 * public methods of {@code java.lang.Object}, that also does
 * <em>not</em> count toward the interface's abstract method count
 * since any implementation of the interface will have an
 * implementation from {@code java.lang.Object} or elsewhere.
 *
 * <p>Note that instances of functional interfaces can be created with
 * lambda expressions, method references, or constructor references.
 *
 * <p>If a type is annotated with this annotation type, compilers are
 * required to generate an error message unless:
 *
 * <ul> * <li> The type is an interface type and not an annotation type, enum, or class.
 * <li>
 The annotated type satisfies the requirements of a functional interface.
 * </ul> *
 * <p>However, the compiler will treat any interface meeting the
 * definition of a functional interface as a functional interface
 * regardless of whether or not a {@code FunctionalInterface}
 * annotation is present on the interface declaration.
 *
 * @jls 4.3.2. The Class Object
 * @jls 9.8 Functional Interfaces
 * @jls 9.4.3 Interface Method Body
 * @since 1.8
 */
@Documented
@Retention
(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}

 

 Conceptually, a functional interface has exactly one abstract method.

 Since default methods have an implementation, they are not abstract.

 If an interface declares an abstract method overriding one of the public methods of java.lang.Object, that also does not count toward the interface's abstract method count since any implementation of the interface will have an implementation from java.lang.Object or elsewhere.

 

After the salvage points, there are three points:

1. a functional interface has exactly one abstract method.

An interface to declare FunctionalInterface can only have 1 abstract method;

2. Since default methods have an implementation, they are not abstract.

Because the default method is implemented, it is not an abstract method, so it is not listed;

3. If an interface declares an abstract method overriding one of the public methods of java.lang.Object, that also does not count toward the interface's abstract method count since any implementation of the interface will have an implementation from java.lang.Object or elsewhere.

Because there can only be one abstract method , if my interface declares an abstract method "String toString();" or "boolean equals(Object obj);", does it count? ---> The answer is: Do not count this, because any object that implements the interface will inherit Object, so the methods of these public Objects are not included in the list.

That is, your interface can be declared as follows:

 

 

/**
 * Created by niewj on 2017/10/26.
 */
@FunctionalInterface
public interface FunctionalInterfaceSummary {

	int doSum(int x, int y); // abstract method

	String toString(); // Amount that does not account for 1

	boolean equals(Object obj); // does not account for the amount of 1
	// boolean equals(); // this will account for the amount of 1, because this is not a method in Object

	default void display() {
		System.out.println("show sth..");
	}
}

 

summary:

1. If only one abstract method is limited in an interface, it can be limited with the annotation @FunctionalInterface;

2. After declaring as a functional interface, it has the following characteristics:

    a. There is only one abstract method;

    b. The public methods in the Object class are also written in the interface, or they can, because this does not count;

    c. default methods do not count, because they are implementations. Not abstract!