java抽象类和抽象方法

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

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

2、为何须要抽象类和抽象方法

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

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

1. 抽象类抽象方法必须被abstract修饰。
2. 抽象类中能够有普通方法，可是有抽象方法的类必须是抽象类。抽象类中的普通方法由于不能被建立对象，因此不能使用这个普通方法。
3. 抽象类除了不能实例化对象以外，类的其它功能依然存在。
4. 抽象方法中能够有被static修饰main方法，而且能够执行。
5. 一个类在继承抽象类后，必须实现抽象类中定义的全部抽象方法。除非它本身也声明为抽象类。
6. 抽象方法名后面直接跟一个分号，而不是花括号。

 

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

　　一、抽象类中能够有普通方法，可是有抽象方法的类必须是抽象类。

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

　

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

public abstract class Demo01 {
    public abstract void run();

    public static void main(String[] args) {
        Demo01 demo01=new Demo01();
    }

}

　　

　　三、抽象方法中能够有被static修饰main方法，而且能够执行。

public abstract class Demo01 {
    public abstract void run();

    public static void main(String[] args) {
        System.out.println("抽象类中的main方法");
    }
}


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

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

public class Demo02 extends Demo01{
    @Override
    public void run() {
        
    }
}


abstract class Demo03 extends Demo01{

}

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

　　五、抽象类中的静态方法能够用类名.方法名的方式调用

 

 

 　　六、抽象的实例：

有抽象类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 类继承 成员方法，且经过该方法能够设置或获取成员变量。

5、抽象类的其余补充吗

　　抽象类是否有构造器：

　　

 

 　　从图中咱们能够知道抽象类也是有构造器的，并别在子类建立对象时被调用。

　　

public abstract class Demo3 {
    public Demo3() {
        System.out.println("抽象类的构造方法");
    }
}


public class Demo4 extends Demo3{
    public static void main(String[] args) {
        Demo4 demo4 =new Demo4();
    }
}


//抽象类的构造方法

　　二、final与abstract的矛盾

　　final关键字能够修饰类、方法、变量。final修饰的类不能被派生；final修饰的方法，禁止子类重写。因此咱们能够看出，final和abstract不能一块儿使用。

　　三、构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。