第六章抽象类和接口

masa010

已于 2024-08-23 08:26:48 修改

阅读量791

点赞数 20

分类专栏：面向对象 java进阶 java全栈学习文章标签：开发语言 java

于 2024-08-22 15:38:50 首次发布

本文链接：https://blog.csdn.net/weixin_65279640/article/details/141429825

版权

java全栈学习同时被 3 个专栏收录

20 篇文章 0 订阅

订阅专栏

面向对象

8 篇文章 0 订阅

订阅专栏

java进阶

8 篇文章 0 订阅

订阅专栏

1、目标

了解抽象类和普通类的区别

会使用抽象类

会定义抽象方法

会定义接口

会运用接口解决实际问题

2、抽象类和抽象方法

2.1 抽象类

以下是来自菜鸟教程的解释：

如果一个类中没有包含足够的信息来描绘一个具体的对象，那么这样的类就是抽象类

抽象类除了不能被实例化之外，类的其他功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样

由于抽象类不能实例化对象，所以抽象类必须被继承才能被使用。也是由于这个原因，通常在设计阶段决定要不要设计抽象类

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口

个人理解：

抽象是提取出多个事务中的共同的、本质性的特征。

就比如从员工信息上提取出共有的本质的东西（比如员工编号、都有名字、年龄等）

那么抽象类就类似于将这些抽象出来的东西写入一个类中，这样的类我认为就是抽象类。

2.1.1 什么是抽象类

被abstract修饰的类成为抽象类。

语法：

public abstract class 类名{

 }

特点：

1、不能被实例化

2、只能被继承使用

2.2 抽象方法

如果你想设计一个包含特别的成员方法的类，该方法的具体实现由他的子类确定，那么你可以在父类中声明该方法为抽象方法。

2.2.1 什么是抽象方法

被abstract修饰的方法就是抽象方法。

语法：

访问修饰符  abstract  返回值类型  方法名()；

声明抽象方法会造成以下结构：

如果一个类包含抽象方法，那么该类必须是抽象类

任何子类必须重写子类的抽象方法，或者声明自身为抽象类

2.3抽象类与抽象方法的使用

抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类

如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类

没有抽象构造方法，也没有抽象静态方法抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用

3、接口

3.1 什么是接口

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

个人认为与抽象类相似，接口就是放抽象方法的地方，只能放抽象方法，并且接口可以被多个类实现

接口的声明使用interface关键字来声明一个接口

[可见度] interface 接口名称 [extends 其他的接口名] {
        // 声明变量
        // 抽象方法
}

3.2 接口的特性

接口不可以被实例化

实现类必须实现接口的所有方法

实现类可以实现多个接口

implements 多个接口使用逗号隔开

接口中的变量都是静态常量（public static）

接口与类相似点：

一个接口可以有多个方法。
接口文件保存在 .java 结尾的文件中，文件名使用接口名。
接口的字节码文件保存在 .class 结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法，Java 8 之后接口中可以使用 default 关键字修饰的非抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

接口特性

接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

抽象类和接口的区别

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

注：JDK 1.8 以后，接口里可以有静态方法和方法体了。

注：JDK 1.8 以后，接口允许包含具体实现的方法，该方法称为"默认方法"，默认方法使用 default 关键字修饰。更多内容可参考 Java 8 默认方法。

注：JDK 1.9 以后，允许将方法定义为 private，使得某些复用的代码不会把方法暴露出去。更多内容可参考 Java 9 私有接口方法。

3.3如何使用接口，这里用程序描述usb接口

接口表示一种能力：

3.4 接口的实现

当类实现接口的时候，类就要实现接口中的所有方法。否则类必须声明为抽象类。

接口的实现需要使用implements关键字

语法：

...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

接口的继承：

一个接口只能继承另一个接口，和类之间的继承方式比较相似。接口的继承也是使用extends关键字：

子接口继承父接口

3.5面接接口的编程

接口是一种约定：有些接口只有名称

面向接口编程：程序设计时面向接口的约定而不考虑具体实现

3.6 接口使用

接口中的成员变量

默认都是public staticfinal的，必须显示初始化

接口中的方法

默认都是public abstract 的

接口没有构造方法，不能被实例化

一个接口不能实现另一个接口，但可以继承多个其他接口

一个类必须实现接口抽象方法，除非这个类也是抽象类

Java中的接口

属性全都是全局静态常量

方法都是全局抽象方法

无构造方法

一个类可以实现多个接口，非抽象类实现接口时必须实现接口中的全部方法

抽象类利于代码复用，接口利于代码维护

练习

练习一

需求说明原始的手机，可以发短信，通电话。随着发展，手机增加了功能：音频、视频播放、拍照、上网。使用接口实现手机功能

Phone

package exercise01;

public abstract class Phone {
    private String brand;
    private String model;

    public Phone(String brand, String model) {
        this.brand = brand;
        this.model = model;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public abstract void sendMessage();

    public abstract void voice_m();
}

Oldphone

package exercise01;

public class Oldphone extends Phone{
    public Oldphone(String brand, String model) {
        super(brand, model);
    }

    @Override
    public void sendMessage() {
        System.out.println("发送文字消息.....");
    }

    @Override
    public void voice_m() {
        System.out.println("开始语音通话...");
    }

}

Newphone

package exercise01;

public class Newphone extends Phone implements Pfunction{
    public Newphone(String brand, String model) {
        super(brand, model);
    }

    @Override
    public void audio() {
        System.out.println("播放音频《热血》");
    }

    @Override
    public void vedio() {
        System.out.println("播放视频 《小时代》");
    }

    @Override
    public void photo() {
        System.out.println("咔嚓   拍照成功");
    }

    @Override
    public void online() {
        System.out.println("开启网络");
    }

    @Override
    public void sendMessage() {
        System.out.println("发送图片与文字的消息");
    }

    @Override
    public void voice_m() {
        System.out.println("开始视频通话");
    }
}

pfunction

package exercise01;

public interface Pfunction {
    void audio();
    void vedio();

    void photo();
    void online();
}

Test

package exercise01;

public class Test {
    public static void main(String[] args) {
        Oldphone o = new Oldphone("索尼爱立信","G502c");
        Newphone n = new Newphone("I0100","HIC");

        o.sendMessage();
        o.voice_m();


        n.online();
        n.audio();
        n.vedio();
        n.sendMessage();
        n.voice_m();
    }
}

作业

作业一

1.利用接口做参数，写个计算器，能完成加减乘除运算。

（1）定义一个接口Compute含有一个方法int computer(int n, int m)。

（2）设计四个类分别实现此接口，完成加减乘除运算。

（3）设计一个类UseCompute，类中含有方法：public void useCom(Compute com, int one, int two)，

此方法能够用传递过来的对象调用computer方法完成运算，并输出运算的结果。

（4）设计一个主类Test，调用UseCompute中的方法useCom来完成加减乘除运算。

Compute(接口)

package homework01;

public interface Compute {
    int computer(int n,int m);
}

Add （加）

package homework01;

public class Add implements Compute{


    @Override
    public int computer(int n, int m) {
        return n+m;
    }
}

divide （除）

package homework01;

public class divide implements Compute{

    @Override
    public int computer(int n, int m) {
        if (m ==0 ){
            System.out.println("分母不能为0");
            return 0;
        }else {
            return n/m;
        }
    }
}

multiply（乘）

package homework01;

public class multiply implements Compute{

    @Override
    public int computer(int n, int m) {
        return n*m;
    }
}

Subtract（减）

package homework01;

public class Subtract implements Compute{
    @Override
    public int computer(int n, int m) {
        return n-m;
    }
}

UseCompute

package homework01;

public class UseCompute {
    public void useCom(Compute com,int one,int two){
        System.out.println(" " + com.computer(one,two));
    }
}

Test

package homework01;

public class Test {
    public static void main(String[] args) {
        UseCompute u = new UseCompute();
        Add a = new Add();
        divide d = new divide();
        Subtract s = new Subtract();
        multiply m = new multiply();

        u.useCom(m,1,2);
        u.useCom(a,1,2);
        u.useCom(s,1,2);
        u.useCom(d,1,2);


    }
}

作业二

2.InterfaceA和InterfaceB；

在接口InterfaceA中有个方法voidprintCapitalLetter()；

在接口InterfaceB中有个方法void printLowercaseLetter()；

然后写一个类Print实现接口InterfaceA和InterfaceB，

要求printCapitalLetter()方法实现输出大写英文字母表的功能，printLowercaseLetter()方法实现输出小写英文字母表的功能。

再写一个主类E，在主类E的main方法中创建Print的对象并赋值给InterfaceA的变量a，对象a调用printCapitalLetter方法；

最后再在主类E的main方法中创建Print的对象并赋值给InterfaceB的变量b，对象b调用printLowercaseLetter方法

interfaceA

package homework02;

public interface interfaceA {
    void printCCapitalLetter();
}

interfaceB

package homework02;

public interface interfaceB {
    void printLowercaseLetter();
}

package homework02;

public class Print implements interfaceA,interfaceB{


    @Override
    public void printCCapitalLetter() {
        System.out.println("A、B、C、D、E、F、G、H、I、J、K、L、M、N、O、P、Q、R、S、T、U、V、W、X、Y、Z");
    }

    @Override
    public void printLowercaseLetter() {
        System.out.println("a、b、c、d、e、f、g、h、i、j、k、l、m、n、o、p、q、r、s、t、u、v、w、x、y、z");
    }
}

package homework02;

public class E {
    public static void main(String[] args) {
        interfaceA a = new Print();
        interfaceB b = new Print();

        a.printCCapitalLetter();
        b.printLowercaseLetter();

    }
}

作业三

3.中国特色社会主义的体制中有这样的现象：地方省政府要坚持党的领导和按照国务院的指示进行安全生产。请编写一个java应用程序描述上述的体制现象。要求如下：

（1）该应用程序中有一个“党中央”接口：CentralPartyCommittee，该接口中有个“坚持党的领导”方法：void partyLeader()

（2）该应用程序中有一个“国务院”抽象类：StateCouncil，该抽象类中有个“安全生产”的抽象方法：abstract void safetyInProduction()

（3）该应用程序中有一个“省政府”类：Province，该类继承StateCouncil抽象类并且实现CentralPartyCommittee接口；在实现partyLeader()方法时输出“我们各省人民一定坚持党的领导！”；在重写safetyInProduction()方法时输出“我们各省人民一定按照国务院的指示进行安全生产！”。

（4）该应用程序中有一个主类E，在主类E的main方法中创建Province类的对象，来测试Province类的功能。

CentralPartyCommittee

package homework03;

public interface CentralPartyCommittee {
    void partyLeader();

}

StateCouncil

package homework03;

public abstract class StateCouncil{
    abstract void safetyInProduction();
}

Province

package homework03;

public  class Province extends StateCouncil implements CentralPartyCommittee{

    @Override
    public void partyLeader() {
        System.out.println("我们各省人民一定坚持党的领导");
    }

    @Override
    void safetyInProduction() {
        System.out.println("我们各省人民一定按照国务院的指示进行安全生产");
    }
}

package homework03;

public class E {
    public static void main(String[] args) {
        Province p = new Province();
        p.partyLeader();
        p.safetyInProduction();
    }
}

作业四

4.设计一个商品类字段：

商品名称,重量,价格,配件数量,配件制造厂商(是数组,因为可能有多个制造厂商)

要求: 有构造函数

重写 toString 方法

重写 equals方法,进行两件商品的比较

Goods

package homework04;

public class Goods {
    private String name;
    private double weight;
    private double price;
    private int  num;
    private String manu;

    public Goods(String name, double weight, double price, int num, String manu) {
        this.name = name;
        this.weight = weight;
        this.price = price;
        this.num = num;
        this.manu = manu;
    }

    public String toString(){
        return "商品名称：" + name + "重量:" + weight +"价格" + price + "数量：" + num + "制造商" + manu;
    }

    @Override
    public boolean equals(Object obj) {
        Goods goods = null;
        if (obj instanceof Goods){
            Goods g = (Goods) obj;
            if (g.getName().equals(this.getName()) && g.getWeight() == this.getWeight()&&g.getNum() == this.getNum()&&g.getManu().equals(this.getManu())){
                return true;
            }else {
                return false;
            }
        }else{
            return false;
        }
    }
    public String getName() {
        return name;
    }

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

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getManu() {
        return manu;
    }

    public void setManu(String manu) {
        this.manu = manu;
    }
}

Test

package homework04;

public class Test {
    public static void main(String[] args) {
        Goods g1 = new Goods("123",123,123,123,"123");
        Goods g2 = new Goods("456",456,456,456,"456");
        Goods g3 = new Goods("123",123,123,123,"123");

        System.out.println(g3.equals(g1));
        System.out.println(g1.toString());
        System.out.println(g2.toString());
    }
}

作业五

5.自己设计一个接口，设计两个类，实现当前接口，并添加另外一个接口再次实现

interface1

package homework05;

public interface interface1 {
    void introduce();
}

Cla1

package homework05;

public class Cla1 implements interface1{
    @Override
    public void introduce() {
        System.out.println("我是学生");
    }
}

Cla2

package homework05;

public class Cla2 implements interface1{
    @Override
    public void introduce() {
        System.out.println("我是老师");
    }
}

Test

package homework05;

public class Test {
    public static void main(String[] args) {
        interface1 one = new Cla1();
        interface1 two = new Cla2();

        one.introduce();
        two.introduce();
    }
}

masa010

关注

20
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
第六章抽象类和接口

被abstract修饰的类成为抽象类。public abstract class 类名{特点：1、不能被实例化2、只能被继承使用被abstract修饰的方法就是抽象方法。访问修饰符 abstract 返回值类型方法名()；声明抽象方法会造成以下结构：如果一个类包含抽象方法，那么该类必须是抽象类任何子类必须重写子类的抽象方法，或者声明自身为抽象类接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。
复制链接

扫一扫