JavaSE——抽象类和接口

1.抽象类

1.1 概念

  在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的， 如果 一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类 。

比如：

  在动物叫声例子中 , 我们发现 , 父类 Animal  中的 brak 方法好像并没有什么实际工作 , 主要的描述叫声都是由 Animal 的各种子类的 brak  方法来完成的 . 像这种没有实际工作的方法 , 我们可以把它设计成一个 抽象方法 (abstract method) , 包含抽象方法的类我们称为 抽象类 (abstract class)

1.2 语法

在Java中，一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。

代码示例如下：

 // 抽象类：被abstract修饰的类
    public abstract class Animal {
        private String name;
        private int age;
        // 抽象方法：被abstract修饰的方法，没有方法体
        abstract public void bark();
        abstract void sheep();
        // 抽象类也是类，也可以增加普通方法和属性
        public String getname(){
            return name;
        }
       
    }

注意：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法

1.3 特性

1. 抽象类不能直接实例化对象

2. 抽象方法不能是 private 的

3. 抽象方法不能被 final 和 static 修饰，因为抽象方法要被子类重写

4. 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰

 abstract class Animal {
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    abstract public  void bark();
    abstract void eat();
    public String getname(){
        return name;
    }
}
 class Dog extends Animal{
     public Dog(String name, int age) {
         super(name, age);
     }

     @Override
     public void bark() {
         System.out.println( getname() +" 正在汪汪叫！！");
     }

     @Override
     void eat() {
         System.out.println(getname() + "正在吃狗粮！！");
     }
 }
 class Cat extends Animal{
     public Cat(String name, int age) {
         super(name, age);
     }

     @Override
     public void bark() {
         System.out.println( getname() +" 正在喵喵叫！！");
     }

     @Override
     void eat() {
         System.out.println(getname() + "正在吃猫粮！！");
     }
 }
public class test1 {
    public static void main(String[] args) {
    Dog dog = new Dog("小黄",14);
    Cat cat = new Cat("小花",15);
    dog.bark();
    cat.bark();
    dog.eat();
    cat.eat();
    }

}

运行结果如下：

注意： 当一个普通类B继承一个抽象类A，如果不想重写这个抽象类A的方法，此时，可以把这个普通类改为抽象类，但是如果B这个抽象类再被普通类C继承，此时C这个类要重写所有未被重写的抽象方法。

代码如下：

abstract class  A{
     abstract public  void func1();
        }
  abstract class B extends A{
      abstract public  void func2();
  }
  class C extends B{

      @Override
      public void func1() {
          System.out.println("C:: func1()");
      }

      @Override
      public void func2() {
          System.out.println("C:: func2()");
      }
  }
public class test2 {
    public static void main(String[] args) {
        C c = new C();
        c.func1();
        c.func2();
    }
}

运行结果如下：