Java의 추상 클래스 및 인터페이스를 완전히 마스터하세요.-java지도 시간-php.cn

이 글에서는 추상 클래스란 무엇인지, 추상 클래스 구현 다형성의 의미 등 추상 클래스와 인터페이스에 관련된 이슈를 주로 소개하는 java에 대한 관련 지식을 소개합니다. 모든 사람에게 도움이 되기를 바랍니다.

Java의 추상 클래스 및 인터페이스를 완전히 마스터하세요.

추상 클래스란 무엇입니까

앞서 클래스가 무엇인지 배웠으니 추상 클래스도 클래스의 일종인가요?

이름이 너무 추상적으로 들리네요! 맞습니다. 구체적이지 않고 추상적입니다. 특정 객체를 설명하기에 충분한 정보를 포함하지 않는 클래스를 추상 클래스라고 합니다.

추상 클래스의 예를 살펴보겠습니다

// 抽象类和抽象方法需要被 abstract 关键字修饰
abstract class Shape {
    // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体
    abstract void draw();
}

로그인 후 복사

모든 사람들은 이 추상 클래스가 아무 것도 하지 않고 유일한 메서드 draw()가 여전히 비어 있다고 생각합니다.

이러한 클래스에는 특정 개체를 설명하는 데 충분한 정보가 포함되어 있지 않습니까? 당연히 개체를 인스턴스화할 수 없습니다. 내 말을 믿을 수 없다면 다음을 살펴보십시오.

클래스는 인스턴스화할 수 없으므로 이 추상 클래스의 존재 의미는 무엇입니까?

다형성 구현에 있어 추상 클래스의 중요성

추상 클래스 존재의 가장 큰 의미 중 하나는 상속받을 때 추상 클래스를 사용하여 다형성을 구현할 수 있다는 것입니다.

코드를 살펴보겠습니다

// 抽象类和抽象方法需要被 abstract 关键字修饰
abstract class Shape {
    // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体
    abstract void draw();
}
// 当一个普通类继承一个抽象类后，这个普通类必须重写抽象类中的方法
class Cycle extends Shape {
    @Override
    void draw() {  // 重写抽象类中的draw方法
        System.out.println("画一个圆圈");
    }
}

public class Test4 {
    public static void main(String[] args) {
        //Shape shape = new Shape();  抽象类虽然不能直接实例化
        // 但可以把一个普通类对象传给一个抽象类的引用呀，即父类引用指向子类对象
        Shape shape = new Cycle(); // 这称作：向上转型
        
        /*Cycle cycle = new Cycle();
          Shape shape = cycle // 这是向上转型的另一种写法
         */
        shape.draw();         // 通过父类引用调用被子类重写的方法
    }
}

로그인 후 복사

실행하고 나면 마법 같은 장면을 발견할 수 있습니다:

코드를 읽은 후 많은 질문이 있을 수 있습니다. 걱정하지 마세요. 하나씩

상위 변환이란 무엇입니까? 한 문장에서 "상위 클래스 참조는 하위 클래스 객체를 가리킵니다"

상향 변환 후 변경 사항

방법 정보: 상위 클래스 참조는하위 클래스와 상위 클래스에 공통된 메서드를 호출할 수 있습니다( 하위 클래스가 상위 클래스의 메서드를 재정의하면 하위 클래스의 메서드가 호출됩니다). 그러나 하위 클래스에 고유한 메서드는 호출할 수 없습니다. .
속성 정보: 상위 클래스 참조는 상위 클래스의 속성을 호출할 수 있지만 하위 클래스의 속성은 호출할 수 없습니다.

상향 변환의 역할

일부 반복 코드 줄이기
객체 인스턴스를 인스턴스화할 때 서로 다른 필요에 따라 서로 다른 객체를 인스턴스화할 수 있습니다

이렇게 하면 위 코드를 이해할 수 있습니다

추상 클래스를 하위 클래스를 통해 상속하고 재사용할 수 있는 것 같습니다. 쓰기, 추상 수업 정말 유익해요!

그러나 이것이 다형성과 무슨 관련이 있습니까? 추상 클래스는 사용하기가 너무 까다롭습니다. 하위 클래스를 작성하지 않고도 동일한 효과를 얻으려면 그냥 일반 클래스를 사용하는 것이 좋을까요?

그 줄, 아래 코드를 보면 다형성 구현에 있어 추상 클래스의 이점을 알 수 있습니다.

abstract class Shape {
    public abstract void draw(); // 抽象方法不能里有具体的语句
}
// 当一个普通类继承一个抽象类的时候，再这个子类中必须重写抽象类中的抽象方法
class Cycle extends Shape {  
    @Override              // 如果不重写会报错，但如果继承的是普通类则不会报错，用抽象类更安全
    public void draw() {
        System.out.println("画一个圆圈");
    }
}
class Flower extends Shape { // 不同的子类对父类的draw方法进行了不同的重写
    @Override
    public void draw() {
        System.out.println("画一朵花");
    }
}
class Square extends Shape {
    @Override
    public void draw() {
        System.out.println("画一个正方形");
    }
}

public class Test4 {
    public static void main(String[] args) {
        Cycle cycle = new Cycle();   // 子类引用cycle
        Flower flower = new Flower(); // 子类引用flower
        Square square = new Square();
        
        // 数组的类型是Shape,即数组中每一个元素都是一个父类引用
        // 在这个过程其实也发生了向上转型，对抽象类中的方法进行了重写
        Shape[] shapes = {cycle, flower, square};  // 父类引用引用不同的子类对象
        for (int i = 0; i < shapes.length; i++) {
            Shape shape = shapes[i]; // 父类引用shape指向—>当前所对应的子类对象

            shape.draw();  // 通过父类引用调用子类重写的draw方法
        }

    }
}

로그인 후 복사

동일한 메서드를 호출하면 실제로 다른 결과가 출력됩니다. 이것이 소위 다형성인가요? 상태 측면에서 보면 다음 세 가지 요소가 있습니다.

상속(방금 상속한 Cycle 클래스) Shape 추상 클래스)

Rewriting(서브클래스의 draw 메소드 재작성)

Parent 클래스 서브클래스 객체를 가리킵니다(즉, Shape1[0] = 사이클 --> 상향 변환이라고도 함) )
우리 코드를 다시 살펴보고 다형성의 세 가지 요소를 충족하는지 확인하세요.
부모 클래스 참조가 다른 하위 클래스 객체를 가리키는 경우 동일한 그리기 메서드를 호출하면 다른 결과가 출력됩니다. (실제로 이 메소드는 서브클래스에서 다른 형태로 다시 작성됩니다.) 이를 다형성이라고 합니다.

헤헤 사실 예제와 함께 보면 다형성은 그리 어렵지는 않네요

그럼 왜 추상클래스를 써야하나요? 일반 클래스에서 다형성을 구현하기 위해 일반 클래스를 상속받는 것은 불가능한 일일까요

물론 가능하지만 안전하지도 위험하지도 않습니다

但如果是抽象类的话，就不一样了

从这我们也可以看出，当用抽象类的时候，编译器自动就对我们是否重写进行了校验，而充分利用编译器的校验, 在实际开发中是非常有意义的。所以说抽象类还是有用的

好了，相信到这里你对抽象类也有了一个大概的认识，下面来简单做一下总结

使用abstract修饰的类或方法，就抽象类或者抽象方法
抽象类是不能具体的描述一个对象，不能用抽象类直接实例化对象
抽象类里面的成员变量和成员方法，都是和普通类一样的，只不过就是不能进行实例化了
当一个普通类继承这个抽象类后，那么这个普通类必须重写抽象类当中的所有的抽象方法（我们之前说过抽象类是不具体的，没有包含足够的信息来描述一个对象，所以我们需要把他补充完整）
但当一个抽象类A继承了抽象类B，这是抽象类A就可以不重写抽象类B当中的抽象方法
final不能修饰抽象类和抽象方法（因为抽象类存在的最大意义就是被继承，而被final修饰的不能被继承，final和抽象，他们两个是天敌）
抽象方法不能被private修饰（抽象方法一般都是要被重写的，你被private修饰了，还怎么重写）
抽象类当中不一定有抽象方法，但如果一个类中有抽象方法，那么这个类一定是抽象类。

接口是什么

抽象类是从多个类中抽象出来的模板，如果将这种抽象进行的更彻底，则可以提炼出一种更加特殊的“抽象类”——接口（Interface）。

接口是Java中最重要的概念之一，它可以被理解为一种特殊的类，不同的是接口的成员没有执行体，是由全局常量和公共的抽象方法所组成。

如何定义一个接口呢？下面我们来看一个栗子

//接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口

public interface 接口名称{
// 定义变量
int a = 10;      // 接口当中的成员变量默认都是public static final

// 抽象方法
public abstract void method1(); // public abstract 是固定搭配，可以不写
void method2();  //  接口当中的成员方法默认都是public abstract, 更推荐用第二种来定义方法 
}

로그인 후 복사

可以看到接口和类其实还是有很多相似点：

接口中也包含抽象方法，所以也不能直接实例化接口，那么我们怎么用接口呢？

哈哈，很简单，我们再用一个普通类实现这个接口不就行了吗，不同的是抽象类是被子类来继承而实现的，而接口与类之间则是用关键字implements来实现。

就像普通类实现实现抽象类一样，一个类实现某个接口则必须实现该接口中的抽象方法，否则该类必须被定义为抽象类。

通过接口实现多态

铁汁们！刚才我们是用抽象类来实现多态，那么现在我们可以尝试用接口来实现多态，

接口可以看成是一种特殊的类，只能用 interface 关键字修饰
interface IShape {
    int a = 10;   接口当中的成员变量默认都是public static final
    int b = 23;
    void draw();  接口当中的成员方法一般只能是抽象方法，默认是public abstract（JDK1.8以前）
  
    default void show() {
        System.out.println("接口中的其他方法");//接口中的其他方法也可以实现，但要用default修饰
    }
    public static void test() {
        System.out.println("这是接口当中的一个静态的方法");
    }
}

// 一个普通的类要想实现接口，可以用implement, 
//因为接口也是抽象方法的，所以实现接口的这个类也要重写抽象方法
class Cycle implements IShape {

    @Override
    public void draw() {
        System.out.println("画一个圆圈");
    }
}
class Square implements IShape {
    @Override
    public void draw() {
        System.out.println("画一个正方形");
    }
}
class Flower implements IShape {

    @Override
    public void draw() {
        System.out.println("画一朵花");
    }
}
public class Test4 {
    public static void main(String[] args) {
        // IShape iShape = new IShape(); 接口也不能直接实例化
        Cycle cycle = new Cycle();
        Square square = new Square();
        Flower flower = new Flower();
        // 这里的IShape接口就相当与抽象类中父类，接口类型也是一种引用类型

        IShape[] iShapes = {cycle, square, flower}; // 这个过程其实就发生了向上转型

        for (IShape iShape : iShapes) { // 增强型的for—each循环，也可以写成普通的for循环形式
            iShape.draw();              // 通过重写实现了多态
        }
    }
}
引用变量cycle和square都赋值给了Shape类型的引用变量shape,
但当执行shape.draw()时，java虚拟机到底要调用谁重写的的draw方法，
就看此时接口引用的是那个对象的，是shape的、还是cycle的

로그인 후 복사

看一下运行结果

看完代码你可能有点晕，但没关系。一般接口咱也不这么用，直接使用抽象类不就好了（我只是演示一下用接口也能实现多态）

下面我们来总结一下Java中接口的几个主要特点

接口中可以包含变量和方法，变量被隐式指定为 public static final，方法被隐式指定为 public abstract（JDK 1.8 d一个类可以同时实现多个接口，一个类实现某个接口则必须实现该接口中的抽象方法，否则该类必须被定义为抽象类
接口支持多继承，即一个接口可以继承（extends）多个接口，间接解决了 Java 中类不能多继承的问题。

那么接口一般用在什么地方呢？

一般情况下，实现类和它的抽象类之前具有 "is-a" 的关系，但是如果我们想达到同样的目的，但是又不存在这种关系时，使用接口。
由于 Java 中单继承的特性，导致一个类只能继承一个类，但是可以实现一个或多个接口，此时可以使用接口。

下面就让我们来看看接口的正确用法：帮助java实现“ 多继承 ”

由于 Java 中单继承的特性，导致一个类只能继承一个类，但是可以实现一个或多个接口，此时可以使用接口。
class Animal {
    String name;        // 不能使用private,后面的子类也要用

    public Animal(String name) { // 父类的自定义的构造方法
        this.name = name;
    }
}
interface IFlying {   // 自定义多种接口
    void fly();
}
interface IRunning {
    void run();
}
interface ISwimming {
    void swimming();
}
// 小鸭子，不仅会跑，还会游泳、飞行
一个类继承父类，并实现多个接口，间接的解决java中不能多继承的问题
class Duck extends Animal implements IRunning, ISwimming, IFlying {

    public Duck(String name) {  // 子类构造方法
        super(name);            // 必须在子类构造方法的第一行
        // 在给实现子类的构造方法前，先要用super()调用实现父类的构造方法，比较先有父后有子呀！
        // 因为父类自己定义了构造方法，编译器不会自动给给子类构造方法中添加super();来实现父类的构造方法，需要我们自己实现
    }
    // 对接口中的抽象方法进行重写
    @Override
    public void fly() {
        System.out.println(this.name + "正在用翅膀飞");
    }

    @Override
    public void run() {
        System.out.println(this.name + "正在用两条腿跑");
    }

    @Override
    public void swimming() {
        System.out.println(this.name + "正在漂在水上");
    }

}

public class 接口的使用 {  // 不用学我用中文名作为类名，我只是为演示方便
    public static void main(String[] args) {
        Duck duck = new Duck("第一个小鸭子");  // 实例化鸭子对象
        duck.fly();  // 通过引用 变量名.方法名 输出重写后的方法
        duck.run();
        duck.swimming();
    }
}
有人可能会说干嘛用接口，我直接在父类Animal中实现fly、run、swimming这些属性，
然后不同的动物子类再继承父类这些方法不行吗？

但问题是，鸭子会fly、swimming，那猫会飞和游泳吗？你再写个其他动物的子类是不是就不行了
而用接口呢？我们只是把这种飞、游泳的行为给抽象出来了，

只要一个子类有这种行为，他就可以实现相对应的接口，接口是更加灵活的

로그인 후 복사

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多个接口。

继承表达的含义是 is - a 语义, 而接口表达的含义是具有 xxx 特性，能实现接口的类和该接口并不一定有is_a的关系，只要该类有这个接口的特性就行

猫是一种动物, 具有会跑的特性.

青蛙也是一种动物, 既能跑, 也能游泳

鸭子也是一种动物, 既能跑, 也能游, 还能飞

这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型，只要这个类有有这个特性就好。

举个栗子

class Robot implements IRunning {
    private String name;
    public Robot(String name) {
        this.name = name;
    }
    // 对run方法进行重写
    @Override
    public void run() {
        System.out.println("机器人" + this.name + "正在跑");
    }
}
public class Test4 {
    public static void main(String[] args) {
        Robot robot1 = new Robot("图图");
        robot1.run();
    }
}
// 执行结果
机器人图图正在跑

로그인 후 복사

只要能跑就行，管他是机器人还是动物呢

推荐学习：《java视频教程》

위 내용은 Java의 추상 클래스 및 인터페이스를 완전히 마스터하세요.의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!