Java中的抽象类

抽象类的定义

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

那么具体什么叫做抽象类呢？在了解抽象类之前我们需要先了解一下抽象方法，在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰

abstract class Abs {//定义的一个抽象类
    public void show(){
        System.out.println("这是普通方法！");//这是普通方法
    }
    public abstract void show1();//这是抽象方法
}

而拥有抽象方法的类就是抽象类，抽象类要使用abstract关键字声明
注意：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法

抽象类的特点

在上面我们已经了解了什么是抽象类，下面我们就来了解一下抽象类的特点吧！

abstract class A {
    public void show(){
        System.out.println("这是普通方法！");
    }
    private abstract void show1();
}
class B extends A{
    @Override
    public void show1() {
        System.out.println("这是重写的抽象方法");
    }
}
class text{
    public static void main(String[] args) {
        A a=new B();
    }
}

此时我们看见当抽象方法用private修饰的时候代码会报错

1.抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public；

abstract class A {
    public void show(){
        System.out.println("这是普通方法！");
    }
   public abstract void show1();
}
class B extends A{
    @Override
    public void show1() {
        System.out.println("这是重写的抽象方法");
    }
}
class text{
    public static void main(String[] args) {
        A a=new A();
 

2.抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
3.抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；

    public void show(){
        System.out.println("这是普通方法！");
    }
   public abstract void show1();
}
 abstract class B extends A{
}
class C extends B{
    @Override
    public void show1() {
        System.out.println("这是重写后的抽象方法");
    }
}
class text{
    public static void main(String[] args) {
        A a=new C();
    }
}

此时B继承了A，但是A并没有重写A的方法而是由C继承B再重写A中的抽象方法

4.子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类
5. 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类

abstract class A {
    public A() {
        System.out.println("A的构造方法");
    }

    public abstract void show1();
}
 class B extends A{
     @Override
     public void show1() {
     }
     public B(){
         System.out.println("B的构造方法");
     }
 }
class text{
    public static void main(String[] args) {
        A a=new B();
    }
}

此时我们在A中和B中都有构造方法而执行的时候依旧按照先执行父类的再执行子类的构造方法

6. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量
   7.抽象方法不能被final和static修饰，因为抽象方法要被子类重写，被final修饰的方法和变量会被类隐藏只能被继承无法被重写修改

抽象类的作用和实现

有些同学可能会问，普通类就可以被继承，普通方法也可以被重写，为什么还要多此一举用抽象类和抽象方法呢？

实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类了, 使用普通类编译器是不会报错的.但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题

 abstract class Act {
    public void eat(){};
    public void sleep(){};
    public void work(){};
}
class animal extends Act{
    @Override
    public void eat() {
        System.out.println("动物需要吃饭！");
    }
    @Override
    public void sleep() {
        System.out.println("动物需要睡觉！");
    }
}
class mankind extends Act{
    @Override
    public void eat() {
        System.out.println("人类需要吃饭！");
    }
    @Override
    public void sleep() {
        System.out.println("人类需要睡觉！");
    }
    @Override
    public void work() {
        System.out.println("人类需要工作！");
    }
}
public class text {
    public static void main(String[] args) {
        Act act=new animal();
        act.eat();
        act.sleep();
        Act act1=new mankind();
        act1.eat();
        act1.sleep();
        act1.work();
    }
}

这里简单使用抽象类并分别让其他两个类去继承抽象类中的方法，最后通过向上引用使用子类中的不同的抽象方法

像这样如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类本身不能被实例化，要想使用只能创建该抽象类的子类，然后子类重写抽象类中的抽象方法