【达内课程】面向对象之接口

最新推荐文章于 2022-03-08 10:33:47 发布
最新推荐文章于 2022-03-08 10:33:47 发布
阅读量376 收藏 1
点赞数
分类专栏： # 达内安卓培训 文章标签： 面向对象 达内 接口
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010356768/article/details/76649021
版权

文章目录

需要知道的知识点

1、百度百科的定义：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

Java中的接口可以被看作是只包含常量和抽象方法的抽象类 。

2、接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。它和类的区别是用interface来代替class关键字，用implements来代替extends关键字。

接口的定义格式：

interface 接口名称{
　　全局常量 ;
　　抽象方法 ;
}

3、在一个接口中，只能定义常量、抽象方法，JDK1.8后可以定义默认的实现方法

4、接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。

5、类只能继承1个类，但可以实现多个接口

class A extends B implements C,D,E{
}

6、接口之间继承，接口继承接口可以多继承

interface A extends B,C,D{
}

7、java8新增
（1）增加了 default 方法和 static 方法，这两种方法完全可以有方法体
（2）default 方法属于实例，static 方法属于类(接口)
（3）接口中的静态方法不会被继承，接口中的静态变量会被继承

举例1：Weapon接口 ，理解接口的使用

我们创建一个武器接口 Weapon
定义了武器类型有：冷兵器（TYPE_CODE）、热兵器（TYPE_HEAT）、核武器（TYPE_NUCLEAR）
定义了武器的方法有 ：攻击（kill）、获取武器名称（getName）、获取武器类型（getType）

接着我们创建冷兵器倚天剑类 Sword类和热兵器 AK47 类 都实现 Weapon 接口。

Weapon
|--------------冷兵器：倚天剑
|--------------热兵器：AK47

创建Weapon接口

public interface Weapon {
    //接口中的属性默认为public static final,所以可省
    public static final int TYPE_COLD = 1;
    int TYPE_HEAT = 2;

    //必须是公共、抽象的，public abstract可以省略
    //接口中的方法会被隐式的指定为 public abstract
    //而且只能是 public abstract(公共、抽象的),所以可省
    public abstract void kill(TextView textView);
    String getName();
    int getType();
}

创建Sword类

public class Sword implements Weapon {
    @Override
    public void kill(TextView textView) {
        textView.append("舞出了一套太极剑法");
    }

    @Override
    public String getName() {
        return "倚天剑";
    }

    @Override
    public int getType() {
        return Weapon.TYPE_COLD;
    }
}

创建AK47类

public class AK47 implements Weapon {
    @Override
    public void kill(TextView textView) {
        textView.append("连续射出了100发子弹");
    }

    @Override
    public String getName() {
        return "AK47";
    }

    @Override
    public int getType() {
        return Weapon.TYPE_HEAT;
    }
}

xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/btn_transformer"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="doClick"
        android:text="变形金刚" />

    <Button
        android:id="@+id/btn_sword"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="doClick"
        android:text="倚天剑" />

    <Button
        android:id="@+id/btn_ak47"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="doClick"
        android:text="AK47" />

    <Button
        android:id="@+id/btn_kill"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="doClick"
        android:text="进攻" />

    <TextView
        android:id="@+id/text"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:textColor="#222222"
        android:textSize="20sp" />
</LinearLayout>

为了方便使用武器，我们创建一个变形金刚类 Transformer ，只要把创建的武器实例放到它手里（setWeapon()方法），然后就可以进行攻击了（调用attack()方法）

创建Transformer类

public class Transformer {
    private Weapon w;

    public void setWeapon(Weapon w) {
        this.w = w;
    }

    public void attack(TextView textView) {
        if (w == null) {
            textView.setText("没有武器，用牙咬吗？");
            return;
        }

        String type = "";
        switch (w.getType()) {
            case Weapon.TYPE_COLD:
                type = "冷兵器";
                break;
            case Weapon.TYPE_HEAT:
                type = "热兵器";
                break;
        }

        textView.setText("使用" + type + w.getName());
        w.kill(textView);
    }
}

MainActivity

public class MainActivity extends AppCompatActivity {
    Button btnTransformer;
    Button btnSword;
    Button btnAK47;
    Button btnKill;

    TextView textView;
    Transformer transformer;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        btnTransformer = findViewById(R.id.btn_transformer);
        btnSword = findViewById(R.id.btn_sword);
        btnAK47 = findViewById(R.id.btn_ak47);
        btnKill = findViewById(R.id.btn_kill);
        textView = findViewById(R.id.text);
    }

    public void doClick(View view) {
        switch (view.getId()) {
            case R.id.btn_transformer:
                createTransformer(textView);
                break;
            case R.id.btn_sword:
                createSword();
                break;
            case R.id.btn_ak47:
                createAK47();
                break;
            case R.id.btn_kill:
                kill();
                break;
        }
    }

    private void createTransformer(TextView textView) {
        transformer = new Transformer();
        textView.setText("已经创建变形金刚");
    }

    public void createSword() {
        Sword sword = new Sword();
        transformer.setWeapon(sword);
        textView.setText("接入倚天剑");
    }

    public void createAK47() {
        AK47 ak47 = new AK47();
        transformer.setWeapon(ak47);
        textView.setText("接入AK47");
    }

    public void kill() {
        transformer.attack(textView);
    }
}

运行程序：
在这里插入图片描述

举例2：Bird 类 。接口使用之一：解决多重继承问题

Java 语言本身是不支持类的多重继承(多重继承是指一个类从多个类继承而来，即一个类拥有多个超类)的，但一个类却可以实现多个接口。这样，我们可以将一些抽象方法定义在接口中，间接地达到多重继承的目的。

我们现在有接口 MyInterface1有 飞翔（fly）方法、接口 MyInterface2 有行走（walk）方法

人类能走路所以可以实现 MyInterface2 。而鸟类既能走路也能飞翔，所以要实现 MyInterface1 和 MyInterface2 两个接口。这样就解决“多重继承”的问题

MyInterface1.java

public interface MyInterface1 {
    void fly();
}

MyInterface2.java

public interface MyInterface2 {
    void walk();
}

Bird.java

public class Bird implements MyInterface1, MyInterface2 {
    private static final String TAG = "Bird";

    @Override
    public void fly() {
        Log.i(TAG, "I can fly");
    }

    @Override
    public void walk() {
        Log.i(TAG, "I can walk");
    }
}

举例3：Calculator 接口 。接口使用之二：定义一个规范（协议）

同一个接口可以有多个不同的实现类，但每一个实现类都必须重写接口中所有的抽象方法。即接口不考虑这些实现类各自采用什么方式实现这些功能，但它要求所有的实现类都必须有这些功能。

例如：
首先定义一个计算器的接口：ICalculator.java，所有实现该接口的类，都必须具有计算两个数相加、相减、相乘、相除的功能。

ICalculator

public interface ICalculator {
    /**
     * 计算器可以计算两个数的和
     */
    int add(int a, int b);

    /**
     * 计算器可以计算两个数的差
     */
    int sub(int a, int b);

    /**
     * 计算器可以计算两个数的积
     */
    long mul(int a, int b);

    /**
     * 计算器可以计算两个数的商
     */
    float div(int a, int b);
}

创建实现该接口的类 ACalculator.java

public class ACalculator implements ICalculator {
    @Override
    public int add(int a, int b) {
        return a + b;
    }

    @Override
    public int sub(int a, int b) {
        return a - b;
    }

    @Override
    public long mul(int a, int b) {
        return a * b;
    }

    @Override
    public float div(int a, int b) {
        return (float) a / (float) b;
    }
}

测试使用

在其他类中使用 ACalculator 进行两数之和的计算，其他类并不需要了解ACalculator 是通过什么方式计算的，只需要了解 ICalculator 接口中的相关方法定义即可

ICalculator calculator = new ACalculator();
int sum = calculator.add(12, 14);
System.out.println("sum = " + sum);

运行结果：
在这里插入图片描述

举例4：OnInfoFetchCallback 。接口使用之三：用于回调

我们知道，一般情况下主线程是不执行耗时任务的，如果遇到一些耗时任务（如网络请求，文件读写，数据库读写等等），我们会将其放入子线程中去执行，当执行完毕后，子线程再将执行结果返回给主线程。这个过程就是回调

首先定义一个回调接口 OnInfoFetchCallback.java

public interface OnInfoFetchCallback {
    /**
     * 获取信息成功
     */
    void onSuccess(String info);

    /**
     * 获取信息失败
     */
    void failure();
}

再定义一个用于获取信息的任务类，在这个类中我们执行一些耗时操作 InfoService.java

public class InfoService {
    private OnInfoFetchCallback callback;

    public InfoService(OnInfoFetchCallback callback) {
        this.callback = callback;
    }

    public void getInfo() {
        // 模拟一个耗时操作
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(3000);
                // 信息获取成功，传递结果
                callback.onSuccess("结果是：" + new Date());
            } catch (InterruptedException e) {
                // 信息获取失败
                callback.failure();
            }
        });
        thread.start();
    }
}

xml 中放一个按钮来获取信息

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/btn_getInfo"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="doClick"
        android:text="获取信息" />

</LinearLayout>

MainActivity
在 MainActivity 中调用 InfoService 中的 getInfo() 方法执行耗时操作

public class MainActivity extends AppCompatActivity implements OnInfoFetchCallback {
    private static final String TAG = "OnInfoFetchCallback";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    public void doClick(View view) {
        switch (view.getId()) {
            case R.id.btn_getInfo:
                fetchInfo();
                break;
        }
    }

    /**
     * 获取信息
     */
    public void fetchInfo() {
        InfoService service = new InfoService(this);
        service.getInfo();
    }

    @Override
    public void onSuccess(String info) {
        Log.i(TAG, info);
    }

    @Override
    public void failure() {
        Log.i(TAG, "获取信息失败");
    }
}

由于 MainActivity 已经实现了 OnInfoFetchCallback 接口，所以在实例化 InfoService 对象时，直接将 this 传入即可。当任务执行结束后，调用 MainActivity 中的 onSuccess(String info) 或 failure() 方法将结果返回

运行结果：
在这里插入图片描述
MainActivity 也可以不用实现 OnInfoFetchCallback 接口，此时可以采用匿名内部类的写法：

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "OnInfoFetchCallback";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    public void doClick(View view) {
        switch (view.getId()) {
            case R.id.btn_getInfo:
                fetchInfo();
                break;
        }
    }

    /**
     * 获取信息
     */
    public void fetchInfo() {
        InfoService service = new InfoService(new OnInfoFetchCallback() {
            @Override
            public void onSuccess(String info) {
                Log.i(TAG, info);
            }

            @Override
            public void failure() {
                Log.i(TAG, "获取信息失败");
            }
        });
        service.getInfo();
    }
}

参考
Java 接口
java之面向对象详解-接口

Errol_King
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
达内 面向对象
01-26
在达内的面向对象课程中，"oop day01"很可能是入门级别的教学内容，旨在帮助初学者理解并掌握面向对象的基本概念和实践。 1. **对象与类**：在OOP中，对象是程序的基本单元，它们包含数据（属性）和行为（方法）。...
达内-2 面向对象
08-06
2. **封装**：封装是面向对象的核心特性之一，它隐藏了对象内部的实现细节，只对外提供公共接口进行交互。这提高了代码的安全性和可维护性，因为外部代码无法直接修改对象的内部状态。 3. **继承**：继承允许一个类...
【UE4 C++】角色拾取、替换武器（下）
Tanzq的博客
07-31 1286
本篇将告诉你如何替换武器 靠近之后会显示字体，按E装备，靠近下一个继续按E，当前这个装备会销毁，而装备上现在这个。
【设计模式】06 策略模式
StudyWinter的博客
05-05 126
策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。 在现实生活中常常遇到实现某种目标存在多种策略可供选择的情况，例如，出行旅游可以乘坐飞机、乘坐火车或自己开私家车等，超市促销可以釆用打折、送商品、送积分等方法。 ​在软件开发中也常常遇到类似的情况，当实现某一个功能存在多种算法或者策略，我们可以根据环境或者条件的不同选择不同的算法或者策略来完成该功能，如数据排序策略有冒泡排序、选择排序、插入排序、二叉树排序等。 ​如果使用多重条件
达内科技NTD1712华为vlan定义，及简单应用
weixin_34370347的博客
02-10 195
Vlan的定义：是物理设备上连接的不受物理限制的用户的一个逻辑组。 Vlan的作用：交换机可以分割冲突域，但不能分割广播域，为了解决这个问题，引进了Vlan，它可以分割广播域。 Vlan的种类：1.基于端口划分的Vlan 2.基于mac地址划分的vlan 本文旨在研究基于端口划分的vl...
特质->self type:this
Andypan的智慧书屋
09-23 160
trait Buffering { this: FileInputStream => val b = new BufferedInputStream(this) override def read(ab: Array[Byte]): Int = { b.read(ab) } } val b = new FileInputStream("c:/ObjectT
【达内课程】面向对象之多态
Errol's Blog
07-22 394
达内课程-面向对象之多态
【达内课程】面向对象之内部类
Errol's Blog
08-09 416
达内课程-面向对象之内部类
【达内课程】面向对象之封装
Errol's Blog
08-15 314
文章目录封装的概念封装的步骤 封装的概念 封装的概念 封装性是面向对象思想的三大特征之一，封装就是隐藏实现细节，仅对外提供访问接口。实现细节部份包装、隐藏起来的方法。 封装的好处 模块化、信息隐藏、代码重用、插件化易于调试、具有安全性 封装的缺点 会影响执行效率 总结 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。 要访问该类的代码和数据，必须通过严格的接口控制。 封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。 适当的封装可以让程式码更容
【达内课程】面向对象之继承与重写
Errol's Blog
07-20 418
本文主要介绍了继承、重写、super关键字的使用。结合具体实例更容易学习。
Java面向对象笔记第1天（达内Java课程）
qq_51178270的博客
03-08 187
*今天是我的的第一篇博客 os1Image,os1Width,os1Heigth,os 对象：软件中真实存在的个体或者东西。
达内javaweb课程安排
12-02
课程体系注重Java基础功底的培养，帮助学员打下坚实的编程基础，包括核心算法、面向对象编程、数据结构、集合框架、反射、输入输出、多线程、异常处理等方面的知识。该体系同样注重Linux操作系统的使用技巧，因为...
达内C++课程笔记
07-20
- C++支持面向对象编程，类是对象的蓝图，通过封装、继承和多态这三个特性，可以构建复杂的软件系统。这里会讲解如何创建和使用类，以及理解构造函数和析构函数的作用。 5. **内存管理**： - 深入理解动态内存...
达内科技培训课程安排.docx
11-13
实训课程的安排非常详细，包括了Unix/Linux开发环境、Oracle数据库管理、面向对象分析与设计、Java编程等多个主题的培训。通过这些实训，学员不仅学习到理论知识，还能掌握实际操作技能，例如使用开发工具Eclipse、...
VB+ACCESS宾馆客房管理系统(系统+论文+封面).zip
最新发布
08-16
计算机毕业设计资源包含（项目部署视频+源码+LW+开题报告等等），所有项目经过助教老师跑通，有问题可以私信博主解决，可以免费帮部署。
自密实混凝土的研究进展.doc
08-16
自密实混凝土的研究进展.doc
基于Andriod条码识别的商品价格查询软件APP设计与实现.docx
08-16
基于Andriod条码识别的商品价格查询软件APP设计与实现.docx
基于python的人脸控制俄罗斯方块小游戏
08-16
基于python的人脸控制俄罗斯方块小游戏
达内Java全课程精华笔记
"达内教育提供的全面Java课程笔记，覆盖了Java语言的基础到核心概念，包括注释、变量、数据类型、运算符、控制结构、数组、面向对象、构造器、继承、访问控制修饰符、JavaBean、静态关键字、final、抽象类、接口、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值