备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

第22篇：接口与抽象类、匿名类的介绍

2022-10-19 120
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 📋 匿名类和局部类一样，都只能访问 final 或有效 final 的局部变量📋 匿名类可以直接访问外部类中的所有成员（即使被声明为 private）📋 匿名类只有在实例相关的代码块中使用，才可直接访问外部类中的实例成员📋 匿名类不能自定义构造方法📋 匿名类可以有初始化块

一、抽象类和接口的选择

📋 选择抽象类

📝 在紧密相关的类之间共享代码（有关联的类之间共享代码）
📝 需要除 public 之外的访问权限（接口中全是 public）
📝 需要定义实例变量，非 final 的 静态变量的时候（接口中默认都是 public final）

📋 选择接口

📝 不相关的类实现相同的方法的时候
📝 只是定义 行为（方法），不关心具体是誰实现了行为的时候
📝 想实现类型的多重继承的时候

二、接口中的默认方法

❓ 假如进行接口升级（如增加新的抽象方法），会导致大幅度的代码改动，之前实现该接口的所有类都得改动
📋 若想在不改动之前实现类的前提下进行接口升级，从 Java8 开始有2种方案：

(1) 默认方法

📝 被 default 修饰的方法
📝 默认方法只能是实例方法
📝 默认方法有具体的实现
📝 默认方法不强制子类（实现该接口的类）必须实现它.

❓ 当一个类实现的接口中存在默认方法的时候，该类可以：

📝 啥也不干，沿用接口的该方法的默认实现
📝 重写该默认方法的实现
📝 把自己修改为抽象类-，重新声明抽象方法（抽象方法的方法签名和返回值类型要与父接口的默认方法一致）

❓ 当一个接口继承的父接口中存在默认方法的时候，该类可以：

📝 啥也不干，沿用父接口的该方法的默认实现
📝 重新定义默认方法，覆盖父接口默认方法
📝 声明抽象方法（抽象方法的方法签名和返回值类型要与父接口的默认方法一致）

默认方法细节

① ✏️ 若父类定义的非抽象方法与接口的默认方法的方法签名一样，最终将调用父类的方法（与方法的返回类型无关）

public interface Eatable {
    default void eat() {
        System.out.println("Eatable_eat()");
    }
}
public class Father {
    public void eat() {
        System.out.println("Father_eat()");
    }
}
public class Child extends Father implements Eatable {
    public static void main(String[] args) {
        Child child = new Child();
        // Father_eat()
        child.eat();
    }
}

② ✏️ 若父类定义的抽象方法与接口的默认方法的方法签名一样，强制要求子类必须实现此抽象方法

public interface Eatable {
    default void eat() {
        System.out.println("Eatable_eat()");
    }
}
public abstract class Father {
    public abstract void eat();
}
public class Child extends Father implements Eatable {
    public static void main(String[] args) {
        Child child = new Child();
        
        /*
            Eatable_eat()
            Child_eat()
         */
        child.eat();
    }


    @Override
    public void eat() {
        // 调用父接口的 eat() 方法
        Eatable.super.eat();
        System.out.println("Child_eat()");
    }
}

③ ✏️ 若（父）接口定义的默认方法与其他（父）接口定义的默认方法的方法签名相同的时候，要求子类型（接口或类）也必须实现该默认方法。

📝 实现（ implements）的多个接口中的默认方法有相同的方法签名的的时候，该方法的返回类型也必须一样。 
public interface Eatable {
    default String test(String text) {
        System.out.println("Eatable_test(String text)");
        return text;
    }
}
public interface Testable {
    default String test(String txt) {
        System.out.println("Testable_test()");
        return txt;
    }
}

接口:

public interface Demoable extends Eatable, Testable {
    @Override
    default String test(String text) {
        Eatable.super.test("Eatable_test");
        Testable.super.test("Testable_test");
        System.out.println("Demoable_test(String text)");
        return text;
    }
}

类：

public class TestDemo implements Eatable, Testable {
    @Override
    public String test(String text) {
        return null;
    }
}

(2) 静态方法

📝 接口中定义的静态方法只能通过接口名调用
📝 接口中的静态方法不会被继承

public interface Runnable {
    static void move() {
        System.out.println("Runnable_move()");
    }
}
public interface Eatable extends Runnable {
    static void move() {
        System.out.println("Eatable_move()");
    }
}
public interface Walkable extends Eatable {
    static void move() {
        System.out.println("Walkable_move()");
    }
}
public class TestDemo implements Runnable, Eatable, Walkable {
    public static void main(String[] args) {
        Runnable.move();
        Eatable.move();
        Walkable.move();

        /*
            output:
                Runnable_move()
                Eatable_move()
                Walkable_move()
         */
    }
}

三、匿名类（实用）

📋 当接口或抽象类的实现类在整个项目中只使用过一次的时候，可以考虑使用匿名类（Anonymous Class）

接口：

/**
 * 一个测试接口
 */
public interface Testable {
    String test(String txt);
}
public class TestDemo1 {
    public static void main(String[] args) {
        /* 匿名类实现 Testable 接口里面的方法 */
        Testable testable = new Testable() {
            @Override
            public String test(String txt) {
                System.out.println("匿名类：test(String txt)");
                return txt + "_Happy";
            }
        };
        
        /*
            匿名类：test(String txt)
            庆医_Happy
         */
        System.out.println(testable.test("庆医"));
    }
}

抽象类: 

/**
 * 一个测试抽象类
 */
public abstract class TestAbstract {
    public abstract void testTest();
}
public class TestDemo2 {
    public static void main(String[] args) {
        /* 通过匿名类实现 TestAbstract 里面的抽象方法*/
        TestAbstract testAbstract = new TestAbstract() {
            public void testTest() {
                System.out.println("TestAbstract_testTest()");
            }
        };

        // TestAbstract_testTest()
        testAbstract.testTest();

        /* 创建完匿名类对象后就调用里面的方法 */
        new TestAbstract() {
            public void testTest() {
                System.out.println("创建完匿名类对象后就调用里面的方法");
            }
        }.testTest();
    }
}

(1) 匿名类细节

📋 匿名类内部不能定义除编译时常量之外的任何static成员

📖 static成员通常通过类名访问，匿名类连名字都没有咋访问啊！

📋 匿名类和局部类一样，都只能访问 final 或有效 final 的局部变量

📋 匿名类可以直接访问外部类中的所有成员（即使被声明为 private）

📋 匿名类只有在实例相关的代码块中使用，才可直接访问外部类中的实例成员

📋 匿名类不能自定义构造方法

📋 匿名类可以有初始化块

(2) 匿名类的应用（☆）

① 代码传递

🍀 写一个工具类 codeTimes
🍀 作用：可计算一段代码的执行时间
🍀 可使用接口实现代码传递

工具类：

/**
 * 计算某段代码的执行时间
 */
public class CodeTimes {

    /**
     * 代码块（以 Inter 结尾表示接口）
     */
    public interface BlockInter {
        void passCode(); // 传递代码
    }

    public static void check(String description, BlockInter codeBlock) {
        if(codeBlock == null) return;
        
        System.out.println("\n----------------------------");
        System.out.println("测试功能：" + description);
        long beginTime = System.currentTimeMillis();

        codeBlock.passCode();

        long endTime = System.currentTimeMillis();
        long duration = (endTime - beginTime) / 1000;
        System.out.println("代码执行花费时间：" + duration + "秒");
        System.out.println("----------------------------");
    }
}

测试类：

public class TestDemo {
    public static void main(String[] args) {
        CodeTimes.check("测试 1", new CodeTimes.BlockInter() {
            @Override
            public void passCode() {
                String string = "Hello Friend";
                for (int i = 0; i < 30000; i++) {
                    string += i;
                }
            }
        });

        CodeTimes.check("测试2", new CodeTimes.BlockInter() {
            @Override
            public void passCode() {
                test();
            }
        });

    }

    /**
     * 待测试的方法
     */
    public static void test() {
        StringBuilder string = new StringBuilder("Hello Friend");
        for (int i = 0; i < 30000; i++) {
            string.append(i);
        }
    }
}

② 过滤器

public class Files {
    public interface Filter {
        boolean accept(String filename);
    }

    public static String[] getAllFilenames(String dir, Filter filter) {
        if(filter == null || dir == null || "".equals(dir)) return new String[];
        // 1.获取 dir 文件夹下的全部文件名
        String[] filenames = {};

        // 2.进行过滤
        for (String filename : filenames) {
            if (filter.accept(filename)) {
                // 文件名符合要求, 保存起来
            }
        }
        // 3.返回所有符合过滤条件的文件名
        return null;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Files.getAllFilenames("D://gq", new Files.Filter() {
            @Override
            public boolean accept(String filename) {
                return filename.contains("爱");
            }
        });
    }
}

③ 回调

public class Life {
    public interface Callback {
        void person(String money);

        void animal();
    }

    public static void check(String name, Callback callback) {
        if(callback == null) return;
        boolean result = isGoodPerson(name);
        if (result) {
            String money = "1000万";
            callback.person("\n" + name + "_获得_" + money);
        } else {
            callback.animal();
        }
    }

    private static boolean isGoodPerson(String name) {
        return !name.equals("坏人");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Life.check("庆医", new Life.Callback() {
            @Override
            public void person(String money) {
                System.out.println(money);
            }

            @Override
            public void animal() {
                System.out.println("\n坏人_当动物");
            }
        });
    }
}
🍀 匿名类的作用本质上是 代码传递，第一次学习的时候对它的理解非常懵，只觉得它非常好用。假如你是初学者，我相信你也会很懵。慢慢来，后面有使用场景的时候你就一目了然了。

如有错误，请不吝赐教

文章标签：
Java
张思睿ZGQ
目录
相关文章
赵广陆
|
8月前
|
Java
Java接口和抽象类
Java接口和抽象类
赵广陆
52 0
Hacoj
|
15天前
|
设计模式 Java
Java接口与抽象类
Java接口与抽象类
Hacoj
17 0
张思睿ZGQ
|
2月前
|
Java
22、接口与抽象类、匿名类的介绍
22、接口与抽象类、匿名类的介绍
张思睿ZGQ
23 0
&sup3;+++
|
2月前
|
算法 C++
c++接口（抽象类）
c++接口（抽象类）
&sup3;+++
15 0
十一..
|
5月前
|
Java 编译器
抽象类和接口
抽象类和接口
十一..
30 0
greework
|
11月前
抽象类与接口
抽象类与接口
greework
41 0
游客mily4rqnu2u72
接口，虚方法，抽象方法
接口，虚方法，抽象方法
游客mily4rqnu2u72
125 0
qasxfte752dni
|
C++
C++中的抽象类和接口
C++中的抽象类和接口
qasxfte752dni
64 0
acc8226
|
Java 编译器
07 接口和抽象类
接口 比抽象类更加抽象的是接口，在接口中所有的方法都会被 public abstract 修饰。 注意：Java 8 之后接口中新增加了 default 默认方法和 对 static 方法的支持。 • Java 中不支持多继承,而是通过接口实现比多重继承更强的功能，java 通过接口可以使出于不同层次,甚至不相关的类具有相同的行为. • 接口可以认为是特殊的抽象类, 不能用于直接创建对象。接口的作用在于规定一些功能框架,具体功能的实现则通过该接口约束的类完成。
acc8226
88 0
游客k2gw4fr7y7zie
抽象类与接口
抽象类 abstract修饰符可以用来修饰方法，也可以用来修饰类，修饰方法就是抽象方法，修饰类就是抽象类 抽象类中可以没有抽象方法，但是抽象方法的类一定要声明为抽象类 抽象类，不能使用new关键字来创建对象，它使用来让子类继承的 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的 子类继
游客k2gw4fr7y7zie
118 0

热门文章

最新文章

  • 1
    解决关于Windows Defender Antivirus Service自启造成运行python程序时，Windows的cpu和内存占用过高问题
  • 2
    订票系统不再瘫痪 阿里云确认与12306合作
  • 3
    2022年了！你有几种获取URL参数的方法？
  • 4
    基于Tablestore的一站式物联网存储解决方案-场景篇
  • 5
    使用 Notepad++ 编辑 .java 文件时的相关配置
  • 6
    烂泥：IIS主机头的理解与应用
  • 7
    安装SQLSERVER2000时出现以前的某个程序安装已在安装计算机上创建挂起的文件操作
  • 8
    android 官方文档中的一些错误收集
  • 9
    Git SSH Key 生成步骤
  • 10
    iReport中求和的问题
  • 1
    【C言专栏】C 语言结构体的应用与实践
    19
  • 2
    【C 言专栏】C 语言指针的深度解析
    20
  • 3
    【专栏：HTML与CSS前端技术趋势篇】HTML与CSS在PWA（Progressive Web Apps）中的应用
    18
  • 4
    【专栏：HTML与CSS前端技术趋势篇】前端框架（React/Vue/Angular）与HTML/CSS的结合使用
    18
  • 5
    Docker部署Traefik结合内网穿透远程访问Dashboard界面
    23
  • 6
    【专栏：HTML 与 CSS 前端技术趋势篇】Web 性能优化：CSS 与 HTML 的未来趋势
    13
  • 7
    探索自动化测试工具Selenium Grid的高效集成策略
    11
  • 8
    深入理解PHP中的命名空间
    13
  • 9
    【专栏：HTML与CSS前端技术趋势篇】渐进式增强与优雅降级在前端开发中的实践
    10
  • 10
    【专栏：HTML与CSS前端技术趋势篇】网页设计中的CSS Grid与Flexbox之争
    11

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册

    • 相关实验场景

    更多
  • 面向对象-1：类的定义
  • 对象和接口-3：接口类型
  • 对象和接口-2：常见用法
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考