Java의 추상 클래스 및 인터페이스에 대한 심층적인 이해

모든 사람이 이런 느낌을 갖고 있다고 생각합니다. 추상 클래스와 인터페이스는 유사점이 너무 많고 차이점도 너무 많습니다. 이 두 가지는 종종 초보자를 혼란스럽게 만듭니다. 실제 프로그래밍에서든 인터뷰에서든 추상 클래스와 인터페이스는 특히 중요합니다. 이 글을 읽고 모두가 차분하게 두 가지를 이해할 수 있기를 바랍니다...

내가 이해하는 추상 클래스

1. 추상 클래스와 클래스는 같은 매력이 있습니다

1) 추상 클래스는 클래스와 마찬가지로 상속될 수 있습니다.

2) 추상 클래스는 클래스가 가질 수 있는 모든 구성 요소를 가질 수 있습니다(생성자, 정적 정적 수정 구성 요소 등 포함).

추상 클래스는 이와 같습니다. 이름 정의도 같고 클래스이기도 합니다

2. 추상 메소드

다른 매력을 이야기하기 전에 잘 알아야 합니다

추상 메소드:

1), 추상 메소드에는 없습니다. 메소드 본문

2), 추상 메소드는 abstract 키워드로 수정되어야 합니다.
3), 추상 메소드가 있는 클래스는 추상 클래스여야 합니다. abstract关键字修饰
3）、有抽象方法的类必然是抽象类
4）、抽象方法必须为public或者protected，缺省情况下默认为public

抽象类不一定有抽象方法

3、抽象类和类的异样韵味

1）、抽象类必须用abstract关键字进行修饰，有abstract修饰的类就是抽象类！
2）、抽象类可有可无抽象方法
3）、抽象类虽然有构造方法但不能用来直接创建对象实例
4）、抽象类不能用final、private修饰
5）、外部抽象类不能用Static修饰，但内部的抽象类可以使用static声明。这句话理解代码如下：

//定义一个抽象类A
abstract class A{
   //定义一个内部抽象类B
    static abstract class B{  //static定义的内部类属于外部类
        public abstract void saoMethod();
    }
}

class C extends A.B{

    public void saoMethod(){
        System.out.println("======saoMethod方法执行了======");
    }
}
public class StaticDemo {

    public static void main(String[] args) {
        A.B ab = new C();//向上转型
        ab.saoMethod();
    }

}

运行结果：  ======saoMethod方法执行了======

有的童鞋就看懵逼了， C extends A.B是啥骚操作啊，还能这样玩？是的，当使用static声明的内部抽象类相当于一个外部抽象类，继承的时候使用“外部类.内部类”的形式表示类名称。这种骚操作属实是稳中带皮。

抽象类是一个特殊的类，抽象类和普通类有着本质区别

4、掌握抽象类

抽象类就是为了继承而存在的，定义了一个抽象类，却不去继承它，创建的这个抽象类就毫无意义!

抽象类虽然有构造方法但不能直接被实例化，要创建对象涉及向上转型，主要是用于被其子类调用

还有对于抽象类可以没有抽象方法这句话，这只是一个要记住的重要概念，一定要记住！实际开发中抽象类一般都有抽象方法，不然该抽象类就失去存在意义，和普通类没啥两样！

一个普通类A继承一个抽象类B，则子类A必须实现父类B的所有抽象方法。如果子类A没有实现父类B的抽象方法，则必须将子类A也定义为为abstract类，也就是抽象类。

我所理解的接口

接口（interface）可以说成是抽象类的一种特例，抽象类与接口这两者有太多相似的地方，又有太多不同的地方。相对的，接口更像是一种行为的抽象！

1、接口特性

1）、接口中的方法默认为public abstract类型，接口中的成员变量类型不写默认为public static final。
2）、接口没有构造方法
3）、接口可以实现“多继承”，一个类可以实现多个接口，实现写法格式为直接用逗号隔开即可。

2、接口必知

接口中只能含有public static final变量，不写默认是public static final，用private修饰会编译失败。

接口中所以的方法会被隐式地指定为public abstract方法且只能是public abstract4), 추상 메소드는 public이어야 합니다. 또는 < code>protected, 기본값은 public추상 클래스에 반드시 추상 메서드가 있는 것은 아닙니다

3. 추상 클래스와 클래스의 이상한 매력

🎜 1) 추상 클래스는 abstract 키워드로 수정해야 합니다. abstract로 수정된 클래스는 추상 클래스입니다! 🎜2) 추상 클래스에는 추상 메소드가 있을 수도 있고 없을 수도 있습니다🎜3) 추상 클래스에 생성자가 있더라도 객체 인스턴스를 직접 생성하는 데 사용할 수는 없습니다🎜4) 추상 클래스는 final을 사용할 수 없습니다. code> private 수정🎜5) 외부 추상 클래스는 Static으로 수정할 수 없지만, 내부 추상 클래스는 static으로 선언할 수 있습니다. 이 문장을 이해하기 위한 코드는 다음과 같습니다. 🎜

package InterfaceDemo;

interface AA{   //接口AA
   default void hh(){
       System.out.println("123");
   };
}

class BB implements AA{  //实现接口
    
}

public class InterfaceDesign {

    public static void main(String[] args) {
        AA a=new BB(); //通过实现类创建实例
        a.hh();
    }
}
运行结果： 123

🎜어떤 아이들의 신발은 헷갈리는데요. C 확장 A.B는 어떤 멋진 연산인가요? 네, static을 사용하여 선언한 내부 추상 클래스가 외부 추상 클래스와 동일할 경우 상속 시 클래스 이름은 "external class.internal class" 형식으로 표현됩니다. 이런 멋진 수술은 정말 안전하고 날씬합니다. 🎜🎜🎜추상 클래스는 일반 클래스와 본질적인 차이가 있습니다.🎜🎜🎜🎜4. 추상 클래스는 상속을 위해 존재하지만 상속하지는 않습니다. , 생성된 추상 클래스는 의미가 없습니다!🎜🎜🎜추상 클래스에는 생성자가 있지만 직접 인스턴스화할 수는 없습니다🎜. 객체를 생성하려면 주로 하위 클래스에서 호출하는 데 사용되는 상향 변환이 필요합니다.🎜🎜또한 추상 클래스에는 필요하지 않습니다. 추상 메소드는 꼭 기억해야 할 중요한 개념입니다. 실제 개발에서 추상 클래스에는 일반적으로 추상 메소드가 있습니다. 그렇지 않으면 추상 클래스는 의미를 잃고 일반 클래스와 다르지 않습니다! 🎜🎜일반 클래스 A가 추상 클래스 B를 상속하는 경우 하위 클래스 A는 상위 클래스 B의 모든 추상 메서드를 구현해야 합니다. 하위 클래스 A가 상위 클래스 B의 추상 메서드를 구현하지 않는 경우 하위 클래스 A도 추상 클래스, 즉 추상 클래스로 정의되어야 합니다. 🎜🎜🎜🎜내가 이해하는 인터페이스 🎜🎜🎜🎜인터페이스는 추상 클래스의 특수한 경우라고 할 수 있습니다. 추상 클래스와 인터페이스는 유사점이 너무 많고 차이점도 너무 많습니다. 대조적으로, 인터페이스는 동작의 추상화에 가깝습니다! 🎜🎜🎜1. 인터페이스 특성 🎜🎜🎜1), 인터페이스의 🎜methods🎜 기본값은 🎜🎜public abstract🎜🎜 유형이고, 인터페이스의 🎜member 변수🎜 유형은 🎜🎜public static final🎜🎜입니다. 🎜2) 인터페이스에는 생성 방법이 없습니다. 🎜3) 인터페이스는 "다중 상속"을 구현할 수 있습니다. 구현 형식은 쉼표로 직접 구분하는 것입니다. 🎜🎜🎜2. 인터페이스에 대해 알아야 합니다🎜🎜🎜인터페이스는 public static final 변수만 포함할 수 있습니다. 작성하지 않은 경우 기본값은 public static final입니다. >private code> 수정은 컴파일에 실패합니다. 🎜🎜인터페이스의 모든 메서드는 암시적으로 공개 추상 메서드로 지정되며 🎜🎜private, protected, static과 같은 다른 키워드를 사용하여 공개 추상 메서드만 될 수 있습니다. , final🎜🎜 및 기타 수정 사항은 컴파일에 실패합니다. 🎜🎜🎜3. 인터페이스 오해🎜🎜🎜인터넷의 많은 기사에서는 인터페이스의 모든 메소드가 추상 메소드라고 말합니다. 그 블로거는 다시 조사를 한 결과 실제로 이것이 충분히 엄격하지 않다는 것을 발견했습니다. 간단한 프로그램🎜

package InterfaceDemo;

interface AA{   //接口AA
   default void hh(){
       System.out.println("123");
   };
}

class BB implements AA{  //实现接口
    
}

public class InterfaceDesign {

    public static void main(String[] args) {
        AA a=new BB(); //通过实现类创建实例
        a.hh();
    }
}
运行结果： 123

显然hh方法并不是抽象方法，但是这样设计就失去接口的意义了，实际开发中不会出现这样的代码，确实有点专牛角尖的韵味,所以我也不否认网上的言论，只是觉得不够严谨，我觉得大家还是注意一下比较好...如果面试官听到你这样的回答，可能对你刮目相看，会认为你是一个对知识极度向往、探索以及有个人思维想法的学习者 ~说白了，就是杠精，这里杠精是褒义词~

抽象类和接口本质区别

抽象类和接口本质区别主要从语法区别和设计思想两方面下手

1、语法区别

1.抽象类可以有构造方法，接口中不能有构造方法。

2.抽象类中可以有任何类型成员变量，接口中只能有public static final变量

3.抽象类中可以包含非抽象的普通方法，接口中的可以有非抽象方法，比如deaflut方法

4.抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然 eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。

5.抽象类中可以包含静态方法，接口中不能包含静态方法

6.抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

7.一个类可以实现多个接口，但只能继承一个抽象类。

2、设计思想区别

对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现（相当于写普通类的普通方法并添加方法体的实现代码），子类可以不进行变更；而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。这一点应该很好理解。

从设计角度来讲抽象类是对一种对类抽象，抽象类是对整个类整体进行抽象，包括属性、行为。而接口是对行为的抽象，接口是对类局部（行为）进行抽象。从某一角度来讲，接口更像是抽象的抽象！

怎么理解上面这段话呢？

理解二者设计思想的区别从程序员宜春和花姑娘（一头可爱的小母猪）的故事开始，程序员宜春每天过着三点一线的生活，不是吃就是睡觉，闲暇之余还会敲敲代码，而花姑娘就厉害了，每天都是一点一线的生活，不是吃就是睡觉，闲暇之余不是吃就是睡觉。程序员宜春和花姑娘都过着幸福安逸的生活，突然有一天，风起云涌，天射大便~天色大变~，万恶的产品经理来需求了，要设计一个程序员宜春和花姑娘的一个程序，要求使用抽象类或者接口去设计，这个时候你会怎么去设计，下面给出两个设计方案...

方案一：使用抽象类设计，分别设计eat、sleep、qiaoDaiMa方法，具体代码如下：

abstract class Myclass{
    public abstract void eat();
    public abstract void sleep();
    public abstract void qiaoDaiMa();
  }

方案二：使用接口设计，分别设计eat、sleep、qiaoDaiMa方法，具体代码如下：

interface Myclass{
    public abstract void eat();
    public abstract void sleep();
    public abstract void qiaoDaiMa();
  }

显然，不管是哪个类继承抽象类或者实现上面的接口，都会出现同样的状况：重写它们的抽象方法。
如果有一百个程序员宜春，上面的设计都是很好地得到解决。但是到花姑娘身上就不管用了，花姑娘不会敲代码这种高端操作啊！一百个花姑娘都重写的qiaoDaiMa方法都没有意义啊，显然这样设计有问题。

从上面可以看出，eat、sleep对于qiaoDaiMa方法不是同一范畴内的行为（方法）。实际上我们可以这样设计：定义一个抽象类，包含eat、sleep方法，再定义一个接口包含qiaoDaiMa方法，具体代码如下：

abstract class Myclass{
    public abstract void eat();
    public abstract void sleep();
   }

interface MyclassTwo{
    public abstract void qiaoDaiMa();
  }
  
class YiChun extends Myclass implements MyclassTwo{

          @Override
          public void eat() {
              
          }

          @Override
          public void sleep() {

          }

          @Override
          public void qiaoDaiMa() {

          }
      }

我们只要让一百个程序员宜春继承抽象类并实现接口就好了，而花姑娘就直接继承抽象类就好了。这样一设计，堪称完美...

同样的，这样讲述是很不负责的，为啥捏？因为你会发现，这样设计不管是抽象类还是接口好像没有什么区别，刚才的抽象类换成接口，接口换成抽象类，实现效果也一致，代码如下：

interface Myclass{
    public abstract void eat();
    public abstract void sleep();
   }

abstract class MyclassTwo{
    public abstract void qiaoDaiMa();
  }

所以，为了讲解清晰设计思想区别，程序员宜春和花姑娘的故事不得不继续讲下去...

我们都知道，可爱的小母猪一般都是粉色的对吧，这个时候我们的产品经理又改需求了。啥？产品经理家中一百只小猪有一只是黑白sai的，额...

万恶的产品经理只会无理改需求，可是产品经理永远不会知道他一味逼程序员，程序员自己都不知道自己有多优秀！

我们都知道，可爱的小母猪一般都是粉色的对吧，这个时候我们的产品经理又改需求了。啥？产品经理家中一百只小猪有一只是黑白sai的，额...

万恶的产品经理只会无理改需求，可是产品经理永远不会知道他一味逼程序员，程序员自己都不知道自己有多优秀！

那么这个时候，我们都知道,抽象类和接口都是可以有成员变量的，只不过接口比较苛刻只能是public static final正是因为这一点！抽象类和接口的设计精髓就在这里了，这个时候我们这样设计：

interface Myclass{
    public abstract void eat();
    public abstract void sleep();
   }

abstract class MyclassTwo{
    String color="red";
    public abstract void qiaoDaiMa();
  }

让宜春类这样设计

package AbstractTest;

interface Myclass {
    public abstract void eat();

    public abstract void sleep();
}

abstract class MyclassTwo {
    String color = "red";

    public abstract void qiaoDaiMa();
}

class YiChun extends MyclassTwo implements Myclass {

    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }

    @Override
    public void qiaoDaiMa() {

    }
}

public class AbstractDemo {
    public static void main(String[] args) {
        YiChun yc = new YiChun();
    }

}

然而宜春对于color这个属性可以是不理睬的，可以当做不存在，除非宜春不嫌弃自己也是一只红sai佩奇哈哈哈....

而花姑娘类就要注意了！然后让产品经理家中的100只小猪设计代码如下;

package AbstractTest;

interface Myclass {
     public abstract void qiaoDaiMa();
}

abstract class MyclassTwo {
    String color = "red";

    public abstract void eat();
    public abstract void sleep();
  
}

class Pig extends MyclassTwo {

    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }

}

public class AbstractDemo {
    public static void main(String[] args) {
        Pig p = new Pig ();
        String color = "blackWhite";
        System.out.println(color);
    }

}

其余的99只花姑娘就直接不用动了也就是不需要String color = "blackWhite";这一句代码，它的color属性默认是red了...

这个时候抽象类和接口就不能更换了，从而抽象类和接口的设计思想就很清晰了，你何识着咩啊~

本文来自 java入门 栏目，欢迎学习！

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