抽象类和接口

最新推荐文章于 2023-11-21 20:14:40 发布
最新推荐文章于 2023-11-21 20:14:40 发布
阅读量5.5k 收藏 85
点赞数 38
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62712350/article/details/126319408
版权

目录

抽象类

抽象类使用abstract修饰类

抽象类当中可以包含普通类所能包含的成员

抽象类和普通类不一样的是，抽象类当中可以包含抽象方法。

抽象类方法是使用abstract修饰的，这个方法没有具体的实现

不能实例化抽象类

抽象类存在的意义是为了被继承

抽象类的方法不能是私有的（private）,要满足重写的规则。

抽象类当中可以有构造方法，为了方便子类能够调用，来初始化抽象类当中的成员

接口

1.使用interface来修饰接口

2.接口当中的成员方法不能有具体的实现。

 在接口中抽象方法默认是public abstract的方法

接口不可以被实例化，也就是说接口不能有静态代码块和构造方法

可以通过implements实现接口，接口里面的抽象方法必须重写，默认方法可重写也可以不重写，静态方法不能被重写。

接口的使用

实现多个接口

 抽象类和接口的区别：

Object类

toString

equals

抽象类

抽象类使用abstract修饰类

抽象类当中可以包含普通类所能包含的成员

抽象类和普通类不一样的是，抽象类当中可以包含抽象方法。

抽象类方法是使用abstract修饰的，这个方法没有具体的实现

abstract class Shape{
    public int a;
    public abstract void draw();
    public void func(){

    }
}

不能实例化抽象类

public class Test {
    public static void main(String[] args) {
        Shape shape = new Shape();//报错
    }
}

抽象类存在的意义是为了被继承

如果一个普通类继承了抽象类，此时必须重写抽象类中的方法。

class Rect extends Shape{
    @Override
    public void draw() {
        System.out.println("矩形");
    }
}

一个抽象类A继承一个抽象类B，此时不需要重写B中的抽象方法，但当A被继承时，还是要重写B中的抽象方法。

抽象类的方法不能是私有的（private）,要满足重写的规则。

抽象类当中可以有构造方法，为了方便子类能够调用，来初始化抽象类当中的成员

接口

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

1.使用interface来修饰接口

2.接口当中的成员方法不能有具体的实现。

interface IShape {
    public abstract void func1();
    public void func2(){
        //报错
    }
}

 在接口中抽象方法默认是public abstract的方法

从JDK1.8开始，允许有方法的实现，但是这个方法必须是有default修饰的

可以实现有静态方法

成员变量默认是public static final修饰的，子类如果重写抽象方法必须由public修饰

interface IShape {
    public static final int a = 10;
    int b = 20;//默认也是public static final修饰的
    public abstract void func1();
    void func();//默认也是public abstract修饰的
    public void func2(){
        //报错
    }
    default public void func3(){
        System.out.println("默认方法");
    }
    public static void func4(){
        System.out.println("static修饰的方法");
    }
}

接口不可以被实例化，也就是说接口不能有静态代码块和构造方法

 public static void main(String[] args) {
        IShape ishape = new IShape();//报错
    }

可以通过implements实现接口，接口里面的抽象方法必须重写，默认方法可重写也可以不重写，静态方法不能被重写。

class A implements IShape{
    public void func1(){
        System.out.println("重写抽象方法");
    }
}

接口的使用

请实现笔记本电脑使用 USB 鼠标、 USB 键盘的例子
1. USB 接口：包含打开设备、关闭设备功能 
//USB接口
public interface USB {
    void openDevice();
    void closeDevice();
}
2. 鼠标类：实现 USB 接口，并具备点击功能 
public class Mouse implements USB{
    @Override
    public void openDevice() {
        System.out.println("打开鼠标");
    }
    @Override
    public void closeDevice(){
        System.out.println("关闭鼠标");
    }
    public void click(){
        System.out.println("鼠标点击");
    }
}

3. 键盘类：实现USB接口，并具备输入功能 

public class KeyBoard implements USB {
    @Override
    public void openDevice() {
        System.out.println("打开键盘");
    }
    @Override
    public void closeDevice() {
        System.out.println("关闭键盘");
    }
    public void inPut(){
        System.out.println("键盘输入");
    }
}

4. 笔记本类：包含开机功能、关机功能、使用 USB 设备功能 
public class Computer{
    public void powerOn(){
        System.out.println("打开笔记本电脑");
    }
    public void powerOff(){
        System.out.println("关闭笔记本电脑");
    }
    public void useDevice(USB usb){
        usb.openDevice();
        if(usb instanceof Mouse){
            Mouse mouse = (Mouse) usb;
            mouse.click();
        }
        if(usb instanceof KeyBoard){
            KeyBoard keyboard = (KeyBoard) usb;
            keyboard.inPut();
        }
        usb.closeDevice();
    }
}

测试：

//测试
public class TestUsb {
    public static void main(String[] args){
        Computer computer = new Computer();
        computer.powerOn();
        computer.useDevice(new Mouse());
        computer.useDevice(new KeyBoard());
        computer.powerOff();
    }
}

实现多个接口

一个类可以实现多个接口，使用implements 用逗号隔开。（可以解决多继承的问题） 
interface  A{
    void func1();
}
interface B{
    void func2();
}
class C implements A,B{
    @Override
    public void func1() {
        System.out.println(1);
    }

    @Override
    public void func2() {
        System.out.println(2);
    }
}

接口实现多继承和多态简单实例

class Animal{
    public String name;
    public int age;
    public Animal(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println("吃饭");
    }
}
interface IRuning{
    void runing();
}
interface ISwimming{
    void swimming();
}
interface IFly{
    void fly();
}
class Dog extends Animal implements IRuning,ISwimming{
    public Dog(String name,int age){
        super(name,age);
    }
    @Override
    public void runing() {
        System.out.println(name+"正在跑");
    }

    @Override
    public void swimming() {
        System.out.println(name+"正在游泳");
    }
}
class Duck extends Animal implements IRuning,ISwimming,IFly{
    public Duck(String name,int age){
        super(name,age);
    }
    @Override
    public void runing() {
        System.out.println(name+"正在跑");
    }

    @Override
    public void swimming() {
        System.out.println(name+"正在游泳");
    }

    @Override
    public void fly() {
        System.out.println(name+"正在飞");
    }
}
public class Test {
    public static void walk(IRuning iruning){
        iruning.runing();//多态
    }

    public static void main(String[] args) {
        walk(new Dog("小黑",2));
        walk(new Duck("可达鸭",3));
    }
}

 继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性

有了接口之后 , 类的使用者就不必关注具体类型 , 而只关注某个类是否具备某种能力 
class Robot implements IRuning{

    @Override
    public void runing() {
        System.out.println("机器人正在跑步");
    }
}
public class Test {
    public static void walk(IRuning iruning){
        iruning.runing();
    }

    public static void main(String[] args) {
        walk(new Dog("小黑",2));
        walk(new Duck("可达鸭",3));
        walk(new Robot());
    }
}

机器人不是动物，但仍然可以实现多态，因为接口只关注某个类是否具有某种能力。机器人有跑步的能力，那他就可以实现。

 抽象类和接口的区别：

抽象类可以包含普通字段和成员，接口中不能包含普通方法，子类必须重写所有的抽象方法

抽象方法由普通类（普通字段和方法）和抽象方法组成

接口由抽象方法和全局常量组成

使用extends继承抽象类，使用implements关键字实现接口

一个抽象类可以实现若干个接口，接口不能继承抽象类，接口可以使用extends继承多个父类接口

一个子类只能继承一个抽象类，一个子类可以实现多个接口

Object类

Object类是所以类的父类，我们自己写的类就算没有写extends Object，默认也是继承的

class Teacher{

}
class Student{

}
public class Test2 {
    public static void func(Object object){
        
    }

    public static void main(String[] args) {
        func(new Student());//向上转型，不报错
        func(new Teacher());
    }
}

Object类当中的一些方法：

toString

输出对象的名称,和@符号后面跟一串16进制数字，该数字是由hashCode这个方法产生的 

equals

在 Java 中， == 进行比较时：
如果==左右两侧是基本类型变量，比较的是变量中值是否相同
如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同
如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的
Object类中的equals方法

 可见Object类中的equals是使用引用中的地址来进行比较的

class Person{
    String name;
    int age;
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
}
public class Test3 {
    public static void main(String[] args) {
        Person per1 = new Person("zhangsan",20);
        Person per2 = new Person("zhangsan",20);
        int a = 10;
        int b = 10;
        System.out.println(a==b);
        System.out.println(per1==per2);
        System.out.println(per1.equals(per2));
    }
}

Person类重写equals方法：

class Person{
    String name;
    int age;
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if(obj==null){
            return false;
        }
        if(this == obj){
            return true;
        }
        if(!(obj instanceof Person)){
            return false;
        }
        Person per = (Person) obj;
        if(this.name.equals(per.name) && this.age == per.age){
            return true;
        }else{
            return false;
        }
    }
}
public class Test3 {
    public static void main(String[] args) {
        Person per1 = new Person("zhangsan",20);
        Person per2 = new Person("zhangsan",20);
        int a = 10;
        int b = 10;
        System.out.println(a==b);
        System.out.println(per1==per2);
        System.out.println(per1.equals(per2));
    }
}

白杨783
关注
  • 38
    点赞
  • 踩
  • 85
    收藏
    觉得还不错? 一键收藏
  • 40
    评论
详细解答Java中抽象类和接口的区别问题！
gg7894125的博客
08-25 714
接口(Interface)和抽象类(Abstract Class)是支持抽象类定义的两种机制。 一、抽象类 在Java中被abstract关键字修饰的类称为抽象类，被abstract关键字修饰的方法称为抽象方法，抽象方法只有方法的声明，没有方法体。抽象类是用来捕捉子类的通用特性的 。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。 以JDK中的GenericServlet为例： 复制代码 public abstract class GenericServlet implemen
深入理解Java的接口和抽象类
12-22
对于面向对象编程来说，抽象是它的一大特征之一。在Java中，可以通过两种形式来体现OOP的抽象：接口和抽象类。这两者有太多相似的地方，又有太多不同的地方。很多人在初学的时候会以为它们可以随意互换使用，但是实际则不然。我们一起来学习一下Java中的接口和抽象类。 　　一.抽象类 　　在了解抽象类之前，先来了解一下抽象方法。抽象方法是一种特殊的方法：它只有声明，而没有具体的实现。抽象方法的声明格式为： 　　abstract void fun(); 　　抽象方法必须用abstract关键字进行修饰。如果一个类含有抽象方法，则称这个类为抽象类，抽象类必须在类前用abstract关键字修饰。因为
1.5：接口和抽象类的区别.pdf
08-20
1. 小结 1.abstract class 在c#语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。 2.在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在 interface中一般不定义数据成员），所有的成员方法都是abstract的。 3.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。 4.实现抽象类和接口的类必须实现其中的所有方法。 抽象类中可以有非抽象方法。接口中则不能有实现方法。如果接口或者抽象类的子类不想实现则继续携程一个抽象方法 5.接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。 6.抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。 7.接口中的方法默认都是 public,abstract 类型的。
Java接口和抽象类原理详解
08-25
主要介绍了Java接口和抽象类原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
抽象(Abstract)类与接口(interface)
Tweek_的博客
03-29 1362
JAVA的抽象类与接口
Java中的抽象类和接口
最新发布
m0_63562631的博客
11-21 331
首先,我们的代码,先是将student1引用指向的对象拷贝一份,student2这个引用指向了这个拷贝的对象,但是在new Student()对象中,我们还有一个m引用指向的对象没有被拷贝,此时,m引用在student2这个引用指向的对象中,m引用里面的地址值没有改变,所以对student1引用指向的对象中的money属性改动,student2中的也没有变.这种。默认会继承Object父类。接口其实就是一种公共的行为规范标准,可以算抽象类的进一步抽象,大家在实现时,只要符合这个标准的,就都可以用这个接口.
Java基础篇：抽象类与接口
张维鹏的博客
09-27 1万+
（1）抽象类和接口都用于抽象化具体对象的，都不能直接实例化，但是两者的侧重点不同：抽象类主要用来抽象类型，表示这个对象是什么；接口主要用来抽象功能，表示这个对象能做什么； （2）接口可以看成抽象类的变体，所有方法都是抽象的，因此接口只能做方法的声明，不能有方法的实现；而抽象类可以有默认的方法实现，既可以做方法的声明，也可以做方法的实现；
C++中抽象类和接口的区别介绍
09-05
在面向对象编程中，抽象类和接口是两种重要的设计机制，它们都用于定义类的蓝图，但有着不同的设计理念和用途。下面将详细解释这两种概念及其区别。 首先，抽象类（Abstract Class）是一种不能被实例化的类，它通常...
抽象类和接口实验报告.doc
12-11
抽象类和接口实验报告
PHP抽象类和接口用法实例详解
01-03
本文实例讲述了PHP抽象类和接口用法。分享给大家供大家参考，具体如下： 前言 对于oop，估计大多数人并不陌生。有些人除PHP外也学习不少其他语言，会发现php的不同之处，可能语法极其丑陋，但并不妨碍它成为世界上...
c#中抽象类和接口的详细介绍
09-04
C#中的抽象类和接口 在C#中，抽象类和接口是两种不同的编程概念，它们都可以用来定义一个类的行为和结构，但它们之间有着明显的区别。 一、抽象类 抽象类是特殊的类，它不能被实例化，但它可以包含抽象方法和普通...
接口和抽象类的区别
热门推荐
奋斗男孩的博客
11-25 1万+
不同点： 1、接口只能定义抽象方法不能实现方法，抽象类既可以定义抽象方法，也可以实现方法。 2、单继承，多实现。接口可以实现多个，只能继承一个抽象类。 3、接口强调的是功能，具有什么能力。抽象类强调的是所属关系。4、接口中的所有成员变量 为public static final（默认，变量也是属于全局变量）， 静态不可修改，当然必须初始化。接口中的所有方法都是public abstract 公开抽象的（public可不写）。而且不能有构造方法。抽象类就比较自由了，和普通的类差不多，可以有抽象方法也可以没有，
dart 接口和抽象类
06-13
在 Dart 中，接口和抽象类都可以用来定义抽象类型，即没有实现的类。它们有一些相似之处，但也有一些不同之处。 接口和抽象类的相似之处： - 都可以用来定义抽象类型。 - 都不能被实例化。 - 都可以被实现或继承。 接口和抽象类的不同之处： - 接口只能定义方法，而抽象类既可以定义方法，也可以定义字段和构造函数。 - 类可以实现多个接口，但只能继承一个抽象类。 - 接口中的所有方法都是抽象的，而抽象类可以包含非抽象方法。 下面是一个简单的示例，展示了如何声明接口和抽象类： ``` // 定义一个接口 abstract class MyInterface { void doSomething(); } // 定义一个抽象类 abstract class MyAbstractClass { void doSomething(); void doSomethingElse() { // 非抽象方法 } } // 实现接口 class MyClass implements MyInterface { @override void doSomething() { // 实现 MyInterface 的 doSomething 方法 } } // 继承抽象类 class MyChildClass extends MyAbstractClass { @override void doSomething() { // 实现 MyAbstractClass 的 doSomething 方法 } } ``` 在上面的示例中，`MyInterface` 和 `MyAbstractClass` 都是抽象类型。`MyClass` 实现了 `MyInterface` 接口，`MyChildClass` 继承了 `MyAbstractClass` 抽象类并实现了 `doSomething` 方法。请注意，`MyAbstractClass` 中还包含一个非抽象方法 `doSomethingElse`。
评论 40
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值