一、什么是抽象类和抽象方法

没有具体功能的实现，通过子类继承后重写方法来实现一定约束的类称之为抽象类，抽象类必须被abstract修饰。抽象方法就是只有方法声明，没有方法体的方法。抽象类的使用一般通过继承来实现

二、为什么需要抽象类和抽象方法

引用抽象方法和抽象类，是java提供的一种语法工具，引导使用者正确的使用它们，减少误用。相当于对子类进行一定限制。

三、抽象类和抽象方法的语法规则及其注意事项

抽象类抽象方法必须被abstract修饰。

抽象类中可以有普通方法，但是有抽象方法的类必须是抽象类。抽象类中的普通方法因为不能被创建对象，所以不能使用这个普通方法。

抽象类除了不能实例化对象之外，类的其它功能依然存在。

抽象方法中可以有被static修饰main方法，并且可以执行。

一个类在继承抽象类后，必须实现抽象类中定义的所有抽象方法。除非它自己也声明为抽象类。

抽象方法名后面直接跟一个分号，而不是花括号。

四、抽象类和抽象方法的实现案例

1、抽象类中可以有普通方法，但是有抽象方法的类必须是抽象类。

public abstract class Demo01 {

public abstract void run();

public void test(){}

}

//编译通过，不报错

public class Demo01 {

public abstract void run();

public void test(){}

}

//报错：

Class 'Demo01' must either be declared abstract or implement abstract method 'run()' in 'Demo01'

Abstract method in non-abstract class

2、抽象类除了不能实例化对象

public abstract class Demo01 {

public abstract void run();

public static void main(String[] args) {

Demo01 demo01=new Demo01();

}

}

3、抽象方法中可以有被static修饰main方法，并且可以执行。

public abstract class Demo01 {

public abstract void run();

public static void main(String[] args) {

System.out.println("抽象类中的main方法");

}

}

//输出结果：抽象类中的main方法

4、抽象类的使用一般通继承来实现，且子类中要么对抽象类的方法进行重写，要么声明子类也为抽象类

public class Demo02 extends Demo01{

@Override

public void run() {

}

}

abstract class Demo03 extends Demo01{

}

//Demo02和Demo3均能编译通过。

5、抽象类中的静态方法可以用类名.方法名的方式调用

6、抽象的实例：

有抽象类Father，和抽象方法run()。

public abstract class Father {

private String name;

private int age;

private char sex='男';

public int money=100_000;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public char getSex() {

return sex;

}

public void setSex(char sex) {

this.sex = sex;

}

abstract void run();

public void say(){

System.out.println("这是父类普通方法");

}

public static void go(){

System.out.println("这是父类静态方法");

}

}

有子类Son继承了抽象类，重写了父类的抽象方法run

public class Son extends Father{

private double salary;

@Override

void run() {

System.out.println("子类重写了父类的方法run");

System.out.println(super.getSex());

super.say();

}

public static void main(String[] args) {

Son son=new Son();

son.run();

System.out.println(son.getSex());

//System.out.println(super.getSex()); //错误

son.setAge(47);

System.out.println(son.getAge());

son.setName("ThreePure");

System.out.println(son.getName());

//调用父类的公有属性

System.out.println(son.money);

//使用继承于父类的方法

son.say();

}

}

运行结果：

子类重写了父类的方法run

男

这是父类普通方法

男

47

ThreePure

100000

这是父类普通方法

尽管我们不能实例化一个 Father类的对象，但是如果我们实例化一个 Son 类对象，该对象将从 Father 类继承 成员方法，且通过该方法可以设置或获取成员变量。

五、抽象类的其他补充吗

抽象类是否有构造器：

从图中我们可以知道抽象类也是有构造器的，并别在子类创建对象时被调用。

public abstract class Demo3 {

public Demo3() {

System.out.println("抽象类的构造方法");

}

}

public class Demo4 extends Demo3{

public static void main(String[] args) {

Demo4 demo4 =new Demo4();

}

}

//抽象类的构造方法

2、final与abstract的矛盾

final关键字可以修饰类、方法、变量。final修饰的类不能被派生；final修饰的方法，禁止子类重写。所以我们可以看出，final和abstract不能一起使用。

3、构造方法，类方法(用 static 修饰的方法)不能声明为抽象方法。