一、final和static关键字

1、final

  final是一个关键字，表示最终的意思，可以用来修饰类、变量、方法。
  修饰类：表明该类是最终类，不能被继承
  修饰变量：表明该类是常量，不能再次赋值
  修饰方法：表明该方法是最终方法，不能被重写

2、static

  static是一个关键字，表示静态的意思。可以用来修饰成员变量和成员方法。

（1）static修饰成员的特点

• 被类的所有对象共享（这也是判断一个成员是否应该用static修饰的条件）
• 可以通过类名直接访问
• 优先于对象存在
• 随着类的加载而加载

（2）静态与非静态成员方法的对比

非静态的成员方法：

• 能访问静态的成员变量
• 能访问非静态的成员变量
• 能访问静态的成员方法
• 能访问非静态的成员方法

静态的成员方法：

• 能访问静态的成员变量
• 能访问静态的成员方法

注意：
  静态成员方法中不能出现this，super这样的关键字
  原因：静态是随着类的加载而加载，this，super这样的关键字是随着对象的创建而存在的，先进内存的不能访问后进内存的。

二、抽象类

1、概述

  抽象类顾名思义就是用来描述一个抽象的事物的类,比如说我们在说动物的时候，并没有具体的说是那种动物，这就是一个抽象的事物，而如果我说猫，这相对而言就是一个具体的事物。同样的，每个动物都具有吃东西的行为，但是不同动物吃的东西是不同的，所以我们在定义动物这个类的时候不能给出具体的体现，只需要给一个声明既可。
  在Java中，一个没有方法体的方法应该定义为抽象方法，而一个类中如果有抽象方法，该类就必须定义为抽象类。

2、特点

（1）抽象类和抽象方法必须使用abstract关键字修饰；
格式：

public abstract class 类名 {}
public abstract 返回值类型 方法名() {}

（2）抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类；
（3）抽象类不能直接实例化，如果想要实例化，需要参照多态的方式，通过子类对象实例化；
（4）抽象类的子类要么是抽象类，要么必须重写抽象类中的所以抽象方法。

案例1：

//定义一个抽象类
public abstract class Animal{
    public abstract void eat();
    
    //抽象类中可以有普通方法
    public void sleep(){
        System.out.println("睡觉");
    }
 }

//定义一个子类Cat继承Animal
public class Cat extends Animal{
    //重写抽象方法
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

//定义测试类
public class AnimalDemo{
    public static void main(String[] args){
        //创建对象
        Animal a = new Cat();
        a.eat();
        a.sleep();
    }
 }

3、成员的特点

（1）成员变量：可以是变量也可以是常量；
（2）构造方法：抽象类中也有构造方法，用于子类访问父类数据的初始化；
（3）成员方法：成员方法可以是抽象的，也可以是非抽象的。
  抽象方法限定子类必须完成某些动作，非抽象方法能够提高代码的复用性

案例2

//定义一个Person类
public abstract class Person {
    private int age = 20;   
    private String country = "中国";
    
    public Person() {}
    
    public Person(int age) {
        this.age = age;
    }
    
    public void show() {
        age = 30;
        System.out.println(age);
        System.out.println(country);
    }
    
    public abstract void eat();
}

//定义一个子类Student继承自Person
public class Student extends Person {

    @Override
    public void eat() {
        System.out.println("学生爱吃KFC");
    }       
}

//定义测试类
public class PersonDemo {
    public static void main(String[] args) {
        Person p = new Student();
        //Person的对象p可以调用Person的方法，但是运行的时候运行的是Student内的方法
        //如果Student内没有这个方法，再调用Person内的方法
        p.show();
        p.eat();
    }
}

三、接口

1、概述

  我们在生活中，每个人都会有不同的技能，这些技能不是一个人与生俱来的，而是我们慢慢学来的，因此我们在定义人类时，不能将这些额外的技能定义进去，因为只有部分人才有这些技能。所以，为了体现事物功能的拓展性，Java中就提供了接口来定义这些额外的功能，并不给出具体实现，将来谁学会了特殊的技能，只需要这部分人实现这些额外的功能。

2、特点

（1）接口用关键字interface表示
格式：

public interface 接口名{}

（2）类实现接口用implements表示
格式：

public class 类名 implements 接口名 {}

（3）接口也不能直接实例化，补习按照多态的方式，有具体的实现类实例化。这也是多态的一种，称为接口多态。
（4）接口的实现类要么是一个抽象类，要么重写接口中的所有的抽象方法。
案例3：

//定义一个钢琴接口
public interface Piano {
    //抽象方法
    public abstract void playThePiano();
}

//定义学生类实现钢琴接口
public class Cat implements Piano {

    @Override
    public void playThePiano() {
        System.out.println("学生会弹钢琴");
    }

}

//定义测试类
public class InterfaceDemo {
    public static void main(String[] args) {
        //接口多态的形式实例化
        Piano p = new Student();
        p.playThePiano();
    }
}

3、接口的成员特点

（1）成员变量：只能是常量，默认修饰符为public static final
（2）构造方法：没有构造方法，因为接口是由于扩张功能的，没有具体存在
（3）成员方法：只能是抽象方法，默认修饰符public abstract

4、类与类、类与接口、接口与接口的关系

（1）类与类：继承关系，只能单继承，但是可以多层继承。
（2）类与接口：实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口。
（3）接口与接口：继承关系，可以单继承也可以多继承。

四、抽象类和接口的区别

1、成员区别

抽象类：
  成员变量：可以是变量可以是常量
  构造方法：有
  成员方法：可以是城乡方法，也可以是非抽象方法
接口：
  成员变量：只能是常量
  没有构造方法
  成员方法：只能是抽象方法

2、关系区别

  类与类：继承关系，只能单继承，可以多层继承。
  类与接口：实现关系，可以单实现，也可以多实现。
  接口与接口：继承关系，可以单继承，也可以多继承。

3、设计理念的区别

  抽象类 被继承体现的是："is a" 抽象类中定义的是继承体系的共性功能。
  接口 被实现体现的是："like a" 接口中定义的是该体系的扩展功能。
  用一张图来表示类，抽象类，接口的关系

类，抽象类，接口的关系