java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > java抽象类和接口使用

Java中抽象类和接口的使用及区别分析

作者：念越

抽象类中可以包含普通方法和字段,这样的包含普通方法和字段可以被子类直接使用,不用重写,而接口中不能包含普通方法,子类必须重写所有的抽象方法,下面通过本文介绍Java中抽象类和接口的使用,感兴趣的朋友一起看看吧

一、 抽象类

1、概念

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

1.这里Animal类是动物类，每个动物都有自己的叫法，但这里Animal不是一个具体的动物，里面的bark()方法无法具体实现。
2.Dog是狗类属于动物，与Animal类是继承关系，狗是一种具体的动物，所以里面的bark()方法可以被具体实现。
3.Cat是猫类属于动物，与Animal类是继承关系，猫是一种具体的动物，所以里面的bark()方法可以被具体实现。
4.因此，这里的Animal类可以设计为抽象类。

2、抽象类语法

在Java中，一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。抽象类也是类，内部可以包含普通方法和属性，甚至构造方法。
举个例子：

//抽象类
public abstract class Animal {
    public int age;
    abstract public void eat();  //抽象方法
    public Animal(int a) {
        this.age = a;
    }
}

3、抽象类的特性

3.1抽象类不能直接实例化对象

Animal抽象类

public abstract class Animal {
    public int age;
    abstract public void eat();  //抽象方法
    public Animal(int a) {
        this.age = a;
    }
}

Dog类继承Animal抽象类

public class Dog extends Animal{
    public void eat() {
        System.out.println("汪汪叫...");
    }
    public void sleep(){
        System.out.println("小狗正在睡觉....");
    }
    public Dog(int age){
        super(age);
    }
}

Test测试类

public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal();  //error
    }
}

这里实例化Animal抽象类，编译器报错。

3.2抽象方法不能是private

public abstract class Animal {
    public int age;
    abstract private void bark(); //error,抽象方法不能是私有的
    abstract public void eat();  //抽象方法
}

3.3抽象方法不能被final和static修饰，因为抽象方法要被子类重写

public abstract class Animal {
    public int age;
    abstract final public void eat(); //error
    abstract public static void bark();//error
}

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

Animal抽象类

public abstract class Animal {
    public int age;
    abstract public void eat();  //抽象方法
    public Animal(int a) {
        this.age = a;
    }
}

Dog类继承Animal抽象类

public class Dog extends Animal{
    public void eat() {
        System.out.println("汪汪叫...");
    }
    public void sleep(){
        System.out.println("小狗正在睡觉....");
    }
    public Dog(int age){
        super(age);
    }
}

这里Dog类继承了Animal抽象类，并且Dog类重写了Animal抽象类中的eat()抽象方法。

3.5抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类

public abstract class Animal {
    public int age;
    public Animal(int a) {
        this.age = a;
    }
}

这里Animal是抽象类，但里面没有包含抽象方法，是可以正常编译的。

public class Dog extends Animal{    //error
    abstract public void sleep(){
        System.out.println("小狗正在睡觉....");
    }
    public void eat() {
        System.out.println("汪汪叫...");
    }
    public Dog(int age){
        super(age);
    }
}

这里Dog类不是抽象类，如果里面写了抽象方法，则编译器会报错。

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

这里上面的代码中已经体现到了。

4、 抽象类的作用

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

二、接口

1、概念

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

2、接口的语法和使用

1.接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。

public interface 接口名称{
//抽象方法
void method();
}

2.接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法。

public class 类名 implements 接口名称{
}

3.注意事项
子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。

3、接口的特性

1.接口中的成员变量默认是public static final修饰的。

2.接口中的抽象方法，默认都是public abstract修饰的。
举个例子：Ishape接口

public interface IShape { 
    int c = 20; //成员变量默认是public static final 修饰的
    void draw(); //默认是abstract修饰的
}

3.如果接口当中的方法被default或者static修饰，那么可以有具体实现。

public interface IShape {
     default void test(){
         System.out.println("default.....");
     }
     static void test1(){
       System.out.println("static.....");
}

4.接口不可以进行实例化。
5.类和接口之间可以使用关键字implements实现接口。
举个例子：
IShape接口

public interface IShape { 
    void draw(); //默认是abstract修饰的
}

Cycle类

public class Cycle implements IShape{
    @Override
    public void draw() {
        System.out.println("画一个圆圈.....");//必须实现接口当中的抽象方法
    }
}

6.一个接口对应一个字节码文件。
7.重写接口中方法时，不能使用默认的访问权限。（子类的重写方法权限要大于等于父类）
8.接口中不能有静态代码块和构造方法。
9.如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类。

4、一个类实现多个接口

接下来我会通过代码来阐述一个类实现多个接口
举个例子
Animal抽象类

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

IRunning 接口

public interface IRunning {
    void run();
}

ISwimming 接口

public interface ISwimming {
    void swim();
}

Frog类继承Animal抽象类并实现了IRunning,ISwimming两个接口

public class Frog extends Animal implements IRunning,ISwimming{
    public Frog(String name, int age) {
        super(name, age);
    }
     public void sleep(){
         System.out.println(this.name+"正在睡觉...");
     }
    @Override
    public void eat() {
        System.out.println(this.name+"正在吃虫子...");
    }
    @Override
    public void run() {
        System.out.println(this.name+"正在跑步..");
    }
    @Override
    public void swim() {
        System.out.println(this.name+"会游泳.....");
    }
}

Test测试类

public class Test {
    public static void swimming(ISwimming iSwimming){
        iSwimming.swim();
    }
    public static void running(IRunning iRunning){
        iRunning.run();
    }
    public static void main(String[] args) {
        swimming(new Frog("小蛙",1));
        running((new Frog("小绿",2)));
    }

打印结果

上述代码：一个Frog类实现了IRunning,ISwimming两个接口，从而阐述了一个类可以实现多个接口。

三、抽象类和接口的区别

抽象类中可以包含普通方法和字段，这样的包含普通方法和字段可以被子类直接使用，不用重写。而接口中不能包含普通方法，子类必须重写所有的抽象方法。

到此这篇关于Java中抽象类和接口的使用及区别分析的文章就介绍到这了,更多相关java抽象类和接口使用内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文