JAVA@13:面向对象(抽象类与接口)

4.3.1抽象类

        在java中:仅声明，不实现（抽象方法定义时，无需实现方法体）,实现由实现类完成

        第一规则：

1.         包含抽象方法的类必须是抽象类；

     2.         声明抽象类和抽象方法都需要abstract关键字修饰(抽象类与抽象方法一样，必须使用abstract 关键字进行修饰)

abstract 返回值类型 方法名称 （参数列表）

     3.        抽象方法只需要声明而不需要是实现。

     4.如果一个非抽象类继承了抽象类之后，那么该类必须重写抽象类的全部抽象方法。否则也必须是抽象类

        抽象类的语法格式 :

abstract class 抽象类名称{
    属性
    访问权限 返回值类型 方法名称(参数){
        return[返回值];           //普通方法
    }
    访问权限 abstract 返回值类型 抽象方法名称(参数);        //抽象方法，无方法体
}

          例子>>>

//定义抽象类animal
abstract class animal{
    //定义抽象方法shout()
    abstract void shout();
}
//定义Dog类继承抽象类animal
class Dog extends animal{
    //重写抽象方法shout（）
    void shout(){
        System.out.println("汪汪汪...");
    }
}
//定义测试类
public class ChouXiang {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.shout();
    }
}

        结果：

注意 ：

        使用abstract关键字修饰的抽象方法不能使用private关键字修饰，因为抽象方法必须被子类实现。

4.3.2接口

        实质：实际上是一种特殊的抽象类

        作用：类只单继承(extends)，接口支持多实现(implements)

        A.接口中的所有方法都是抽象方法，

          接口中所有的方法都是公开公平的（public）

        B.接口使用interface来声明，并非是class。

public class panda extends Anmal implements canshu1,canshu2{}

        C.接口中的变量默认使用public static final 进行修饰，即全局变量；（final关键字修饰的名称都要大写）

        D.接口中的方法默认使用public abstract 进行修饰。（接口中方法的访问权限永远是public）

接口的实现(implements)

        与继承extends非常相似，但是实现implements可以多实现

        接口支持多实现，类实现接口>>>并且重写其所有抽象方法,否则程序编译报错

package com.dzt.java2;

//定义接口 animal
interface animal1{
    int ID = 1;         //定义全局常量，变量
    String NAME = "牧羊犬";    //全局常量，名称
    void shout();           //定义抽象方法 shout（）
    public void info();    //定义抽象方法 info（）
    static int getID(){     //定义静态方法getID（），用于返回ID值
        return animal1.ID;
    }
}
interface Action1{
    public void eat();
}
//定义DOG 类实现animal1接口和Action接口
class DOG1 implements animal1,Action1{   //多实现
    //重写Action1接口中的抽象方法eat()
    public void eat(){
        System.out.println("最喜欢吃骨头");
    }
    //重写animal1接口中的抽象方法shout（）
    @Override
    public void shout() {
        System.out.println("汪汪汪...");
    }
    //重写animal1接口中的抽象方法info（）
    @Override
    public void info() {
        System.out.println("名称："+NAME);
    }

}
//定义测试类
public class JIE_kou {
    public static void main(String[] args) {
        DOG1 xdog = new DOG1();         //创建DOG1类的实例对象
        System.out.println("编号："+animal1.getID());  
        xdog.info();         //调用DOG1类中重写的info()方法
        xdog.shout();    //调用DOG1类中重写的shout方法
        xdog.eat();     //调用DOG1类中重写的eat方法
    }
}

结果：

 即承接又实现的语法格式

修饰符 class 类名 extends 父类名 implements 接口1,接口2,...{}

接口总结

        类继承类

public class A extends B

        接口继承接口(可以多继承，不过里面的抽象方法可以不用重写，抽象方法由实现类来重写)

interface C extends D,E{
    //可以定义抽象方法
    }

        类实现接口

class F impleents C{
    //需要重写抽象类C、D、E中的抽象方法
    }