ืืืฉืจ ืืฉ ืืืืืจืื ืขื ืคืจืืืืืช ื-Java OOP ืฉื ืืจืืฉื, ืื ืืืจื ืืื ืืชืืืื ืื ืืืจืืืช ืืืชืช ืื ืขื ืืืจืฉ, ืืืชืช ืืื. ืืืื ืืืฉืจ ืืชื ื ืชืงื ืืืืืช ืืืคืชื Java implements, ืื ืืืืจ ืฉืื ื ืขืืืจืื ืืจืื ืืืจืช ืฉื ืืคืฉืื ืืืชืืืืื ืืขืืื ืขื ืืืฉืงืื ื-Java. ืื ืื ื ืืืืืื ืืืืจ ืขื ืื ืื ืืืฉืงืื, ืืฉืืื ืื ืื ืืืืขืืื, ืืื ืืืืฉืื ืงืืจื.
ืืื ืืืฉืง ืืืืฉืื
ืืื ืฉืืขืชื ืืช ืืืืื "ืืืฉืง" ืคืขืืื ืจืืืช. ืืืืืื, ืืืืฉื ืืฉ ืืืฉืง ืงืื (ืขืืืจ ืืืงืืืช), ืืชืืื ืืืช ืจืืืช ืืฉ ืืืฉืงื ืืฉืชืืฉ. ืืืืื ืืจืื, ืืืฉืง ืืื ืงืืฉืืจ ืืื ืฉื ื ืฆืืืื ืืืงืืืืื ืืื ืืจืืงืฆืื. ืืืืืื, ืืืชื ืืงืืืช ืื ืฉืื ืจืืืง ืืืืืืืืื. ืืชืื ืืช, ืืื'ืืืื ืืคืจื, ืืืฉืง ืืื ืืืื ืกืคืฆืืคื ืฉืืืืจ ืื ืชืขืฉื ืืืืืงื ืฉืชืืืืข ืืืชื. ืืืฉืง ืจืง ืืืืืจ ืืชื ืืืืช. ืื ืื ืืืืจ ืืืื ืขื ืืืืืืืงื ืฉืืืืืข ืืช ืื. ืืชื ืืืื ืืืืจืื ืขื ืืืฉืง ื-Java ืื:public interface MyInterface {
// constants declaration
// methods without implementation
// static methods
// default methods (default)
// private methods
}
ืืืื ืชืืืืจ ืฉื Implements ื-Java:
public class MyClass implements MyInterface{
//implementing the methods of MyInterface
//Other code
}
ืืืฉืง ืืชืืจ ืืชื ืืืืช ืืืื ืืฆืืื ืืืช. ืืืฉื, ืืชื ืืืืช ืืื "ืชื ืืขื" ืืืืื ืืืืืช ืืืืฉืืช ืขื ืกืืืื ืฉืื ืื ืฉื ืืคืฆืื: ืืืคื ืืื, ืืื, ืืืื ืืช, ืืื ืื ืืจ ืืืืืื. ืืชื ืืืืช ืืฉืืืื ืืืืื ืืืืืช ืืชื ืืืืช ืฉื ืืจืืื, ืกืคืื ื ืื ืื. ืืืคืฆืื ืืืื ืืื ืฉืื ืืืจ ืืืฉืืชืฃ ืืืื ืืขืืืื ืฉืื ืืืืืื ืื ืืข ืื ืืฉืืืช. ืื, ืืขืฆื ืืชื ืืขื ืืฉืืืื ืื ืฉืื ืื ืืืื. ืขื ืืืช, ื-Java ืืชื ืืืื ืืืฆืืจ ืฉืืขืืจื ืืจืืื , ืกืืจื , ืืืื ืืืชืช ืืื ืืืืฉื ืืช ืืืืืืช ืืฉืืืช. ืืื ื ืขืฉื ืฉืืืืฉ ืืืืืช ืืืคืชื Java Implements .
ืืืฉื ืืืืื ืืืืืช ืืคืชื
public interface Swimmable {
void moveForward();
void TurnRight();
void TurnLeft();
}
ืืคื ืฉืืชื ืืืื ืืจืืืช, ืืฉืืืืช ืขืฆืื ืืื ื ืืืืฉืืืช. ืืื ืืืจืื ื ืฉืืฉืืขืืจืื ืฉืืืืฉืืื ืืช ืืืืฉืง ืืื ืืืืืื ืืืืืช ืืกืืืืื ืืฉืืืช ืืงื ืืฉืจ, ืืื ืื ืืคื ืืช ืืืื ื ืืฉืืืื. ืืืื ื ืืฆืืจ ืืืืงืืช ืฉืืืืืขื ืืช ืืืืฉืง ืืื.
public class Duck implements Swimmable {
//implementing the methods
public void moveForward() {
System.out.println(" Quack, I am moving forward...");
}
public void TurnRight(){
System.out.println("I am turning right...");
}
public void TurnLeft(){
System.out.println("I am turning left...");
}
public void Stop() {
System.out.println("Quack. I am relaxing on the surface of the water...");
}
}
public class Fish implements Swimmable {
public void moveForward() {
System.out.println("I am moving forward...");
}
public void TurnRight(){
System.out.println("I am turning right...");
}
public void TurnLeft() {
System.out.println("I am turning left...");
}
public void turnUp(){
System.out.println("I am turning up...");
}
public void turnDown(){
System.out.println("I am turning down...");
}
public void Stop() {
System.out.println("I am relaxing somewhere under the water surface...");
}
}
ืื ืืืืืงืืช ืฉืืืืฉืืืช ืืช ืืืฉืง Swimmable , ืขื ืคื ืืืืื, ืืืืืืช ืืืืืช ืืกืืืืืช ืืฉืืืช ืงืืืื (ืืืืฉื ืืช ืฉืืืช moveForward() ), ืืื ืืคื ืืช ืืืื ื ืืฉืืืื. ื ืืจืฉ ืืืฉืื ืฉื ืฉืืืืช ืืื. ืืจืืื ืืื ืฉืืืื ืืืจืช. ื ื ืื ืฉืืื ืืฉ ืฉืชื ืฉืืืืช ื ืืกืคืืช ืืืืืฉืืืช ืืช ืืืืืชื ืืฉืืืช ืืืขืื ืืืืื. ืืืืฉืง ืื ืืชื ืืฉืืืื ืืื ืืช ืื. ืขื ืืืช, ืื ื ืืฆืืจ ืืื ืืืืชืช ืืืืื, ืืืฉื, ืืื ื ืื ืกืืืื, ืื, ืืื ืื "ืื", ืืืืื ืืฉืืืช ืืขืื ืืืื.
ืืืฉืงืื ืืจืืืื ื-Java
ืืคื ืฉืืชื ืืืื ืืืจ ืืืืข, ื'ืืืื ืืื ื ืชืืืืช ืืืืจืฉื ืืจืืื. ืื ืืืืจ ืฉืืคืฉืจ ืืืืจืืฉ ืืืืงื ืืืช ืืืขืื-ืขื ืืื ืืืื. ืขื ืืืช, ืืืืคื ืืกืืื ืืชื ืขืืืื ืืืื ืืืฉืชืืฉ ื"ืืจืืฉื ืืจืืื" ื-Java, ืืืืืื ืฉืืืชื ืืืืื ืืืืฉื ืืืฉืงืื ืืจืืืื.To implement multiple interfaces, use the next syntax:
interface MyFirstInterface {
public void myMethod();
}
interface MySecondInterface {
public void myOtherMethod();
}
// MyClass implements both MyFirstInterface and MySecondInterface
class MyClass implements MyFirstInterface, MySecondInterface {
public void myMethod() {
//method implementation
}
public void myOtherMethod() {
//method implementation
}
}
ืืืืื ืืืืฉืงืื ืืจืืืื
ืืืืจ ืื ืืจืืื ืืืื ืื ืจืง ืืฉืืืช, ืืื ืื ืืขืืฃ. ืืืื ื ืืชืื ืืช ืืืฉืง ืืืืกื ืื ืืืฉื ืืืชื ืืืจืืื ืฉืื ื.public interface Flyable {
double startAge = 0.1;
void fly();
}
public class Duck implements Swimmable, Flyable {
public void moveForward() {
System.out.println(" Quack, I am moving forward...");
}
public void TurnRight(){
System.out.println("I am turning right...");
}
public void TurnLeft(){
System.out.println("I am turning left...");
}
public void Stop() {
System.out.println("Quack. I am relaxing on the surface of the water...");
}
public void fly(){
System.out.println("I am flying!!!");
}
}
ืืฉืื, ืืฉืื ืืืืืจ ืืืืข ืื ื ืืืชืืื ืืช ืืืืฉืง. ื ื ืื ืฉืื ืื ืืืืฉื ืขื ืืื ืฆืืคืืจ, ืืืืก, ืฆื ืืื ืืืคืฉืืช ืืฉื ืืืจื, ืืืืกืืช ืฉืืื ืืืื ืฉืื ืืช ืืืืืืื.
GO TO FULL VERSION