java中的抽象类,final关键字,接口

★夏夜微凉★

已于 2022-08-09 16:15:04 修改

阅读量342

点赞数 1

分类专栏： JavaSE基础部分文章标签： java 经验分享面向对象编程

于 2021-11-25 21:19:18 首次发布

本文链接：https://blog.csdn.net/qq_56501283/article/details/121545342

版权

JavaSE基础部分专栏收录该内容

33 篇文章 0 订阅

订阅专栏

本文详细介绍了Java编程中的抽象类、抽象方法、final关键字以及接口的概念和使用。抽象类用于定义继承层次结构，不能实例化，包含抽象方法；final关键字用于声明不可变的属性和方法，确保类或方法不可被继承或重写；接口则作为类的另一种继承方式，提供多继承功能，强制实现其所有方法。文章通过实例展示了它们在实际开发中的应用和重要性。

摘要由CSDN通过智能技术生成

1.抽象类及抽象方法

1.抽象方法

抽象方法是一种特殊的方法：它只有声明，而没有具体的实现.
抽象方法必须用abstract关键字进行修饰

2.抽象类

如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法。
用abstract修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须定义成抽象类。
特点:
(1)抽象类不能被实例化，但可以有构造方法,因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。
(2) 抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实现其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一样。否则，该类也必须声明为抽象类

public class Test2 {
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.eat();    //调用实现了的抽象方法
        dog.sleep();   //调用普通方法
        System.out.println(dog.num);
    }
}
 abstract class Animal {
    /*如果一个类没有足够的信息来描述一个具体的对象,那么这个类可以定义为抽象类;
      抽象类中可以没有抽象方法,如果包含抽象方法一定要声明成抽象类
      抽象类的其他功能依然存在,成员变量,构造方法,成员方法*/
    int num;
    
    public abstract void eat();//抽象方法没有具体的代码块;
    /*抽象类不能被实例化，但可以有构造方法,因为抽象类中含有无具体实现的方法，
    所以不能用抽象类创建对象。*/
    public Animal(){
        System.out.println("调用了Animal的构造方法");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}
//继承抽象类必须实现抽象类中的所有抽象方法,不然该类也要被定义成抽象类
 class Dog extends Animal{
    /*抽象类，抽象方法，在软件开发过程中都是设计层面的概念。也就是说，
    设计人员会设计出抽象类，抽象方法，程序员都是来继承这些抽象类并
    覆盖抽象方法，实现具体的功能*/
    @Override
    public void eat() {     //实现抽象方法  已实现方法的参数、返回值要和抽象类中的方法一致
        System.out.println("狗在吃");
    }
}

结果如下:
在这里插入图片描述

3.总结

抽象类，抽象方法，在软件开发过程中都是设计层面的概念。也就是说，设计人员会设计出抽象类，抽象方法，程序员都是来继承这些抽象类并覆盖抽象方法，实现具体功能。

2.final关键字

final 用于声明属性，方法和类。

属性:定义就必须直接赋值或者在构造方法中进行赋值，并且后期都不能修改。
方法:子类里不可以重写。
类:不能被定义为抽象类或是接口,不可被继承。

对参数做final修饰。

在方法参数前面加final关键字，为了防止数据在方法体中被修改。

/*
    final 修饰类,属性(成员变量-->常量),方法

    修饰类:不能被其他类继承
    修饰属性:修饰后的属性使用前必须赋值,赋值值不能改变
    修饰方法:修饰的方法不能被重写
 */
//public final class FinlDemo {//修饰类
public  class FinalDemo {

    static final int PI = 3;//修饰属性，直接为常量赋值,建议使用static修饰,这样在内存中就只有一份,所有对象共享
    final int num;//不用static修饰,不需要赋初值,每个对象中都会包含一个常量,在构造方法中初始化


    public FinalDemo(int n) {
        num = n;
    }

    //修饰方法参数,当调用时传入值后,值不能改变
    public final static void  test(final  int a){

    }

    public static void main(String[] args) {
        FinalDemo f1 = new FinalDemo(10);
        FinalDemo f2 = new FinalDemo(20);
        System.out.println(f1.num);
        System.out.println(f2.num);

        test(10);
        test(20);

    }
}

结果如下:
在这里插入图片描述

3.接口

1.生活中的接口

接口泛指实体把自己提供给外界的一种抽象化物（可以为另一实体），用以由内部操作分离出外部沟通方法，使其能被内部修改而不影响外界其他实体与其交互的方式。
在这里插入图片描述

2.接口的概念

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
在这里插入图片描述
认识一下接口(常作为类型使用)
必须知道的接口特性(Java中的多继承)

接口不可以被实例化
实现类必须重写接口的所有方法
实现类可以实现多个接口
接口中的变量都是静态常量

3.面向接口编程

在这里插入图片描述
接口存在的意义:java中一个类只能有一个父类，所以用接口可以实现多继承的逻辑

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现

4.接口的定义与使用

接口的定义：

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

[访问修饰符] interface 接口名称 [extends 其他的接口名1,….其他的接口名n] {
 // 声明常量 抽象方法 静态方法 默认方法

}

public interface MyInterface{
    //接口不能实例化对象，不能有构造方法
    //所以有默认方法，让子类来实例化对象
    //接口可以声明成员变量
    //public static final int num =10;
    //public static final 都默认不写
    public static final int num1 =15;
    int num = 10;

    //接口可以声明抽象方法
    //public 可以默认不写
    public void m1();
    void m2();

    //在JDK8之前，接口只能声明前两种类型，但是在8以后，又多了两种

    //默认方法
    default void m3(){
        System.out.println("默认方法m3");
    }

    //静态方法
    static void m4(){
        System.out.println("静态方法m4");
    }
}

接口的使用：
类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。
[访问修饰符] class 类名 implements 接口名1，接口名2……{ }

//接口可以实现多继承，interface
public interface MyInterfaceA {
}

public interface MyInterfaceB {
}


public interface MyInterface extends MyInterfaceA,MyInterfaceB{
    //接口可以多继承，当一个类实现这个接口时，要重写所有继承接口的抽象方法

    public static final int num1 =15;
    int num = 10;

    //接口可以声明抽象方法
    //public 可以默认不写
    public void m1();
    void m2();

    //默认方法
    default void m3(){
        System.out.println("默认方法m3");
    }

    //静态方法
    static void m4(){
        System.out.println("静态方法m4");
    }
}
//定义类

//实现接口
//因为接口里面有抽象方法，所以
//要么给这个类加abstract使这个类称为抽象类
//要么重写接口里面的所有抽象方法

//public class abstract MyInterfacement implements MyInterface{
public class MyInterfacement implements MyInterface {
    //implements来实现类继承接口
    public void m1(){
        System.out.println("重写后的m1方法");
    }

    public void m2(){
        System.out.println("重写后的m2方法");
    }
    //可以直接用类名调用接口的成员变量
    public static void main(String[] args) {
        System.out.println(MyInterface.num);
        System.out.println(MyInterface.num1);
        //子类来实例化对象，调用父类的方法
        MyInterfacement my = new MyInterfacement();
        my.m1();
        my.m2();
        my.m3();
        MyInterface.m4();//静态的
    }
}