一.抽象类
1.概念
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。abstract class用来定义抽象类。
public abstract class Animal {
public String name;
public int age;
public abstract void eat();
public abstract void sleep();
}
2.特点
1.抽象类和抽象方法必须用abstract关键字修饰
抽象类格式: abstract class 类名 {}
抽象方法格式: public abstract void eat();
2.抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
3.抽象类中可以有构造方法,抽象类不能进行实例化,构造方法有什么用于子类访问父类数据时的初始化
4.抽象类不能直接实例化，按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
5.抽象类的子类：要么是抽象类，要么重写抽象类中的所有抽象方法
3.成员特点
1.成员变量：既可以是变量，也可以是常量。
2.构造方法：用于子类访问父类数据的初始化。
3.成员方法：既可以是抽象的，也可以是非抽象的。
4.练习题
//父类
public abstract class Employee {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public abstract void work();
}
//子类
public class Manager extends Employee{
private double bonus;
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
@Override
public void work() {
System.out.println("经理进行管理的工作");
}
public void fitness(){
System.out.println("健身");
}
}
public class MyTest {
public static void main(String[] args) {
Employee employee = new Manager();
employee.setName("张三");
employee.setAge(200);
Manager manager = (Manager) employee;
manager.setBonus(3000);
System.out.println(employee.getName());
System.out.println(employee.getAge());
System.out.println(manager.getBonus());
manager.work();
manager.fitness();
}
}
注意：
abstract 在方法中使用，能不能和下面的关键字一块使用
1.private abstract 矛盾 abstract 强制子类重写 private 限定后又无法重写
2. final abstract 矛盾 abstract 强制子类重写 final 重写不了
3.abstract static 矛盾 没有意义
二.接口
1.概念
猫狗案例中狗一般就是看门，猫一般就是作为宠物了。但是，出现了有这样的情况猫钻火圈，狗跳高，狗做计算等。而这些额外的动作，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的。所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。
为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可。
interface 接口名称 [extends 其他的接口名] {
// 声明变量
// 抽象方法
}
2.特点
1.接口用关键字interface表示 格式: interface 接口名 {}
public interface Fireinterface { //定义了一个接口
//在接口里面定义扩展的功能
//接口里面定义的是抽象的功能
public abstract void fire();
}
2.:类实现接口用implements表示 格式: class 类名 implements 接口名 {}
class Dog implements Fireinterface{
public void fire() {
System.out.println("狗学会了钻火圈");
}
}
3.接口不能实例化，按照多态的方式来实例化。
4.接口的子类
a:可以是抽象类。但是意义不大。
b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
3.成员特点
1.成员变量；只能是常量，并且是静态的。
默认修饰符：public static final
建议：自己手动给出。
2.构造方法：接口没有构造方法。
3.成员方法：只能是抽象方法。
默认修饰符：public abstract
建议：自己手动给出。
三.类与类,类与接口,接口与接口的关系
a:类与类：
继承关系,只能单继承,可以多层继承。
b:类与接口：
实现关系,可以单实现,也可以多实现。
并且还可以在继承一个类的同时实现多个接口。
c:接口与接口：
继承关系,可以单继承,也可以多继承。
//案例
public class MyTest {
public static void main(String[] args) {
VV vv = new VV();
vv.hehe();
vv.hehe();
}
}
interface AA{
void aa();
public default void hehe(){
System.out.println("hehe");
}
}
class VV implements AA,BB{
public void aa() {
}
public void bb() {
}
}
interface BB{
void bb();
public default void haha() {
System.out.println("haha");
}
}
interface CC{
void cc();
}
class MyClass implements AA,BB,CC{
public void aa() {
}
public void bb() {
}
public void cc() {
}
}
interface AAA {
void aaa();
}
interface BBB{
void bbb();
}
interface CCC extends AAA,BBB{
void CCC();
}
class MM implements CCC{
public void aaa() {
}
public void bbb() {
}
public void CCC() {
}
}
class Zi extends MM implements AA,BB{
public void aa() {
}
public void bb() {
}
}
四.抽象类和接口的区别
A:成员区别
抽象类：
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象
B:关系区别
类与类
继承，单继承
类与接口
实现，单实现，多实现
接口与接口
继承，单继承，多继承
C:设计理念区别
抽象类 被继承体现的是：”is a”的关系。 抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是：”like a”的关系。 接口中定义的是该继承体系的扩展功能。
今天的学习到这里就结束了~
Anything in life worth having would take sacrifice，patience，and be a lot of work.
生活中任何值得拥有的东西都需要牺牲，耐心，还有努力。
