JavaSe之抽象类

本文主要是介绍JavaSe之抽象类，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

抽象类的特点：
1、抽象类和抽象方法必须用abstract关键字修饰
格式：
abstract class 类名{}
abstract void eat();
2、抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
抽象类里面可以有具体的实现方法
3、抽象类不能实例化
那么，抽象类如何实例化呢？
按照多态的方式，首先要有继承关系，由具体的子类实例化。
多态的形式实例化，我们在这里称之为：抽象类多态
4、抽象类的子类
1、如果是一个具体的子类，就必须重写所有的抽象方法
2、如果是一个抽象的子类，可以不重写父抽象类的抽象方法，也可以有选择性的重写

//由于类存在抽象方法，该类必须定义为抽象类
//class Demo{
//    public abstract void show();
//}

abstract class Demo{
    public abstract void show();

    public void show2(){
        System.out.println("这是在抽象类中的具体的方法");
    }
}


//定义一个抽象类
abstract class Animal{
    //定义一个抽象的方法，名字叫吃，没有方法体
    public abstract void eat();
    //下面这样定义抽象方法是错误的，{}代表空方法体，会报错，抽象方法不能有方法体
//    public abstract void eat(){};

    //定义一个抽象的方法，名字叫睡觉，没有方法体
    public abstract void sleep();
}

//abstract class Demo2 extends Animal{
//    @Override
//    public void eat() {
//        System.out.println("重写方法");
//    }
//}

//快捷键 alt + enter
class Cat extends Animal{

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void sleep() {
        System.out.println("趴着睡");
    }
}



public class AbstractDemo1 {
    public static void main(String[] args) {
        //Animal这个类是一个抽象类，而抽象类不能被实例化
//        Animal animal = new Animal();

//        Cat cat = new Cat();
//        cat.eat();
//        cat.sleep();

        //用多态的形式进行实例化
        Animal a1 = new Cat();
        a1.eat();
        a1.sleep();
    }
}

抽象类中成员的特点：
成员变量：可以是变量，也可以是常量
构造方法：有构造方法
但是抽象类又不能被实例化，有个构造方法有什么用呢？
用于子类访问父类进行初始化
成员方法：
可以是具体的实现方法，也可也是抽象的方法

        特点：
            1、如果是一个具体的子类，就必须重写所有的抽象方法
            2、如果是一个抽象的子类，可以不重写父抽象类的抽象方法，也可以有选择性的重写

abstract class Animal2{
    int num  = 20;
    final int num2 = 200;

    Animal2(){}

    abstract public void sleep();

}

class Dog extends Animal2{

    @Override
    public void sleep() {
        System.out.println("侧着睡");
    }
}


public class AbstractDemo2 {
    public static void main(String[] args) {
        Animal2 a = new Dog();
        a.sleep();
    }
}

一个类如果没有抽象方法，可不可以定义为抽象类?
可以
如果可以，有什么意义?
如果说一大堆东西，他们都有共同的概念，这个共同的概念本身在现实中是没有具体的存在，把这些概念
集合起来归为一个类，这个类就是抽象类。
至于说这个抽象类有没有方法，却决于这一大堆东西有没有共同的行为，如果说他们只是有着相同的本质。
但是呢，没有共同的行为，这也是合情合理的。

    总结：
        1、抽象类里面可以没有抽象方法
        2、抽象类不能被实例化

    abstract不能和哪些关键字共存
        private  冲突
        final    冲突
        static   冲突

abstract class Demo2{
    public abstract void show();

    //非法的修饰符组合: abstract和private
//    private abstract void show2();

    //非法的修饰符组合: abstract和final
//    final abstract void show3();

    //非法的修饰符组合: abstract和static
//    static abstract void show4();

}

public class AbstractDemo3 {
    public static void main(String[] args) {

    }
}

抽象类练习1：
猫狗案例
具体事物：猫，狗
共性：姓名，年龄，吃饭

    分析：从具体到抽象的过程
        猫：
            成员变量：姓名，年龄
            构造方法：无参构造，有参构造
            成员方法：吃饭（猫吃鱼）

        狗：
            成员变量：姓名，年龄
            构造方法：无参构造，有参构造
            成员方法：吃饭（狗吃肉）

   通过分析发现，猫和狗有一些共性内容，所以我们就根据这些共性内容提取了一个父类：动物类：Animal
   但是呢，又由于吃饭的方式不同，所以吃饭的方法我们定义为抽象方法。
   又因为，吃饭的方法是一个抽象方法，所以该类必须定义为抽象类

   抽象动物类：Animal
        成员变量：姓名，年龄
        构造方法：无参构造，有参构造
        成员方法：吃饭，是一个抽象方法 eat();

   实现：从抽象到具体
        抽象动物类：Animal
           成员变量：name,age;
           构造方法：无参构造，有参构造
           成员方法：吃饭，是一个抽象方法 public abstract void eat();
        狗类：
            继承自动物类
            无参构造，有参构造
            重写抽象的吃饭方法
        猫类：
            继承自动物类
            无参构造，有参构造
            重写抽象的吃饭方法

abstract class Animal3{
    private String name;
    private int age;

    public Animal3() {
    }

    public Animal3(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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 abstract void eat();
    public abstract void eat();
}


class Dog3 extends Animal3{

    public Dog3() {
    }

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

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}

class Cat3 extends Animal3{

    public Cat3() {
    }

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

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}


public class AbstractTest {
    public static void main(String[] args) {
        Animal3 a = new Cat3("小花",3);
        System.out.println(a.getName()+"---"+a.getAge());
        a.eat();

        Animal3 a2 = new Dog3("大黄",4);
        System.out.println(a2.getName()+"---"+a2.getAge());
        a2.eat();

    }
}

老师案例
具体事物：十三期老师，十二期老师
共性：姓名，年龄，讲课。

    分析：
        十三期老师：
            姓名，年龄
            讲课（讲JavaSE）

        十二期老师：
            姓名，年龄
            讲课（讲Hive）

    实现：
        抽象的老师类：
            姓名，年龄
            讲课，定义为抽象方法
        十三期老师：
            继承自老师类
            姓名，年龄
            讲课（讲JavaSE）
        十二期老师：
            继承自老师类
            姓名，年龄
            讲课（讲Hive）

abstract class Teacher{
    private String name;
    private int age;

    public Teacher() {
    }

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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 abstract void teach();
}

class ThirteenTeacher extends Teacher{

    public ThirteenTeacher() {
    }

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

    @Override
    public void teach() {
        System.out.println("教JavaSE");
    }
}

class TwelveTeacher extends Teacher{

    public TwelveTeacher() {
    }

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

    @Override
    public void teach() {
        System.out.println("教Hive");
    }
}

public class AbstractTest2 {
    public static void main(String[] args) {
        Teacher t1 = new ThirteenTeacher("小虎",24);
        System.out.println(t1.getName()+"---"+t1.getAge());
        t1.teach();

        Teacher t2 = new TwelveTeacher("火火",24);
        System.out.println(t2.getName()+"---"+t2.getAge());
        t2.teach();
    }
}

学生案例
具体事务：十三期学员，十二期学员
共性：姓名，年龄，班级，学习，吃饭

分析：
    十三期学员：
        姓名，年龄，班级
        学习（学习Java基础），吃饭
    十二期学员：
        姓名，年龄，班级
        学习（学习Hive），吃饭
    抽象的学员：
        姓名，年龄，班级
        学习（定义为抽象方法），吃饭

    实现：
    十三期学员：
        姓名，年龄，班级
        学习（学习Java基础），吃饭
    十二期学员：
        姓名，年龄，班级
        学习（学习Hive），吃饭
    抽象的学员：
        姓名，年龄，班级
        学习（定义为抽象方法），吃饭

abstract class Trainee{
    private String name;
    private int age;
    private String clazz;

    public Trainee() {
    }

    public Trainee(String name, int age, String clazz) {
        this.name = name;
        this.age = age;
        this.clazz = clazz;
    }

    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 String getClazz() {
        return clazz;
    }

    public void setClazz(String clazz) {
        this.clazz = clazz;
    }

    //这是抽象的学习方法
    public abstract void study();

    //具体的吃米饭的方法
    public void eat(){
        System.out.println("吃米饭");
    }
}

class ThirteenTrainee extends Trainee{

    public ThirteenTrainee() {
    }

    public ThirteenTrainee(String name, int age, String clazz) {
        super(name, age, clazz);
    }

    @Override
    public void study() {
        System.out.println("学习Java基础");
    }
}

class TwelveTrainee extends Trainee{

    public TwelveTrainee() {
    }

    public TwelveTrainee(String name, int age, String clazz) {
        super(name, age, clazz);
    }

    @Override
    public void study() {
        System.out.println("学习Hive");
    }
}


public class AbstractTest3 {
    public static void main(String[] args) {
        Trainee t1 = new ThirteenTrainee("陈俊荣",17,"十三期");
        System.out.println(t1.getName()+"---"+t1.getAge()+"---"+t1.getClazz());
        t1.study();
        t1.eat();

        Trainee t2 = new TwelveTrainee("航航",18,"十二期");
        System.out.println(t2.getName()+"---"+t2.getAge()+"---"+t2.getClazz());
        t2.study();
        t2.eat();
    }
}

假如我们在开发一个系统时需要对员工类进行设计，员工包含3个属性：姓名、工号以及工资。
经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。
请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。

    分析：
        普通员工：
            姓名，工号，工资
            工作（敲代码）

        经理：
            姓名，工号，工资，奖金
            工作（做PPT）

    实现：
        抽象的员工类
        普通员工类
        经理类

abstract class Staff{
    private String name;
    private String id;
    private int salary;

    public Staff() {
    }

    public Staff(String name, String id, int salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public abstract void work();
}

class GeneralWorker extends Staff{

    public GeneralWorker() {
    }

    public GeneralWorker(String name, String id, int salary) {
        super(name, id, salary);
    }

    @Override
    public void work() {
        System.out.println("敲代码");
    }
}


class Manager extends Staff{

    private int bonus;

    public Manager() {
    }

    public Manager(String name, String id, int salary) {
        super(name, id, salary);
    }

    public int getBonus() {
        return bonus;
    }

    public void setBonus(int bonus) {
        this.bonus = bonus;
    }

    @Override
    public void work() {
        System.out.println("做PPT");
    }
}

public class AbstractTest4 {
    public static void main(String[] args) {
        Staff s1 = new GeneralWorker("陈峻荣","0001",14000);
        System.out.println(s1.getName()+"---"+s1.getId()+"---"+s1.getSalary());
        s1.work();

        Staff s2 = new Manager("小虎","00080",30000);

        //向下转型使用子类特有的方法
//        s2.setBounts();
        ((Manager)s2).setBonus(4000000);
        System.out.println(s2.getName()+"---"+s2.getId()+"---"+s2.getSalary()+"---"+((Manager) s2).getBonus());
        s2.work();


    }
}

这篇关于JavaSe之抽象类的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

JavaSe之抽象类

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯