Java——【抽象类】

---

一、抽象类

1.抽象类用abstract修饰

astract class A{//抽象类，用astract修饰
}

2.抽象类不能被实例化

abstract class A{
    abstract public void A();//抽象方法
}
public class Main{
    public static void main(String[] args) {
        A a=new A();//报错了
    }
}

3.作为抽象类的非抽象子类可以创建对象

abstract class A{
    abstract public void A();//抽象方法
}
class B extends A{
    @Override
    public void A() {//覆写抽象方法
        System.out.println("hello world!");//有具体的实现
    }
}
public class Main{
    public static void main(String[] args) {
       B b=new B();//可以创建对象
    }
}

所以一般用抽象父类声明的方法，是通过子类来具体实现的

4.抽象类与普通类的区别就是可以包含抽象方法

抽象类中不一定要有抽象方法

abstract class A{//抽象类
    abstract public void A();//抽象方法，可以没有
    public int a=10;//可以有普通成员
    public String name="ff";//普通成员
    public static void B(){//可以有普通方法
        System.out.println("hallo world!");
    };

5.抽象类的子类要重写抽象类中的抽象方法

父类中有抽象方法存在，则需要覆写抽象方法（通过子类将父类中抽象方法的具体实现），如果子类是抽象类则可以不覆写

abstract class A{
    abstract public void A();//抽象方法
}
class B extends A{
    @Override
    public void A() {//覆写抽象方法，没有报错
        System.out.println("hello world!");//有具体的实现
    }
}

abstract class A{
    abstract public void A();//抽象方法
}
class B extends A{//没有覆写抽象方法，报错
}

abstract class B extends A{}//将子类变成抽象类后没有报错，但是不能实例化

二、向上转型

直接赋值

abstract class Animal {
    public int age;
    public String name;

    public Animal(int age, String name) {
        this.age = age;
        this.name = name;
    }
   abstract void Break();//抽象类
}
class Cat extends Animal{

    public Cat(int age, String name) {
        super(age, name);
    }
    public void Break(){//重写抽象类
        System.out.println(name+"在猫叫");
    }
}
class Duck extends Animal {
    public Duck(int age,String name){

        super(age,name);
    }
    public void Break(){//重写抽象类
        System.out.println(name+"在鸭叫");
    }
}
public class Main{
    public static void main(String[] args) {
        Cat cat=new Cat(12,"xx");//实例化子类对象
        Duck duck=new Duck(12,"xx");//实例化子类对象
        Animal animal=cat;//子类对象直接赋值
        Animal animal2=duck;//子类对象直接赋值
        animal.Break();//向上转型，被赋予的子类对象不同，具体实现的方法也不同
        animal2.Break();//向上转型，被赋予的子类对象不同，具体实现的方法也不同
    }
}
xx在猫叫
xx在鸭叫

作为方法的参数

abstract class Animal {
    public int age;
    public String name;

    public Animal(int age, String name) {
        this.age = age;
        this.name = name;
    }
    abstract void Break();//抽象类
}
class Cat extends Animal{

    public Cat(int age, String name) {
        super(age, name);
    }
    public void Break(){//重写抽象类
        System.out.println(name+"在猫叫");
    }
}
class Duck extends Animal {
    public Duck(int age,String name){

        super(age,name);
    }
    public void Break(){
        System.out.println(name+"在鸭叫");
    }
}
public class Main{
    public static void func(Animal animal){
        animal.Break();//向上转型，参数对应的子类对象不同，具体实现的方法也不同
    }
    public static void main(String[] args) {
        func(new Cat(1,"xx"));//子类对象作为方法参数
        func(new Duck(1,"xx"));//子类对象作为方法参数
    }
}
输出结果：
xx在猫叫
xx在鸭叫

作为方法的返回值

abstract class Animal {
    public int age;
    public String name;
    public Animal(int age, String name) {
        this.age = age;
        this.name = name;
    }
    abstract void Break();//抽象类
}
class Cat extends Animal{//继承Animal

    public Cat(int age, String name) {
        super(age, name);
    }
    public void Break(){//重写

        System.out.println(name+"在猫叫");
    }
}
class Duck extends Animal {
    public Duck(int age,String name){

        super(age,name);
    }
    public void Break(){//重写

        System.out.println(name+"在鸭叫");
    }
}
public class Main{
    public static Animal func(){
        System.out.println("1>>Cat"+" "+"2>>Duck");//1是猫，2是鸭子
        Scanner scanner=new Scanner(System.in);
        int scan= scanner.nextInt();//选择猫或鸭子
        if(scan==1){
            return new Cat(12,"xx");//子类对象作为返回值
        }else {
            return new Duck(12,"xx");//子类对象作为返回值
        }
    }
    public static void main(String[] args) {
        while(true) {
            Animal animal = func();
            animal.Break();//向上转型，返回的子类对象不同，具体实现的方法也不同
        }
输出结果：        
1>>Cat 2>>Duck
2
xx在鸭叫
1>>Cat 2>>Duck
1
xx在猫叫