JavaSE——面向对象（五）（抽象类，接口）

1.抽象类

（1） 概述

• 我们在前面学习猫狗案例当中，发现猫和狗都继承动物这个类，我们对动物这个类也创建了对象，其实这是不对的，因为动物也是一个抽象的概念，你根本不知道是那种动物。所以前面我们给动物写的方法是不合理的，每个动物都有不同的行为。所以我们不应该在动物类中给出一个具体的实现，只需要给出一个方法声明即可。
• 在Java中，我们对于一个没有方法体的方法应该被定义为抽象方法，同时该类也被定义为抽象类。

（2）特点

• 抽象类：abstract class Animal{}
  抽象方法：public abstract void eat（）
• 抽象类不一定有抽象方法，但有抽象方法的一定是抽象方法。
• 抽象类不能被实例化，但抽象类中却还有构造方法。因为这个构造方法是用来子类完成对抽象类初始化数据的用的。
• 抽象类的子类：抽象类的子类要么是抽象类，要么重写抽象类中所有的抽象方法。
• 举例

//具体事物：基础班老师，就业班老师
 //	共性：姓名，年龄，讲课。
 package com.westmo.demo1;
public class MyTest4 {
    public static void main(String[] args) {
        Teacher teacher= new jiuyeTeacher();
        System.out.println(teacher.name = "小李");
        System.out.println(teacher.age = 10);
        teacher.teach();
        jichuTeacher jichuTeacher = new jichuTeacher();
        jichuTeacher.teach();
    }
}
abstract class Teacher{
    String name;
    int age;
    public abstract void teach();
}
class jiuyeTeacher extends Teacher{
    public void teach(){
        System.out.println("讲就业课");
    }
}
class jichuTeacher extends Teacher{
    public void teach(){
        System.out.println("讲基础课");
    }
}

(3)抽象类中的面试题

• 一个没有抽象方法的类可不可以被定义为抽象类，有什么意义？
  答：可以，意义就是这个不能被实例化
• 抽象类不能和那些关键字共存？
  答：private（修饰的方法不能被继承）
  final（修饰的方法不能被重写）
  static（无意义）

2.接口

（1）概述

由前面的猫狗案例中，我们知道狗一般是看门的，可是有的狗却能搜寻猎物，而这些行为并不是它一开始就具备的，是后天训练出来的。我们对于这些额外的动作Java中就提供了接口来定义，并不给出具体的实现，将来那些对象需要这些额外的功能时，就只需要实现接口中的定义（重写）即可。

（2）特点

• 创建：interface 接口名{}
  实现：class 类名 implements 接口名{}
• 接口的子类可以是抽象类（没意义），也可以是具体类，但是该具体类必须要重写接口中所有的抽象方法。

（3）接口成员特点

• 成员变量： 都是静态常量，前面有默认修饰符public static final可以省略不写。
• 成员方法：都是抽象方法，前面有默认修饰符public abstract可以省略不写。
• 构造方法：没有构造方法

package com.westmo.demo1;
public class MyTest5 {
    public static void main(String[] args) {
        Test test = new Test();
        test.show();
        System.out.println(test.age);
        //多态进行访问
//        Interface1 In1 =new Test(); 
//        System.out.println(In1.age);
//        In1.show();
    }
}
interface Interface1{
    int age=10;
    void show();
}
class Test implements Interface1{
    @Override
    public void show() {
        System.out.println("你好");
    }
}

（4）类与类，类与接口，接口与接口的关系

• 类与类
  继承关系，只能单继承，也可以多层继承
• 类与接口
  实现关系，既能单实现也能多实现（一个类实现多个接口）
• 接口与接口
  继承关系，可以单继承，也可以多继承

//举例：类与类前面有，这里就不测试了
package com.westmo.demo1;
public class  MyTest6  {
    public static void main(String[] args) {
    }
}
interface jiekou1{
    public abstract void eat();
}
interface  jiekou2{
    public abstract void play();
}
interface jiekou3 extends jiekou1{
}
interface jiekou4 extends jiekou1,jiekou2,jiekou3{//接口与接口多继承
}
class Test1 implements jiekou1,jiekou2,jiekou3{//一个类实现多个接口
    @Override
    public void eat() { }
    @Override
    public void play() { }
}

实例

动物类：姓名，年龄，吃饭，睡觉。
动物培训接口：跳高
狗继承动物类
部分狗继承狗类并实现跳高接口
通过抽象类测试基本功能。
通过接口测试扩展功能。

package com.westmo.demo1.demo2;

public class MyTest {
    public static void main(String[] args) {
        Interface In1=new wangcaiDog();
        //wangcaiDog wangcaidog = new wangcaiDog();
        In1.jump();
        Animal animal=new Dog();
        animal.eat();
        System.out.println(animal.name = "小花");
    }
}
interface Interface{
    public abstract void jump();
}
abstract class Animal{
    String name;
    int age;
    public abstract void eat();
    public abstract void sleep();
}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("吃鱼");
    }
    @Override
    public void sleep() {
        System.out.println("晚上睡觉");
    }
    public void lookdoor(){
        System.out.println("看门");
    }
}
class wangcaiDog extends Dog implements Interface{
    @Override
    public void jump() {
        System.out.println("跳高");
    }
}