面向对象（抽象类和接口）

一 抽象类
1:抽象类概述
回想前面我们的猫狗案例，提取出了一个动物类。并且我们在前面也创建过了动物对象，其实这是不对的。为什么呢?因为，我说动物，你知道我说的是什么动物吗?只有看到了具体的动物，你才知道，这是什么动物。 所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出方法具体体现，而是应该给出一个声明即可。在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
2：抽象类特点
（1）抽象类和抽象方法必须用abstract关键字修饰
（2）格式
抽象类格式： abstract class 类名{}
抽象方法格式 public abstract void eat{}
（3）抽象类不一定有抽象方法，有抽象方法的类必须是抽象类，
（4）抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
答：用于子类访问父类数据时的初始化
（5）抽象类不能直接实例化那么，抽象类如何实例化呢?
答：按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
（6）抽象类的子类要么是抽象类，要么重写抽象类中的所有抽象方法。
（7）抽象类的成员特点
a:成员变量：既可以是变量，也可以是常量。
b:构造方法：有。用于子类访问父类数据的初始化。
c:成员方法：既可以是抽象的，也可以是非抽象的。
（8）抽象类中既可以有抽象方法，也可以有非抽象方法，抽象方法，强制子类重写，非抽象方法，可以让子类继承下去用
3：面试题
（1）一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
答案: 可以 . 不能创建对象.
（2）abstract不能和哪些关键字共存?
private 冲突
final 冲突
static 不能共存 无意义
4：例题
（1）动物案例

public class MyText {

    public static void main(String[] args) {
        //  new Animal();    抽象类不能直接创建对象 我们可以采用多态间接的去实例化抽象类
        Animal an=new Cat();
        an.eat();
        an.sleep();
        an.show();
    }
}

}

public abstract class Animal() {

   System.out.println("父类的构造方法执行了");
//abstract 抽象的，可以修饰类，修饰方法
public abstract void eat(); //抽象方法，此方法没有方法实现
public abstract void sleep();//这个也一样
//抽象类中既可以有抽象方法，也可以非抽象方法
public void show(){
System.out.println("这是父类的一个非抽象方法");
}

}

class Cat extends Animal{

@Override
public void eat() {
    System.out.println("猫爱吃鱼");

}

@Override
public void sleep() {
    System.out.println("猫白天睡觉");
}

}
运行结果为：

父类的构造方法执行了
猫爱吃鱼
猫白天睡觉
这是父类的一个非抽象方法
Process finished with exit code 0
（2）Person例题

public class MyTest {
    public static void main(String[] args) {
        Person p = new Student();
        p.name = "董永";
        p.age = 29;
        System.out.println(p.name + "====" + p.age); //董永 ====29
        p.sleep();//学生通宵不寐
        p.playGame();//玩游戏
        p.eat();//学生爱吃烤串
        ((Student) p).watchTV();//学生看电视
        System.out.println("------------------------");//------------------------
        p = new Teacher();
        p.name = "沈某某";
        p.age = 20;
        System.out.println(p.name + "===" + p.age);//沈某某 ====20
        p.sleep();//老师经常失眠
        p.eat();//老师爱吃搅团
        p.playGame();//玩游戏
    }
}

public abstract class Person {
    public String name;
    public int age;
    public abstract void eat();
    public abstract void sleep();
    public void playGame(){
        System.out.println("玩游戏");
    }

}

public class Student extends Person{
    @Override
    public void eat() {
        System.out.println("学生爱吃烤串");
    }

    @Override
    public void sleep() {
        System.out.println("学生通宵不寐");
    }
    public void watchTV(){
        System.out.println("学生看电视");
    }
}

public class Teacher extends Person {
    @Override
    public void eat() {
        System.out.println("老师爱吃搅团");
    }

    @Override
    public void sleep() {
        System.out.println("老师经常失眠");
   }
   }

运行结果在代码中已标注
二 接口
1.接口概述
继续回到我们的猫狗案例，我们想想狗一般就是看门，猫一般就是作为宠物了。但是，现在有很多的驯养员或者是驯兽师，可以训练出：猫钻火圈，狗跳高，狗做计算等。而这些额外的动作，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的。所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。所以，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可
2.接口特点
（1）接口用关键字interface表示
格式: interface 接口名 {}
（2）类实现接口用implements表示
格式: class 类名 implements 接口名 {}
（3）接口不能实例化那么，接口如何实例化呢?
答：按照多态的方式来实例化。
（4）接口的子类
a:可以是抽象类。但是意义不大。
b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
3.接口的成员特点
成员变量；只能是常量，并且是静态的。
默认修饰符：public static final
建议：自己手动给出。
构造方法：接口没有构造方法。
成员方法：只能是抽象方法。
默认修饰符：public abstract
建议：自己手动给出。
4 类与类,类与接口,接口与接口的关系
（1）类与类：继承关系,只能单继承,可以多层继承。
（2）类与接口：实现关系,可以单实现,也可以多实现。并且还可以在继承一个类的同时实现多个接口。
（3）接口与接口：继承关系,可以单继承,也可以多继承。
5 抽象类和接口的区别
（1）成员区别
抽象类：
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象
构造方法：没有
（2）设计理念区别
抽象类：
被继承，体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
接口：
被实现，体现的是：”like a”的关系。 接口中定义的是该继承体系的扩展功能。
（3） 注意：JDK1.8之后在接口中提供了用default修饰的方法，可以给出功能的具体实现，子类可以继承下去用
6 例题
动物例题

public abstract class Animal {

    public abstract void eat();
}

public interface CalcInterface {
    //用来定义额外功能
    public abstract void calc();
}

public class Cat extends Animal implements CalcInterface{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void catcheMouse(){
        System.out.println("猫抓老鼠");
    }

    @Override
    public void calc() {
        System.out.println("猫经过不断的努力学习，会做算术了");
    }
}

public class Dog extends Animal implements CalcInterface{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    public void lookDoor(){
        System.out.println("狗看门");
    }


    @Override
    public void calc() {
        System.out.println("狗经过自己的学习，也学会了做算术");
    }
}

public class MyTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        Animal an = cat;
        an.eat();
        // CalcInterface 是猫的一个父接口，猫类也是父接口的一个子类
        CalcInterface calcInterface = cat;
        calcInterface.calc();
        //多态
        CalcInterface c = new Dog();
        c.calc();
        //接口不能new 对象

    }
}

运行结果为

猫吃鱼
猫经过不断的努力学习，会做算术了
狗经过自己的学习，也学会了做算术

Process finished with exit code 0