抽象类和接口（java初识）

于 2024-03-30 15:59:52 发布
阅读量929 收藏 32
点赞数 34
分类专栏： java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhyhgx/article/details/137073949
版权

1.抽象类

1.1抽象类的概念

在面向对象中，所有对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息描绘一个具体的对象，这样的类就是抽象类。

例子：

 说明：Animal类没有办法描述一个具体动物的行为，所以Animal无法具体实现，可以将Animal设置一个抽象类。

我们可以发现，父类Animal中的draw方法并没有什么实际工作，主要工作的是Animal中各种子类的方法来实现。

对于这种没有实际工作的方法，我们可以将其设计为一个抽象方法，包含抽象方法的类我们叫做抽象类。

1.2抽象类语法

在java中，一个类如果被abstract修饰，抽象类中被abstract修饰的方法叫抽象方法，抽象方法不用给出具体的实现体。

注意：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法

1.3特性

1.抽象类不能直接实例化

2.抽象类也可以发生向上转型，动态绑定，多态。

3.抽象方法不能被final和stati修饰，因为抽象方法要被子类重写

4.抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用abstract修饰

5.抽象类不一定要包含抽象方法，但是有抽象方法的类一定是抽象类

6.抽象类中也可以有构造方法，供子类创建对象时，初始化父类的成员变量

抽象类的作用：

使用抽象类相当于多了一重编译器的校验. 使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类 了, 使用普通类编译器是不会报错的. 但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题.

2.接口

2.1接口的概念

接口就是公共的行为规范标准，在实现时，只要符合规范标准，就可以通用。

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

用于描述类具有什么功能，但不给予实现，当某个类要使用接口时，需要重写接口中的方法。

例如：电脑上的USB口上，可以插：U盘、鼠标、键盘...所有符合USB协议的设备

2.2接口的语法规则

1.接口的定义格式与类的定义基本相同，只是将class换成interface关键字

2.格式：interface 接口名｛｝  （注意的是，接口的访问权限修饰符只能是public或者默认）

3.类和接口之间是实现关系，不再是继承，所以要用implements关键字

4.接口的命名一般以大写字母I开头

public interface Running

2.3接口的特点

1.接口成员变量

接口中没有成员变量，只有公有静态常量

在默认情况下，属性前都会有 public  static  final 修饰。

即 public static final  数据类型  常量名  =  值；

在定义时必须初始化，否则报错。对于公有静态常量，初始化的途径有两种：

1.在定义的时候初始化

2.在静态代码块中初速化，但是接口中不允许存在代码块，而且接口没有构造方法。

所以我们在只能在定义时就初始化。

1.2接口中成员方法的特点

接口中方法默认是公有抽象方法，在定义接口时，我们可以直接写返回类型 方法名（参数）

接口中可以有public static 方法（通过接口名引用）和 public default 方法（可重写或者不重写，由对象引用）

2.4多接口

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口

注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。

我们动物为例

先创建个Animal类

public abstract class Animal {
    protected String name;
    protected int age;
    public Animal(String name,int age){
        this.name=name;
        this.age=age;

    }
    public abstract void eat();
}

 有了动物，那么他们的行为有多种，如果我们用继承，只能继承一个，不能多继承。但是对于一种动物，它的行为不止一种，对于猫，它会跑，跳。用继承明显不行，所以我们可以用接口，一个类可以实现多个接口。

跑的接口，游泳接口 飞的接口，跳的接口

public interface IRunning {
    void run();
}

public interface ISwumming {
    void swim();
}

public interface IFly {
     void fly();
}

public interface Ijump {
    void jump();
}

 我们创建具体的动物，如猫，狗。

猫是动物，所以我们需要继承Animal类，再实现跑和跳的接口

public class Cat extends Animal implements IRunning,Ijump{
    public Cat(String name, int age) {
        super(name, age);
    }

    public void eat() {
        System.out.println(this.name+"吃鱼");
    }

    public void run() {
        System.out.println(this.name+"跑");
    }
    public void jump() {
        System.out.println(this.name+"跳");
    }
}

狗

public class Dog extends Animal implements IRunning,ISwumming{
    public Dog(String name, int age) {
        super(name, age);
    }
    public void eat() {
        System.out.println(this.name + "吃骨头");
    }

    public void swim() {
        System.out.println(this.name + "在游泳");
    }

    public void run() {
        System.out.println(this.name + "在跑");
    }

}

我们既然已经创建好猫和狗

那么我们就可以进行创建对象，这里我们创建了两个方法，runc和swim，但是为什么参数不是Dog和Cat呢，这里我们不需要关心对象是谁，只需要知道对象是否具有这个功能。

public class test {
    public static void runc(IRunning irunning){
        irunning.run();
    }
    public static void swim(ISwumming iswumming){
        iswumming.swim();
    }
    public static void main(String[] args) {
    runc(new Dog("旺财",3));
    runc(new Cat("小花",2));
  swim(new Dog("旺财",3));;
    }
}

上面展示了一个类继承一个父类, 同时实现多种接口.

2.5接口继承

类与类之间是单继承的，一个类可以实现多个接口，接口与接口之间也可以多继承。

用接口可以达到多继承的目的。

接口与接口之间用extends关键字，实现复用


interface IA{
    void testa();
}

interface IB{
    void testb();
}

interface IC extends IA,IB{
    void testc();
}
class TC implements IC{
    public void testa()
    {
        System.out.println("testa");
    }
    public void testb()
    {
        System.out.println("testb");
    }
    public void testc()
    {
        System.out.println("testc");
    }
}
public class test{
    public static void main(String[] args) {
        TC tc=new TC();
        tc.testa();
        tc.testb();
        tc.testc();
    }
}

我们可以看到，虽然只implements IC，但是IA,IB的方法我们也要实现。

3.接口的实际使用

3.1给对象数组排序

引用类型不可以用>、=、<比较

对于引用类型，我们可以implements comparable

但是comparable这个接口有局限性

import java.util.Arrays;

class Student implements Comparable<Student>{
    public int age;
    public String name;
    public Student(int age){
        this.age=age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                '}';
    }
//    @Override
//    public int compareTo(Student o) {//通过名字排序
//        if(this.name.compareTo(o.name)>0) {
//            return 1;
//        }else if(this.name.compareTo(o.name)<0) {
//            return -1;
//        }else {
//            return 0;
//        }
//    }

    public int compareTo(Student o) {//通过年龄
        return this.age-o.age;
    }
}

public class tesst {
    public static void bubble_Sort(Student[] arr){
        for (int i=0;i<arr.length-1;i++)
            for (int j=0;j<arr.length-1-i;j++)
                if (arr[j].compareTo(arr[j+1])>0){
                    Student temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
    }
    public static void main(String[] args) {
        Student[]  student=new Student[3];
        student[0]=new Student(8);
        student[1]=new Student(15);
        student[2]=new Student(10);
        Arrays.sort(student);
      //  bubble_Sort(student);
        for (int i=0;i<student.length;i++)
            System.out.println(student[i]);
    }
}

在对对象数组排序的时候，我们需要借助comparable接口，并重写compareTo方法

当然，我们也可以调用sort方法，但是sort方法判断是否排序，也是需要借助compareTo方法

优化：既然comparable有局限性，那么我们可以用Comparator接口，并重写里面的compare方法

只不过我们在使用这个AgeCompare时，需要先new一下它的对象，然后进行使用 

import java.util.Comparator;

class AgeCompare implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age-o2.age;
    }
}
class Student {
    public int age;
    public String name;
    public Student(int age){
        this.age=age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                '}';
    }

}

public class tesst {
    public static void bubble_Sort(Student[] arr) {
        AgeCompare ageCompare = new AgeCompare();
        for (int i = 0; i < arr.length - 1; i++)
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (ageCompare.compare(arr[j], arr[j + 1]) > 0) {
                    Student temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
    }

    public static void main(String[] args) {
        Student[]  student=new Student[3];
        student[0]=new Student(8);
        student[1]=new Student(15);
        student[2]=new Student(10);
      //  Arrays.sort(student);
       bubble_Sort(student);
        for (int i=0;i<student.length;i++)
            System.out.println(student[i]);
    }
}

3.2Clonable接口和浅，深拷贝

  java中内置一些很有用的接口，Clonable就是其中一个。

Objet类中存在一个clone方法，调用这个方法可以创建一个对象的“拷贝”。但是要想合法调用clone方法，我们需要先实现Clonable接口，否则就会抛出CloneNotSupportedException异常。

我们先创建一个学生类并且接入Clonable

lass Student implements Cloneable {
    public int age;
    public String name;

    public Student(int age) {
        this.age = age;
    }


    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                '}';
    }
}

我们需要对Clonable里的方法进行重写，这里我们可以点击鼠标右键，找到Generate，按照图中步骤生成即可。

 

浅拷贝注意事项：

1. 需要接入Clonable接口

2.需要实现clone方法并抛出异常

3.main方法也需要抛出异常

class Student implements Cloneable {
    public int age;
    public String name;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public Student(int age) {
        this.age = age;
    }


    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                '}';
    }
}

public class ttest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student s1=new Student(10);
        Student s2=(Student)s1.clone();
        System.out.println(s1);
        System.out.println(s2);
    }
}

 

 浅拷贝缺点：

浅拷贝也有她的不足之处，在上面的例子中，我们新增个Money类并且也接入Clonable，如果我们只想修改student1的money，就会发现student2的money也发生改变。

class Money implements Cloneable {
    int money=10;
  @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class Student implements Cloneable {
    public int age;
    public String name;
    public Money m=new Money();
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public Student(int age) {
        this.age = age;
    }


    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                '}';
    }
}

public class ttest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student s1=new Student(10);
        Student s2=(Student)s1.clone();
        System.out.println(s1.m.money);
        System.out.println(s2.m.money);
        System.out.println("==========");
        s1.m.money=20;
        System.out.println(s1.m.money);
        System.out.println(s2.m.money);
    }
}

 为什么会这样，这是因为只拷贝了student1，但是内部的Money类并没有拷贝，student2的m还是指向的student1的m。

既然浅拷贝不行，那么我们就得用深拷贝

 深拷贝

对对象的复制，创建一模一样的对象，新的对象不会对被拷贝的对象造成影响。


class Money implements Cloneable {
    int money=10;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class Student implements Cloneable {
    public int age;
    public String name;
    public Money m=new Money();
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Student tmp=(Student) super.clone();
        tmp.m=(Money)this.m.clone();
        return  tmp;
    }

    public Student(int age) {
        this.age = age;
    }


    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                '}';
    }
}

public class ttest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student s1=new Student(10);
        Student s2=(Student)s1.clone();
        System.out.println(s1.m.money);
        System.out.println(s2.m.money);
        System.out.println("==========");
        s1.m.money=20;
        System.out.println(s1.m.money);
        System.out.println(s2.m.money);
    }
}

我们可以看到，改student1的m的值，不会影响到student2的m的值，这就是深拷贝。下面是student的内存分配示意图。 

 

 4.抽象类和接口的区别

 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写)

而接口中 不能包含普通方法, 子类必须重写所有的抽象方法

注意：抽象类存在的意义是为了让编译器更好的校验

看图：

 

zhyhgx
关注
  • 34
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
【Java】抽象类和接口
qq_61635026的博客
06-28 964
在Java中，抽象类是一种特殊的类，用来表示具有一般特征和行为的抽象概念。它不能够直接实例化，而是作为其他类的基类或者父类来使用。抽象类通过在类声明中使用关键字abstract来定义。它可以包含抽象方法和非抽象方法。抽象方法是没有具体实现的方法，只有方法签名，用关键字abstract关键字修饰；非抽象方法则具有具体的实现。抽象类的主要目的是提供一种通用的基类，将相关的子类归类在一起，以便共享通用的属性和行为。它可以定义一些通用方法，供子类继承和实现。
抽象类和接口——Java手把手保姆级教程
最新发布
kk1kk2kk3kk4的博客
12-21 89
在面向对象的概念中，所有的对象都是通过类来描绘的，但是放过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。在Java 中，一个类如果被 修饰的类成为抽象类，抽象类中被 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。抽象类的定义格式如下： 从以上格式可以看出，抽象类的定义比普通类多了抽象方法，类的其他功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。抽象类不能直接实例化对象抽象方法不能是被 修饰的抽象方法不能被 和 修饰，
抽象类与接口详解
weixin_53066120的博客
12-05 8197
抽象类使用 abstract 关键字来进行声明。// ...抽象类可以包含属性、方法和构造函数，但不能被实例化。接口使用 interface 关键字进行声明。在上面的例子中，Shape 接口定义了 calculateArea() 和 calculatePerimeter() 两个抽象方法。
Java抽象类和接口
LEE180501的博客
12-04 3524
本篇文章我们只谈了两件事：抽象类-接口。抽象类和接口是Java中两个非常重要的概念，它们各有独特的优势，共同特点是都很抽象。
JAVA基础-初识JAVA
08-16
3. **接口**：接口在Java中是抽象方法的集合，它可以看作是一种契约，规定了实现该接口的类必须提供哪些方法。接口增强了代码的可扩展性和灵活性。 4. **包**：Java使用包来组织类，它提供了一种命名空间管理机制，...
初识java,用springBoot学习java.zip
06-16
Java的核心特性包括封装、继承、多态和抽象，这些构成了面向对象编程的基础。在Java中，一切皆为对象，类是创建对象的模板，接口定义了一组方法签名，允许类之间实现多态性。异常处理是Java中的一个重要概念，用于...
初识Java_课后补充作业
08-17
8. **接口与抽象类**：理解接口的定义和实现，抽象类的作用，以及两者之间的区别。 9. **多线程**：了解线程的创建方式，同步机制（synchronized关键字、wait()、notify()、notifyAll()），以及线程池的使用。 10....
java中的对象类包和接口PPT教案学习.pptx
09-30
修饰符可以指定类的访问级别，以及是否是抽象类或最终类。例如，`public class MyClass`声明了一个公共的、可被任何其他类访问的类。 4.3.2 类体： 类体包含了类的实现，包括构造方法、成员变量和方法。构造方法是...
Java集合类——前言
01-07
emmmm大致可以看出，上面有三巨头，即Iterator、Collection、Map（虚线框是接口，实线框是类）,Java的集合类主要就是由Collection和Map两个接口派生而出，而Iterator主要起的是遍历器的作用。 先说Collection ...
JAVA抽象类和接口
weixin_64903131的博客
07-15 4657
Java中抽象类和接口的介绍
Java---抽象类和接口
m0_64365419的博客
10-15 5328
抽象类的基本概念和定义以及实例应用；接口的基本概念和作用以及实例应用；接口和抽象类的比较
Java中的抽象类和接口
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
04-15 4万+
各位铁汁们大家好呀！今天让我们继续学习java，看看java中的抽象类和接口到底是什么？ 里面也会讲到多态呀，一起来看看吧😉
Java 抽象类、普通类、接口的区别——值得你一看的干货
热门推荐
csdn_aiyang的博客
05-04 4万+
且不说会有很多人合作一起写一个程序，哪怕还是你一个人写，也保不住有忘记的时候，那时候编译器不报错，茫茫码海上哪找错误去面向对象说到底就是方便你思考，易扩展、易维护管理，硬要说没必要，整个面向对象都没必要了，C语言有什么干不了的呀，运行效率还高。抽象的概念是由具体概念依其“共性”而产生的，把具体概念的诸多个性排出，集中描述其共性，就会产生一个抽象性的概念。所以，在高级语言上，一个类只能继承一个类或抽象类，正如人不可能同时是动物类又是植物类，但是可以实现多个接口，例如，吃饭接口、呼吸接口等。
Java中抽象类实现接口
qq_44887733的博客
05-06 7892
抽象类 Java中的抽象类主要是作为一个公共父类的作用，它可以抽象出用来描述一种类型应该具备的基本特征与功能，具体行为则由子类通过方法重写来完成。 抽象类具有的性质 类定义前需要加上abstract关键字 抽象类中可以没有抽象方法 抽象类中可以有非抽象方法 如果一个类中有至少一个抽象方法，那么它一定是抽象类，则类名前必须加上abstract关键字，抽象方法没有方法体。 抽象类无法实例化 只有覆盖了抽象类中所有的抽象方法后，其子类才可以实例化。如果存留未实现的抽象方法则该子类仍为一个抽象类，无法创建对象。
java提高篇（四）-----抽象类与接口
chenssy 的技术博客
10-18 857
接口和内部类为我们提供了一种将接口与实现分离的更加结构化的方法。 抽象类与接口是java语言中对抽象概念进行定义的两种机制，正是由于他们的存在才赋予java强大的面向对象的能力。他们两者之间对抽象概念的支持有很大的相似，甚至可以互换，但是也有区别。 一、抽象类 我们都知道在面向对象的领域一切都是对象，同时所有的对象都是通过类来描述的，但是并不是所有的类都是来描述对象的。如果...
Java抽象类&接口
yuqu1028的博客
07-23 705
接口的定义，它与定义类方式相似，但是使用interface关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。引用数据类型数组，类，接口。
抽象类和接口的区别
weixin_44181419的博客
11-19 295
参数 抽象类 接口 声明 抽象类使用abstract关键字声明 接口使用interface关键字声明 实现 子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现 子类使用implements关键字来实现接口。它需要提供接口中所有声明的方法的实现 构造器 抽象类可以有构造器 接口不能有构造器 访问修 饰符 抽象类中的方法可以是任意访问修饰符 接口方法默认修.

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zhyhgx

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值