抽象类和接口

1.抽象类

---

  如果 一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

就比如：我们把动物统一为一个整体，狗属于动物的一种，但是动物是一个大整体，他不是具体的某一个动物，所以不能具体描述狗。因此我们可以把它看成一个抽象类。

如代码：

​
abstract class Animal{
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public abstract void eat();//抽象方法。
    public void run(){
        System.out.println("正在跑");
    }//成员方法。
}
class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }
    public void eat(){
        System.out.println(name + " 正在吃狗粮");
    }
}
class Cat extends Animal{
    public Cat(String name, int age) {
        super(name, age);
    }
    public void eat(){
        System.out.println(name + " 正在吃猫粮");
    }
}
public class Main {

    public static void main(String[] args) {
        Animal dog = new Dog("旺财",3);
        Animal cat = new Cat("哈基米",3);
        dog.eat();
        cat.eat();
        }
    }

​

  如上图代码，在定义一个类的时候，我们是 { 父类 + 对象 = new 子类（）} 这样定义的，因为在抽象类定义的抽象方法中，我们在子类需要对父类进行重写，因此这样定义会向上转型，可以实现多态，即引用父类方法时，会调用子类重写的方法。

---

  如图所示：在我们不能对抽象类进行实例化。

  在我们抽象类的构造方法中也可以包含构造方法，但是这个构造方法不是实例化这个抽象类使用的，因为抽象类是不能被实例化的。那么这个构造方法其实，主要时在子类中被调用，进行初始化的。

---

  如图所示：关于抽象方法不能被 private  final  static修饰

  因为我们定义的父类的抽象方法，必须被子类重写，而private修饰的是私有的，final修饰的算是常量不能被修改，static修饰属于静态方法，属于类，不包含属于对象的某一方法，不能使用this。

---

对抽象类总结：

1.被abtract 修饰的叫做抽象方法，没有被具体实现。

2.如果一个类，包含了一个抽象方法，那么这个也一定是抽象方法，也必须被abtract 修饰。

3.抽象类可以和普通类一样，包含成员变量和成员方法。

4.和普通类在于，抽象类不能对对象进行实例化。

5.当普通类继承抽象类的时候，那么这个普通类必须重写抽象类中的抽象方法。

6.抽象方法不能被 private  final  static修饰。

---

2.接口

---

首先呢 接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。

接口也不能被jie

如下面的代码：

interface Animal{
     public static final int age = 0;
     public abstract void eat();
     public abstract void run();
}
class Dog implements Animal{
     String name;
     int age;
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + " 正在吃狗粮");
    }
    public void run(){
        System.out.println(name + " 正在跑");
    }
}
class Cat implements Animal{
     String name;
     int age;
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + " 正在吃猫粮");
    }
    public void run(){
        System.out.println(name + " 正在跑");
    }
}
public class Main {

    public static void main(String[] args) {
        Animal dog = new Dog("旺财",3);
        Animal cat = new Cat("哈基米",3);
        dog.eat();
        cat.eat();
        dog.run();
        cat.run();
        }
    }

如上述代码所示：我们定义接口的时使用 interface 关键字。在接口中如果不实现具体的成员方法，那么系统会默认为抽象方法。

如：

这里的 public abstract 显示的是白色的，因为这里系统会默认成这样。

还有看上述代码，我们在定义成员变量的时候，默认的都是 public static final 修饰，也需要进行初始化。

---

如果我们在定义具体的成员方法的时候我们必须用 default 或者 static 修饰。

如：

---

在这里我们讲述了如何定义接口，那么接口主要的作用是什么呢？

其实接口实现了类的多继承。

如代码：

class Animal{
        String name;
        int age;
        public Animal(String name , int age){
            this.name = name;
            this.age = age;
        }
}
interface Eat{
    void eat();
}
interface Run{
    void run();
}
class Dog extends Animal implements Eat,Run{
    public Dog(String name, int age) {
        super(name,age);
    }
    public void eat(){
        System.out.println(name + " 正在吃狗粮");
    }
    public void run(){
        System.out.println(name + " 正在跑");
    }
}
class Cat extends Animal implements Eat,Run{
    public Cat(String name, int age) {
        super(name, age);
    }
    public void eat(){
        System.out.println(name + " 正在吃猫粮");
    }
    public void run(){
        System.out.println(name + " 正在跑");
    }
}
public class Main {

    public static void main(String[] args) {
        Dog dog = new Dog("旺财",3);
        Cat cat = new Cat("哈基米",3);
        dog.eat();
        cat.eat();
        dog.run();
        cat.run();
        }
    }

如代码所示：我们子类继承接口的时候使用 implements 关键字。

在这里的每个接口的抽象方法必须重写。

---

接口也是可以生成字节码文件的。

如上述代码的例子：

---

接口总结：

1.我们定义接口的时使用 interface 关键字。

2.接口当中的方法，如果没有具体实现，那么会默认他是一个抽象方法。

3.接口中，不能有具体的方法实现，如果我们要定义具体的成员方法的时候我们必须用 default 或者 static 修饰。

4.接口中定义成员变量时，默认都是 public static final 修饰的。

5.接口中的方法，默认都是 public abstract 修饰的。

6.接口是不能被实例化的。

7.类和接口用关键字 implements 联系。

8.接口也是可以生成字节码文件。

---

以上就是关于 抽象类和接口的叙述。

谢谢大家观看。