JAVA

추상 클래스는 인스턴스화 할 수없는 클래스입니다. 추상 클래스는 인스턴스화 할 수 있는 상속 서브 클래스를 작성하여 사용됩니다 . 추상 클래스는 상속 서브 클래스에 대해 몇 가지 작업을 수행합니다.

1. 상속 서브 클래스에서 사용할 수있는 메소드를 정의하십시오.
2. 상속 서브 클래스가 구현해야하는 추상 메소드를 정의하십시오.
3. 서브 클래스를 다른 모든 서브 클래스와 교환 할 수있는 공통 인터페이스를 제공하십시오.

예를 들면 다음과 같습니다.

abstract public class AbstractClass
{
    abstract public void abstractMethod();
    public void implementedMethod() { System.out.print("implementedMethod()"); }
    final public void finalMethod() { System.out.print("finalMethod()"); }
}

“abstractMethod ()”에는 메소드 본문이 없습니다. 이로 인해 다음을 수행 할 수 없습니다.

public class ImplementingClass extends AbstractClass
{
    // ERROR!
}

구현하는 메소드가 없습니다 abstractMethod()! 따라서 JVM이 다음과 같은 것을 얻을 때 수행해야 할 작업을 알 수있는 방법이 없습니다 new ImplementingClass().abstractMethod().

올바른 내용은 다음과 같습니다 ImplementingClass.

public class ImplementingClass extends AbstractClass
{
    public void abstractMethod() { System.out.print("abstractMethod()"); }
}

implementedMethod()또는 을 정의 할 필요는 없습니다 finalMethod(). 이미에 의해 정의되었습니다 AbstractClass.

또 다른 올바른 것이 ImplementingClass있습니다.

public class ImplementingClass extends AbstractClass
{
    public void abstractMethod() { System.out.print("abstractMethod()"); }
    public void implementedMethod() { System.out.print("Overridden!"); }
}

이 경우을 재정의했습니다 implementedMethod().

그러나 final키워드로 인해 다음이 불가능합니다.

public class ImplementingClass extends AbstractClass
{
    public void abstractMethod() { System.out.print("abstractMethod()"); }
    public void implementedMethod() { System.out.print("Overridden!"); }
    public void finalMethod() { System.out.print("ERROR!"); }
}

finalMethod()in AbstractClass구현이 최종 구현으로 표시되어 있기 때문에이 작업을 수행 할 수 없습니다 finalMethod(). 다른 구현은 절대 허용되지 않습니다.

이제 추상 클래스를 두 번 구현할 수도 있습니다 .

public class ImplementingClass extends AbstractClass
{
    public void abstractMethod() { System.out.print("abstractMethod()"); }
    public void implementedMethod() { System.out.print("Overridden!"); }
}

// In a separate file.
public class SecondImplementingClass extends AbstractClass
{
    public void abstractMethod() { System.out.print("second abstractMethod()"); }
}

이제 어딘가에 다른 방법을 쓸 수 있습니다.

public tryItOut()
{
    ImplementingClass a = new ImplementingClass();
    AbstractClass b = new ImplementingClass();

    a.abstractMethod();    // prints "abstractMethod()"
    a.implementedMethod(); // prints "Overridden!"     <-- same
    a.finalMethod();       // prints "finalMethod()"

    b.abstractMethod();    // prints "abstractMethod()"
    b.implementedMethod(); // prints "Overridden!"     <-- same
    b.finalMethod();       // prints "finalMethod()"

    SecondImplementingClass c = new SecondImplementingClass();
    AbstractClass d = new SecondImplementingClass();

    c.abstractMethod();    // prints "second abstractMethod()"
    c.implementedMethod(); // prints "implementedMethod()"
    c.finalMethod();       // prints "finalMethod()"

    d.abstractMethod();    // prints "second abstractMethod()"
    d.implementedMethod(); // prints "implementedMethod()"
    d.finalMethod();       // prints "finalMethod()"
}

우리가 선언에도 불구하고 있음을 공지 유형에서 표시 . 우리가 인스턴스화 된 객체가 실제로이었다 때문입니다 누구는 물론 오버라이드 (override)이다. (이것을 다형성이라고합니다.)bAbstractClass"Overriden!"ImplementingClassimplementedMethod()

특정 하위 클래스에 특정한 멤버에 액세스하려면 먼저 해당 하위 클래스로 캐스트해야합니다.

// Say ImplementingClass also contains uniqueMethod()
// To access it, we use a cast to tell the runtime which type the object is
AbstractClass b = new ImplementingClass();
((ImplementingClass)b).uniqueMethod();

마지막으로 다음을 수행 할 수 없습니다.

public class ImplementingClass extends AbstractClass, SomeOtherAbstractClass
{
    ... // implementation
}

한 번에 하나의 수업 만 연장 할 수 있습니다. 여러 클래스를 확장해야하는 경우 인터페이스 여야합니다. 당신은 이것을 할 수 있습니다 :

public class ImplementingClass extends AbstractClass implements InterfaceA, InterfaceB
{
    ... // implementation
}

인터페이스 예는 다음과 같습니다.

interface InterfaceA
{
    void interfaceMethod();
}

이것은 기본적으로 다음과 같습니다.

abstract public class InterfaceA
{
    abstract public void interfaceMethod();
}

유일한 차이점은 두 번째 방법은 컴파일러가 실제로 인터페이스라는 것을 알리지 않는다는 것입니다. 사람들이 인터페이스 만 구현하고 다른 인터페이스는 구현하지 않으려는 경우에 유용 할 수 있습니다. 그러나 일반적인 초급 규칙으로 추상 클래스에 추상 메소드 만있는 경우 인터페이스로 만들어야합니다.

다음은 불법입니다 :

interface InterfaceB
{
    void interfaceMethod() { System.out.print("ERROR!"); }
}

인터페이스에서 메소드를 구현할 수 없습니다. 이것은 두 개의 다른 인터페이스를 구현하면 해당 인터페이스의 다른 메소드가 충돌 할 수 없음을 의미합니다. 인터페이스의 모든 메소드는 추상이므로 메소드를 구현해야하며 메소드가 상속 트리에서 유일한 구현이므로 컴파일러는 메소드를 사용해야한다는 것을 알고 있습니다.

답변

public abstract void myMethod()

abstract class MyClass

abstract class AbstractDemo{ }

abstract void moveTo();//no body

abstract class GraphicObject {

  void moveTo(int x, int y) {
    // Inside this method we have to change the position of the graphic 
    // object according to x,y     
    // This is the same in every GraphicObject. Then we can implement here. 
  }

  abstract void draw(); // But every GraphicObject drawing case is 
                        // unique, not common. Then we have to create that 
                        // case inside each class. Then create these    
                        // methods as abstract 
  abstract void resize();
}

class Circle extends GraphicObject {
  void draw() {
    //Add to some implementation here
  }
  void resize() {
    //Add to some implementation here   
  }
}
class Rectangle extends GraphicObject {
  void draw() {
    //Add to some implementation here
  }
  void resize() {
    //Add to some implementation here
  }
}

public static void main(String args[]){
   GraphicObject c = new Circle();
   c.draw();
   c.resize();
   c.moveTo(4,5);
}

abstract class GraphicObject {

  GraphicObject (){
    System.out.println("GraphicObject  is created");
  }
  void moveTo(int y, int x) {
       System.out.println("Change position according to "+ x+ " and " + y);
  }
  abstract void draw();
}

class Circle extends GraphicObject {
  void draw() {
    System.out.println("Draw the Circle");
  }
}

class TestAbstract {
 public static void main(String args[]){

   GraphicObject  grObj = new Circle ();
   grObj.draw();
   grObj.moveTo(4,6);
 }
}

GraphicObject  is created
Draw the Circle
Change position according to 6 and 4

public abstract class MyAbstractClass{
  public abstract void DoSomething();
}

public abstract class MyAbstractClass{

  public int CalculateCost(int amount){
     //do some default calculations
     //this can be overriden by subclasses if needed
  }

  //this MUST be implemented by subclasses
  public abstract void DoSomething();
}

abstract void moveTo(double deltaX, double deltaY);

public abstract class GraphicObject {
   // declare fields
   // declare nonabstract methods
   abstract void draw();
}