Java基础——抽象类

目录

一，创建抽象类的原因及定义

原因

定义

二，抽象类有关代码的定义

三，抽象类的特点

1.抽象类定义

2.抽象方法

3.抽象类的继承

4.抽象方法的限定

5.抽象类的方法组成

6.实例化限制

7.final与abstract的互斥性

8.抽象方法的修饰符限制

9.抽象类的构造器

---

一，创建抽象类的原因及定义

原因

在父子类当中，如果父类的一个方法要被全部的子类继承重写，因为子类重写的方法会覆盖父类的方法，则为了方便可以将父类设置为抽象类，重写的方法设置为抽象方法，这样就避免了方法在父类中的完成，只需定义即可。

定义

抽象类是一种特殊的父类，它不能直接实例化，但可以作为其他子类的基座

二，抽象类有关代码的定义

public abstract class Animal {
    public abstract void makeSound();
}

class Dog extends Animal{
    public void makeSound(){
        System.out.println("wang");
    }

}
class Bird extends Animal{
    public void makeSound(){
        System.out.println("tweet");
    }
}

class Cat extends Animal{
    public void makeSound(){
        System.out.println("miao");
    }
}

 定义了抽象类Animal，其中包括抽象方法makeSound（），而之后三个子类分别继承Animal，并对该抽象方法进行了重写。

public class Test {

    public static void main(String[] args) {
        Animal[] animals = new Animal[3];
        animals[0] = new Dog();
        animals[1] = new Cat();
        animals[2] = new Bird();
        for (Animal animal : animals) {
            animal.makeSound();
        }
    }
}

测试类当中，创建了一个对象数组，包含的三个元素体现了多态的引用（抽象类不不能直接创建对象），最后遍历数组，调用每个子类的抽象方法。

三，抽象类的特点

抽象类的特点

1.抽象类定义

abstract修饰的类叫做抽象类，abstract修饰的方法叫做抽象方法

2.抽象方法

abstract修饰的抽象方法必须在子类当中实现，前提是子类不是抽象类

3.抽象类的继承

抽象类一定是父类

4.抽象方法的限定

只有抽象类当中才能有抽象方法， 普通类当中不能有抽象方法

5.抽象类的方法组成

抽象类当中不一定非要写抽象方法，也可以写普通方法

6.实例化限制

抽象类不能被实例化(不能被被创建对象),只能使用多态

7.final与abstract的互斥性

final和abstract不能同时使用,final修饰的类不能被继承,final修饰的方法不能被重写

8.抽象方法的修饰符限制

abstract修饰的方法不能被static修饰，static修饰的方法属于类

抽象方法不能使用private访问修饰符修饰

9.抽象类的构造器

抽象类是有构造器的,但是它的构造器不能创建对象,构造器的目的是为了完成 一些必要的初始化操作

public abstract class Animal {
    public String name;
    public Animal(String  name){
        this.name = name;

    }
    public abstract void makeSound();
}

class Dog extends Animal{
    public Dog(String name) {
        super(name);
    }

    public void makeSound(){
        System.out.println("wang");
    }

}
class Bird extends Animal{
    public Bird(String name) {
        super(name);
    }

    public void makeSound(){
        System.out.println("tweet");
    }
}

class Cat extends Animal{
    public Cat(String name) {
        super(name);
    }

    public void makeSound(){
        System.out.println("miao");
    }
}

public class Test {

    public static void main(String[] args) {
        Animal[] animals = new Animal[3];
        animals[0] = new Dog("mmm");
        animals[1] = new Cat("jjj");
        animals[2] = new Bird("lll");
        for (Animal animal : animals) {
            animal.makeSound();
        }
    }
}

使用super方法进行构造器的值传递，最后创建对象时进行赋值。

运行结果

 四，抽象类有关的例子

public abstract class Payment {

    public abstract void pay();

}
class CashPayment extends Payment{

    public void pay(){
        System.out.println("CashPayment");

    }
}
class CreditCardPayment extends Payment{

    public void pay(){
        System.out.println("CreditCardPayment");

    }
}

public class Test {
    public static void main(String[] args) {
              CreditCardPayment creditCardPayment = new CreditCardPayment();
              CashPayment cashPayment = new CashPayment();
              Payment payment1 = creditCardPayment;
              Payment payment2 = cashPayment;
              payment1.pay();
              payment2.pay();

    }
}

在测试类当中创建了对应子类的对象，因为抽象类不能直接创建对象，则可以将子类对象向上转型为父类，进而进行方法的调用。（也体现了多态的思想）

运行结果