I'm a beginner, but I wrote it for personal study
An interface does not provide concrete processing like a class, but is explicitly stated to define ** rules **, and the actual processing is defined by the class that implements the interface. As a result, in the field of a company where multiple people create a program, by defining the method that you want the child class to implement in the parent abstract class as an abstract method, even the child class created by other people can be used. There is an advantage that the method is always implemented
** * Abstract method ** ・ ・ ・ Method that defines only name / type / argument
** * "Type" ** ... itself ** "How to decide how to handle" **, and when declaring a variable, the type is specified in order to decide how to handle the variable.
-It should be noted that ** the type of the object to be handled and the "type of the thing to be handled" specified by the type are different concepts **. For example, the type and handling method are different so that you can change whether the number 1 is handled as an int type or a double type.
-The interface is ** automatically made public ** by the compiler because all specified methods are interpreted as public so that they can be handled by other classes. -Methods defined in the interface cannot be qualified with protected or private (from Java8, the contents can also be defined by adding the default modifier). -As you can see from using implements when a class inherits an interface, it only works if there is a ** "class that implements the specification" **.
** Since the interface only specifies how to handle **, ** cannot have an implementation , so create an instance and ** describe something that operates dynamically (thing that changes dynamically) Can not However, it can be described if either of the following two conditions is met.
-Use ** final ** and the value should not be changed dynamically (constant) -Cannot create an instance using ** static **
-Inheritance can define a new class that extends the class function as you can see from using extends, but you can also define (inherit) a new interface that extends a certain interface with extends. -** Multiple inheritance of classes is prohibited, but multiple realization of interfaces is allowed **
· Can have both ** concrete methods ** with implementations and ** abstract methods ** without implementations -The concrete method defined in the abstract class is inherited by the subclass that inherits the abstract class. -** Abstract methods must be overridden and reimplemented in their subclasses **
-Abstract classes with interface characteristics (abstract methods) cannot be instantiated like interfaces ** -As you can see from the fact that it cannot be instantiated, it is a prerequisite that it is inherited and used **. -The abstract method defined in the abstract class must be implemented by a concrete class that inherits it ** -Abstract classes that inherit from abstract classes do not necessarily have to be implemented like concrete classes, but can be implemented by extending the original abstract class, adding new abstract methods, or overriding existing abstract methods. it can.
-The instance of the subclass that inherits the abstract class includes the instance of the abstract class. In other words, an instance of a subclass that inherits an abstract class contains an instance of the abstract class, and an interface that provides only types can only have constant fields, but an abstract class can define fields whose values can be changed dynamically.
-** Override ** is to ** redefine ** the method defined in the superclass in the subclass. ・ Be careful not to mistake it for ** overload **, which represents ** overload **.
① To redefine the method, the ** signatures of the methods must be the same ** ** Signature **: A combination of method name, argument list type, number, and order ② ** The return value is the same or it is a subclass ** ③ ** Access modifiers can be looser than the original definition, but cannot be strict ** -The following example can be overridden because Integer type is a subclass of Number type.
Sample.java
public Number method{
//any code
}
Sample.java
public Integer method{
//any code
}
-Because the override is not an overwrite but an add (redefinition), there are multiple methods with the same name in the subclass instance. In this case, the overridden method is used
Recommended Posts