抽象类、抽象方法、接口-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_68151004/article/details/127837206

本文详细介绍了Java中的抽象类与抽象方法，包括它们的定义、特点和使用。抽象类不能被实例化，但可以通过子类实现。模板方法模式用于定义通用功能，并将可变部分抽象为子类实现。接口作为规范，可以被类实现，体现了多实现的特性。JDK8之后，接口增加了默认方法、静态方法和私有方法等新特性。通过这些概念，我们可以更好地理解和应用面向对象设计原则。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、抽象类与抽象方法

1.代码展示

Animal类

/*
abstract---修饰符------abstract类+abstract方法
 */
public abstract class Animal {
    abstract void eat();//只有方法头，没有方法体
    abstract void jump();
     void sleep(){
        System.out.println("睡觉。。。。。");
    }
}

Cat类

public class Cat extends Animal{
    void eat(){
        System.out.println("猫吃鱼。。。。。。");
    }
    void jump(){
        System.out.println("猫");
    }
}

Monkey类

public class Monkey extends Animal{
    void eat(){
        System.out.println("猴子吃桃子。。。。。。。。。。");
    }
    void jump(){
        System.out.println("猴子");
    }
}

Pig类

public class Pig extends Animal{
    void eat(){
        System.out.println("猪吃饲料。。。。。。。");
    }
    void jump(){
        System.out.println("猪慢慢跳");
    }
}

Test类

//抽象类不能new----实例化（不能）
//可通过子类（一定复写抽象类中所有的抽象方法）创建对象
//复写条件：子类权限大于等于父类条件
public class Test {
    public static void main(String[] args) {
        Monkey mon1=new Monkey();
        mon1.eat();
        mon1.sleep();
        mon1.jump();
        System.out.println("=======================");
        Cat cat1=new Cat();
        cat1.eat();
        cat1.sleep();
        cat1.jump();
    }
}

2.抽象类与抽象方法的特点

1.不能new这个抽象类，只能靠子类实现它，约束！
2.抽象类中的方法不全是抽象方法
3.抽象方法一定在抽象类中
4.要想成为抽象类的子类，必须复写父类的所有抽象方法（复写条件：子类的权限大于等于父类）或者子类也定义为抽象类
5.abstract可以修饰方法和类
6.抽象方法，只有方法名字，没有方法的实现
7.不能用abstract修饰变量、代码块、构造器
8.最重要的特征:得到了抽象方法，失去了创建对象的能力（有得有失）

3.思考题

A.抽象类不能new，存在构造器吗？
类有的成员（成员变量、方法、构造器）抽象类都具备
B.抽象类存在的意义？
抽象出来-节省代码的开发，提高开发效率
C.final和abstract有什么关系？

互斥关系
abstract定义的抽象类作为模板让子类继承，final定义的类不能被继承
抽象方法定义通用功能让子类复写，final定义的方法子类不能复写

4.模板方法模式

4.1使用场景说明：当系统中出现同一个功能多处在开发，而该功能中大部分代码是一样的，只有其中部分可能不同的时候
4.2模板方法模式实现步骤：

把功能定义成一个所谓的模板方法，放在抽象类中，模板方法中只定义通用且确定的代码
模板方法中不能决定的功能定义成抽象方法让具体子类去实现

在这里插入图片描述

public abstract  class Student {
    /**
     * 正式：声明了模板方法
     */
    public void write(){
        //题目
        System.out.println("\t\t\t《我的爸爸》");
        //第一段
        System.out.println("你的爸爸是什么样，来说说");
        //正文部分（每个子类都要写，每个子类写的情况不一样
        //因此，模板方法把正文部分定义成抽象方法，交给具体子类去完成）
        System.out.println(writeMain());
        //最后一段
        System.out.println("我爱我的爸爸");
    }
    public abstract String writeMain();
}

public class StudentChild extends Student{
    @Override
    public String writeMain() {
        return "我的爸爸是超级英雄";
    }
}

public class StudentMiddle extends Student {
    @Override
    public String writeMain() {
        return "我的爸爸是superhero";
    }
}

public class Test {
    public static void main(String[] args) {
        //目标：理解模板方法模式的思想和使用步骤
        StudentChild sc=new StudentChild();
        sc.write();
        StudentMiddle sm=new StudentMiddle();
        sm.write();
    }
}

《我的爸爸》
你的爸爸是什么样，来说说
我的爸爸是超级英雄
我爱我的爸爸
			《我的爸爸》
你的爸爸是什么样，来说说
我的爸爸是superhero
我爱我的爸爸

注：模板方法建议用final修饰，这样更专业
原因：模板方法是给子类直接使用的，不是让子类重写的，子类一旦重写了模板方法，模板方法就失效了，因此，加上final后可以防止子类重写模板方法，这样更安全、更专业！

二、接口

1.接口的定义与特点

/**
 * 声明了一个接口，体现的是一种规范，规范一定要公开。
 */
public interface InterfaceDemo {
    //目标：接口中的成分特点：JDK8之前，接口中只能有抽象方法和常量
    //1.常量：
    //注意：由于接口体现的是规范思想，规范默认都是公开的，所以代码层面都是公开的
    //public static final可以省略不写
    public static final String SCHOOL_NAME="黑马";//常量
    //2.抽象方法：
    //注意：由于接口体现的是规范思想，规范默认都是公开的，所以代码层面都是公开的，
    //public abstract 可以省略不写
    public abstract void run();
    public abstract void eat();
}

接口体现的也是一种规范
接口的定义格式：
public interface 接口名{
//常量
//抽象方法
}

2.接口的基本使用：被实现

2.1接口的用法：

接口是用来被类实现（implements）的，实现接口的类称为实现类。实现类可以理解成所谓的子类。
2.2语法格式
修饰符 class 实现类 implements 接口一、接口二、接口三，…{

}

接口可以多实现

/**
 * 规范思想
 */
public interface SportMan {
    void run();
    void competition();
}

public interface Law {
    void rule();
}

/**
 * 实现类
 */
public class PingPangMan implements SportMan,Law{
    private String name;
    public PingPangMan (String name){
        this.name=name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void run(){
        System.out.println(name+"必须跑步训练！");
    }
    @Override
    public void competition(){
        System.out.println(name+"要参加比赛！");
    }
    @Override
    public void rule(){
        System.out.println(name+"必须守法");
    }
}

public class Test {
    public static void main(String[] args) {
        //目标：理解接口的基本使用，被类实现
        PingPangMan p=new PingPangMan("小米");
        p.run();
        p.competition();
        p.rule();
    }
}

3.接口与接口的关系（多继承）

3.1

public interface Law {
    void rule();
}

public interface People {
    void eat();
    void sleep();
}

/*
接口可以多继承：一个接口可以同时继承多个接口
 */
public interface SportMan extends Law,People{
    void run();
    void competition();
}

/**
 * 一个实现类
 */
public class BasketballMan implements SportMan{

    @Override
    public void rule() {

    }

    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }

    @Override
    public void run() {

    }

    @Override
    public void competition() {

    }
}

public class Test {
    public static void main(String[] args) {
        //理解：接口多继承的作用

    }
}

3.2作用：规范合并，整合多个接口为一个接口，便于子类实现

4.JDK8开始新增方法（包含8）

4.1默认方法

类似实例方法：必须用default修饰
默认会用public修饰，需要用接口的实现类对象调用

4.2静态方法

默认用public修饰，必须用static修饰
注意：接口的静态方法必须用本身的接口名来调用

4.3私有方法

就是私有的实例方法，必须使用private修饰，从JDK1.9开始使用
只能在本接口中被其他的默认方法或者私有方法访问

public interface SportManInter {
    //1.JDK8开始：默认方法(实例方法)
    /*
     必须default修饰，默认public修饰
     默认方法：接口不能创建对象，这个方法只能给实现类，有实现类的对象调佣
     */
    public default void run(){
        System.out.println("跑的很快");
       // go();
    }
    /**
     * 2.静态方法：Jdk1.8开始，必须用static修饰，默认用public修饰
     * 注：接口的静态方法必须用本身的接口名来调用
     */
    public static void inAdder(){
        System.out.println("我们都在学习Java新增方法的语法");
    }
    /**
     * 3.jdk9开始的新增方法，私有方法，必须在接口内部被访问，
     * 必须在接口内部才能访问
     */
//    private void go(){
//        System.out.println("开始跑");
//    }
}
class PingPangMan implements SportManInter{
}
class Test{
    public static void main(String[] args) {
        PingPangMan p=new PingPangMan();
        p.run();
        SportManInter.inAdder();
    }
}

4.总结

41.基本关系小结
类和类的关系：单继承
类和接口的关系：多实现
接口和接口的关系：多继承，一个接口可以继承多个接口
4.2接口的注意事项：

接口不能创建对象
一个类实现多个接口，多个接口中的同名的静态方法不冲突原因：接口的静态方法必须用本身的接口名来调用

public class Test {
    public static void main(String[] args) {
        /**
         * 接口不能创建对象(接口没有构造器)
         *一个类实现多个接口，多个接口中有同名的静态方法不冲突
         *一个类继承父类，同时又实现了接口，父类中和接口又同名方法，默认用父类的
         *一个类实现了多个接口，多个接口存在同名的默认方法，不冲突，这个类重写该方法即可
         *一个接口继承
         */
    }
}
interface A{
    public static void test(){
        System.out.println("A");
    }
}
interface B {
    public static void test() {
        System.out.println("B");
    }
}
class C implements A, B {
    public static void main(String[] args) {
        B.test();
        A.test();
    }
}

一个类继承父类，同时又实现了接口，父类中和接口有同名方法，默认用父类的

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
    }
}
//3.一个类继承父类，同时又实现了接口，父类中和接口有同名方法，默认用父类的
interface Food{
    default void eat(){
        System.out.println("接口中的吃方法");
    }
}
class Animal{
    public void eat(){
        System.out.println("父类动物吃！！！");
    }
}
class Cat extends Animal implements Food{


}

一个类实现了多个接口，多个接口存在同名的默认方法，不冲突，这个类重写该方法即可

interface AA{
    public default void go(){
        System.out.println("AA");
    }
}
interface BB{
    public default void go(){
        System.out.println("BB");
    }
}
class CC implements AA,BB{

    @Override
    public void go() {
        System.out.println("abc");
    }
}

一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承

interface AAA{
    int  run();
}
interface BBB{
    void run();
}
interface  CCC extends AAA,BBB{//此时会报错
    
}