Java 추상 정의 분석 예

1. 개요

OOP의 개념에서는 모든 객체가 클래스를 통해 설명되지만 모든 클래스가 객체를 설명하는 데 사용되는 것은 아닙니다. 클래스에 구체적인 객체를 설명하기에 충분한 정보가 포함되어 있지 않은 경우 이러한 클래스를 추상 클래스라고 합니다.

추상 클래스: (1) 추상 클래스는 객체를 인스턴스화할 수 없습니다. 객체가 인스턴스화되면 컴파일이 통과되지 않습니다. 추상 클래스의 비추상 서브클래스만이 멤버 변수, 멤버 메소드, 생성자 등을 포함할 수 있는 객체(2)를 생성할 수 있습니다. (3) 생성자와 클래스 메서드(정적으로 수정된 메서드)는 추상 메서드로 선언할 수 없습니다.

추상 메서드: (1) 클래스에 추상 메서드가 포함되어 있으면 클래스는 추상 클래스여야 합니다. (2) 모든 하위 클래스는 쓰기를 반복해야 합니다. 상위 클래스의 추상 메서드를 사용하거나 자신을 추상 클래스로 선언합니다

정의: 추상 클래스 클래스 이름

2. 예: 농부는 동물에게 먹이를 줍니다

동물: 추상 클래스-------getName(), move( ), drink()

Reptile, Mammal: 추상 클래스 상속

Snake, Tiger, Goat, Rabbit: Reptile 또는 Mammal 각각 상속

fammer: BringWater(), FeedWater(동물)---- 담당 물을 가져오기 위해 지정된 장소로 이동한 후, 동물은 목적지로 이동하여 물을 마십니다

코드는 다음과 같습니다.

package abstractDemo;
 
/**
 * @author lpx
 * @Description TODO
 * @date 2021-04-07
 */
public abstract class Animal {
    abstract String getName();
    abstract void move(String destination);
    abstract void drink();
}
abstract class Reptile extends Animal{
 
}
 
abstract class Mammal extends Animal{
 
}
 
class Tiger extends Mammal{
    private static String name="tiger";
 
    @Override
    String getName() {
        return this.name;
    }
 
    @Override
    void move(String destination) {
        System.out.println("tiger move to "+destination+".");
    }
 
    @Override
    void drink() {
        System.out.println("tiger lower it is head and drink");
    }
}
 
class Goat extends Mammal{
    private static String name="goat";
 
    @Override
    String getName() {
        return this.name;
    }
 
    @Override
    void move(String destination) {
        System.out.println("goat move to "+destination+".");
    }
 
    @Override
    void drink() {
        System.out.println("goat lower it head to drink");
    }
}
 
class Rabbit extends Mammal{
    private static String name="rabbit";
 
    @Override
    String getName() {
        return this.name;
    }
 
    @Override
    void move(String destination) {
        System.out.println("rabbit move to "+destination+".");
    }
 
    @Override
    void drink() {
        System.out.println("rabbit put out it is tongue and drink");
    }
}
 
class Snake extends Reptile{
    private static String name="snake";
 
    @Override
    String getName() {
        return this.name;
    }
 
    @Override
    void move(String destination) {
        System.out.println("snake move to "+destination+".");
    }
 
    @Override
    void drink() {
        System.out.println("snake dived into and drink");
    }
}
 
class Farmer{
    public void bringWater(String destination){
        System.out.println("Farmer bring water to " + destination + ".");
    }
 
    public void feedWater(Animal a){ // polymorphism
        this.bringWater("Feeding Room");
        a.move("Feeding Room");
        a.drink();
    }
 
}
 
class Test{
    public static void main(String[] args) {
        Farmer fm=new Farmer();
        Snake snake=new Snake();
        Goat goat=new Goat();
        Tiger tiger=new Tiger();
        Rabbit rabbit=new Rabbit();
 
        fm.feedWater(snake);
        fm.feedWater(goat);
        fm.feedWater(tiger);
        fm.feedWater(rabbit);
    }
}

실행 결과:

요약:

각 동물이 한다면 음료 및 이동 방법을 추상화하지 않으면 다형성을 달성할 수 없습니다. 농부 클래스는 다양한 매개변수에 따라 여러 FeedWater를 오버로드해야 합니다. 계속해서 동물을 추가하면 재장전 횟수가 늘어납니다. 비교와 이해를 돕기 위해 코드도 다음과 같습니다.

package abstractDemo;
 
/**
 * @author lpx
 * @Description TODO
 * @date 2021-04-07
 */
 
class Tiger1{
    private static String name="tiger";
 
    String getName() {
        return this.name;
    }
 
    void move(String destination) {
        System.out.println("tiger move to "+destination+".");
    }
 
    void drink() {
        System.out.println("tiger lower it is head and drink");
    }
}
 
class Goat1{
    private static String name="goat";
 
    String getName() {
        return this.name;
    }
 
    void move(String destination) {
        System.out.println("goat move to "+destination+".");
    }
 
    void drink() {
        System.out.println("goat lower it head to drink");
    }
}
 
class Rabbit1{
    private static String name="rabbit";
 
    String getName() {
        return this.name;
    }
 
    void move(String destination) {
        System.out.println("rabbit move to "+destination+".");
    }
 
    void drink() {
        System.out.println("rabbit put out it is tongue and drink");
    }
}
 
class Farmer1{
    public void bringWater(String destination){
        System.out.println("Farmer bring water to " + destination + ".");
    }
 
    public void feedWater(Goat1 goat){ // polymorphism
        this.bringWater("Feeding Room");
        goat.move("Feeding Room");
        goat.drink();
    }
    public void feedWater(Tiger1 tiger){ // polymorphism
        this.bringWater("Feeding Room");
        tiger.move("Feeding Room");
        tiger.drink();
    }
 
    public void feedWater(Rabbit1 rabbit1) {
        this.bringWater("Feeding Room");
        rabbit1.move("Feeding Room");
        rabbit1.drink();
    }
}
 
public class Test1{
    public static void main(String[] args) {
        Farmer1 farmer1=new Farmer1();
        Tiger1 tiger1=new Tiger1();
        Goat1 goat1=new Goat1();
        Rabbit1 rabbit1=new Rabbit1();
        farmer1.feedWater(tiger1);
        farmer1.feedWater(goat1);
        farmer1.feedWater(rabbit1);
    }
}

이 예제를 직접 입력했는데 예전에는 기본이 매우 중요하다는 것을 깨달았습니다. , 그래서 여러 곳에서 혼란을 야기했는데 왜 그렇게 썼는지 모르겠습니다.

(1) .java 파일에는 여러 클래스를 정의할 수 있지만, 하나만 공개로 정의할 수 있으며 클래스 이름은 파일 이름과 동일해야 합니다.

(2) 추상 클래스는 해당 클래스를 재정의하지 않고 추상 클래스를 상속합니다. 추상 메서드(이유도 매우 간단합니다. 추상적이고 메서드 본문을 구현할 수 없습니다.) 비추상 클래스는 추상 클래스를 상속하지만 추상 메서드를 재정의해야 하며 비추상 메서드는 필요하지 않습니다.

(3) 재작성과 오버로딩의 차이점(고주파 인터뷰 질문?)

오버로딩: 메소드 이름은 동일하지만 매개변수가 다릅니다. 이는 컴파일 시간 다형성

Rewriting에 속합니다. 하위 클래스는 상위 클래스의 @Override 메서드를 재정의합니다. 런타임 다형성에 속합니다

위 내용은 Java 추상 정의 분석 예의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!