javaSE10--final关键字-抽象类-接口-抽象类接口区别

原创

靠谱的大钊 2022-10-28 12:23:22 博主文章分类：javaSE ©著作权

文章标签 抽象类 java 接口多态类 文章分类 OpenStack 云计算

©著作权归作者所有：来自51CTO博客作者靠谱的大钊的原创作品，请联系作者获取转载授权，否则将追究法律责任

final关键字

final用于声明属性,方法和类,可以修饰类,修饰字段,修饰方法,修饰局部变量,修饰形参
属性:定义就必须直接赋值或者在构造方法中进行赋值,并且后期不能修改,
修饰修饰类,最终类,不能被继承,不能被定义为抽象类或者接口
修饰字段,必须显示初始化,不能被修改,一般final与static同时修饰某个字段,所有字母都大写,表示final常量
修饰方法:bueng子类不能被覆盖能被子类继承
修饰局部变量, 一旦初始化就不能再修改, 注意final修饰引用类型变量, 是指这个引用类型变量不能再指向其他对象,可以修饰它的属性值
修饰方法形参, 在方法体中不能修改final形参的值

final属性赋值:

–在声明时同时赋值,往往与static一起使用

final static int Num = 10;

package com.nie.day5.demo06;

public class Filal {
    //用于声明方法和类
    //final修饰常量,常量值不能变,利用static 修饰 节省空间
    final static int Num = 10;
    final int a = 100;


    public final void eat() {
        System.out.println("你好");
    }

    //定义就必须直接赋值或者在构造方法中进行中进行赋值,后期不能修改
    public void num(int a) {
//       this.a=1000;
        System.out.println(a);
    }


    //在方法参数前加final关键字,防止数据在方法题中被修改.
    public void num1(final int b) {
//        b=11;
    }
}

抽象类

为什么定义抽象类?

如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类
抽象类除了不能实例化对象之外,类的其他功能依然存在,名成变量,成员方法和构造方法的访问方式和普通类一样.

如何定义抽象类

用abstract修饰的类就是抽象类,如果某个类中包含抽象方法,那么这个类就必须定义抽象类.

为什么定义抽象方法:

当一个类的某个操作无法具体实现时,这个操作可以定义为抽象方法,使用abstract修饰方法, 只有方法的声明, 没有方法体

抽象方法时一种特殊的方法:他只有声明,而没有具体的实现
抽象方法必须用abstract关键字进行修饰

如何使用抽象类

抽象类一般作为其他类的父类存在,
子类继承了抽象类,子类需要重写抽象类中所有的抽象方法,如果没有重写所有的抽象方法子类也需要为定义抽象方法

注意:

抽象类中不一定含有抽象方法

抽象类可以有成员属性和非抽象方法
抽象类不能被实例化,但可以有构造函数.因为抽象类中含有无具体实现的方法,所以不能用抽象类创建对象
抽象类不能创建对象:抽象类只能做基类,表示一种继承关系.
构造方法和静态方法不可以用abstract,

abstract与final不共存

因为abstract不能实例bai化（没有构造方法），du需要有子类zhi来实现，而final为“最终的”，修饰类时表示不能被继承既没有子类，这两个就矛盾了。
但是呢，一个abstract类里面可以有final关键字存在，前提是这个final修饰的方法必须在abstract类中已经实现，作用是继承它的子类不能重写这个方法

[访问权限] abstract class 类名 {
    成员列表
  }

public abstract class Shapes {
  public abstract void draw();
}

public abstract class Shapes {
  public void draw(){
         //具体代码
       }
}

然后我们定义个抽象类

javaSE10--final关键字-抽象类-接口-抽象类接口区别_抽象类

抽象类无法被直接实例化，我们可以让子类继承然后实例化子类

javaSE10--final关键字-抽象类-接口-抽象类接口区别_多态_02

然后我们实例化子类

javaSE10--final关键字-抽象类-接口-抽象类接口区别_类_03

接口

接口的基本概念:

Java中只支单继承,如果向定义一些功能,想让一个子类都能继承实现,提供接口,这样我们就可以用一个子类去实现多个接口.**.可以理解为接口时特殊的抽象类.**这种抽象类中只包含常量和方法的定义,没有变量和方法的实现.

接口设计时候:关系实现类有何做哟个,不关心内部细节,面向接口的约定而不考虑接口的具体实现.

接口的定义:

public interface Animal1 {
    //所有属性默认为: public static final
    void eat1();

    //所有方法都是：public abstract
    void foo();
}

定义接口: interface

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

接口使用 :implements

[访问修饰符] class 类名 implements 接口名1，接口名2……{ }

结合继承：

[访问修饰符] class 类名 extends 父类名 implements 接口名1，接口名2……{ }

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

接口一

/**
 * 本质上说接口就是一个抽象类,
 * 抽象类中只包含常量和方法的定义,
 * 没有变量和方法的实现
 */
public interface animal extends Animal1 {
    //所有属性默认为 public static final
    // public static final int age=10;
    //变量必须赋值
    int age = 10;

    //默认的为public  abstract
    //抽象方法访问时必须进行重写
    void eat();

    public abstract void test();

    //jdk8后接口可以使用默认方法,和静态方法
    //比抽象方法更加灵活,根据功能方法进行选择
    public default void test1() {  //被子类重写
        System.out.println("默认方法");
    }

    public static void test2() {//通过类名访问4
        System.out.println("静态方法");
    }
}

接口二

public interface Animal1 {
    //所有属性默认为: public static final
    void eat1();

    //所有方法都是：public abstract
    void foo();
}

接口三

public interface Animal2 {
    void  test3();
}

类

//定义为抽象类  或者
//重写抽象方法

/**
 * 一个类可以实现多个接口,
 * <p>
 * 一个类可以实现继承一个类
 * 但是可以实现多个接口
 */
public class Dog implements animal, Animal1, Animal2 {

    //抽象方法访问时必须进行重写
    @Override
    public void eat() {
        System.out.println("抽象方法\t吃");
    }

    @Override
    public void test() {
        System.out.println("抽象方法测试");
    }

    @Override
    public void eat1() {
    }

    @Override
    public void foo() {
    }

    @Override
    public void test3() {
    }
}

测试

public class Test {
    public static void main(String[] args) {
        Dog dog =new Dog();
        dog.eat();
        dog.test();
        dog.test1();//默认方法//
        animal.test2();//静态方法
    }
}

接口的特性:

接口是特殊的抽象类,当声明一个接口的时候必须要声明abstract关键字
接口中每一个方法也是隐式抽象的,默认public abstract 。jdk8以后有默认和静态方法 public static 方法, public default方法
接口中声明的属性默认为 public static final
接口不能被继承,要被实现implements
接口不能实例化对象(灭有构造方法),但是可以声明对象的引用(多态性)
有接口多有多态。多态的条件（子类重写父类方法，继承，父类引用指向子类对象）因为接口中有抽象方法，所以必须要重写，实现（implements）可以理解为在接口环境下继承（extends）的另一个名字
多个类可以使用一个接口
一个类可以实现多个接口,但只能继承一个类
一个类可以继承多个接口,使用关键字extends，可以继承多个接口，使用逗号分割
在类实现接口的时候,类要实现接口的所有方法,或者类必须设置为抽象类
接口体现的是is-a的关系