java基础------抽象类

前言

在面向对象的概念中，所有的对象对象都是通过类来描绘的，但是并不是所有的类都是用来描绘对象的，当一个类没有足够的信息来描绘一个具体的对象，而是需要其它的类来对它进行支撑，那么我们就将这样的类成为抽象类，用abstract 关键字来声明。

抽象类&抽象方法的定义

抽象方法定义格式：

public abstract 返回值类型 方法名(参数);

抽象类定义的格式：

abstract class 类名{
}

简单实例

package 抽象类;
public abstract class Test {
    //声明属性
    String name;
    int age;
    //普通方法
    public void show(){
        System.out.println("这是一个普通方法");
    }
    //抽象方法
    public abstract void run();
    //抽象方法所在类是抽象方法，但是抽象类里可以没有抽象方法

}
package 抽象类;
public class Test1 extends Test {
    //
    public void run(){
        System.out.println("我是从父类抽象方法重写的方法");
    }
    public static void main(String[] args) {
        //利用抽象方法子类构建实例对象
        Test1 test1=new Test1();
        test1.run();
        test1.show();
    }
}

抽象类注意事项

抽象类不能创建对象，即不能new 对象，只能创建抽象类的对象。
抽象类中，可以有构造方法，是提供创建对象时，初始化父类成员用的
抽象类不一定包含抽象方法，但是抽象方法的类一定是抽象类
抽象类的子类，必须要重写父类中的抽象方法，不然编译无法通过而报错，除非该子类也是抽象类

抽象类应用

package 抽象类;
public abstract class Animal {
    String name;
    int age;
    String color;
    //无参构造
    public Animal(){
    }
    //有参构造
    public Animal(String name,int age,String color){
        this.age=age;
        this.name=name;
        this.color=color;
    }
    public abstract void go();
    public abstract void show();
    public abstract void eat();
}

package 抽象类;
public class car extends Animal{
    public car(){

    }
    public car(String name,int age,String color){
        super(name,age,color);
    }

    public void show(){
        System.out.println(name);
        System.out.println(age);
        System.out.println(color);
    }
    public void go(){
        System.out.println("小猫跑");
    }
    public void eat(){
        System.out.println("小猫吃鱼");
    }
}

package 抽象类;
public class Test2 {
    public static void main(String[] args) {
        car car=new car("小猫",2,"白色");
        car.eat();
        car.go();
        car.show();
    }
}
//输出结果
小猫吃鱼
小猫跑
小猫
2
白色

final关键字

1.修饰的类不希望被继承

public final class 类名{
}

2.修饰的方法不希望被重写

public final void 方法名(){
//方法体
}

3.修饰的属性值不希望被修改

final 数据类型 变量名 

总结

三必须（三种情况必须定义为抽象类）：

1、一个类中直接定义了一个或多个抽象方法；

2、一个类继承了一个抽象父类，但没有实现父类中的抽象方法；

3、一个类实现了一个接口，但没有完全实现接口包含的抽象方法；

五不能：

1、抽象类不能被实例化（即抽象类不能被new）；

2、abstract与final永远不能同时使用（final修饰的类不能被继承，修饰的方法不能被重写；而abstract修饰的类只能被继承才有意义，修饰的方法必须被重写才有意义）；

3、abstract与static不能同时修饰方法（static修饰的方法属于类本身，如果抽象方法被static修饰，通过类调用该方法时会因为没有方法体而出错）；

4、abstract与private不能同时使用（abstract修饰的方法必须重写才有意义，而private使访问权限受限）；

5、abstract不能修饰变量（即没有抽象变量）；