java-抽象类

约定不等于承诺〃 2022-06-13 14:20 361阅读 0赞

抽象类

怎样理解抽象类：
打个形象的比喻：
我们以前定义一个动物类，动物有吃的行为，但是我们没有指定这是哪个动物（不是一个具体的事物），而且动物吃的行为也不知道是哪种具体吃的行为。所以这里我们所指的动物类就可以看做是一个抽象类。这个动物拥有动物的属性和方法。

特点：
1-抽象类和抽象方法必须用abstract关键字修饰。
2-抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类。
3-抽象类不能直接实例化（可通过多态实现），因为它不是具体的类。（但是有构造方法）
4-抽象类是有构造方法的，只是不能实例化，用于子类访问父类数据的初始化。
抽象类的子类：
1- 不重写抽象方法，抽象类的子类是一个抽象子类
2-重写父类所有父类方法，子类不是抽象类（可通过该子类可实例化抽象父类）
例如：动物类
abstract class Animal{
public abstract void eat();
}
注意：抽象类中可以没有抽象方法。
抽象方法不能有方法体。
注意：空方法体和没有方法体的区别。

抽象类的成员特点：
成员变量：
既可以是变量也可以是常量。
构造方法：
有构造方法，用于子类访问父类数据的初始化。
成员方法：
抽象类中方法既可以是抽象的，也可以是非抽象方法。
在父类中：
非抽象方法：子类继承的事情，提高代码的复用性
抽象方法：强制要求子类做的事情。

抽象类中注意的问题：
一个类如果没有抽象方法，可以是抽象类，即抽象类中可以完全没有抽象方法。
这样类的主要目的就是不让创建该类对象。

abstract关键字不可以个那些关键字使用。
private 冲突；private修饰的成员不能被继承，从而不可以被子类重写，而abstract修饰的是要求被重写的。
final 冲突；final修饰的成员是最终成员，不能被重写，所以冲突，
static 无意义；static修饰成员用类名可以直接访问，但是abstract修饰成员没有方法体，所以访问没有方法体的成员无意义。

案例：定义一个动物类：

  1. package day09;
  3. public abstract class AnimalDe1 {
  4.     private String name;
  5.     private int age;
  7.     public AnimalDe1(){};
  8.     public AnimalDe1(String name,int age){
  9.         this.name=name;
  10.         this.age=age;
  11.     }
  13.     public String getName(){
  14.         return name;
  15.     }
  16.     public void setName(String name){
  17.         this.name=name;
  18.     }
  19.     public int getAge() {
  20.         return age;
  21.     }
  22.     public void setAge(int age) {
  23.         this.age = age;
  24.     }
  25.     public abstract void eat();
  27. }

定义一个狗类：

  1. package day09;
  3. public class DogDe1 extends AnimalDe1 {
  5.     public DogDe1(){}
  6.     public DogDe1(String name,int age){
  7.         super(name,age);
  8.     }
  9.     public void eat() {
  10.         System.out.println("狗吃肉！！！");
  11.     }
  13. }

定义一个猫类：

  1. package day09;
  3. public class CatDe1 extends AnimalDe1 {
  4.     public CatDe1(){}
  5.     public CatDe1(String name,int age){
  6.         super(name,age);
  7.     }
  8.     public void eat() {
  9.         System.out.println("猫吃鱼！！！");
  10.     }
  12. }

测试类： 

  1. package day09;
  3. public class MainDe1 {
  5.     /**
  6.      * @param args
  7.      */
  8.     public static void main(String[] args) {
  9.         DogDe1 dd = new DogDe1();//调用无参构造实现
  10.         dd.setName("狗狗1");
  11.         dd.setAge(2);
  12.         System.out.println(dd.getName()+"年龄："+dd.getAge());
  13.         dd.eat();
  14.         System.out.println("------------------");
  15.         DogDe1 dd1 = new DogDe1("狗狗2",3);//通过调用有参构造方法实现
  16.         System.out.println(dd1.getName()+"年龄："+dd1.getAge());
  17.         dd1.eat();
  18.         System.out.println("------------------");
  19.         AnimalDe1 dd2 = new DogDe1();//多态实现
  20.         dd2.setName("狗狗3");
  21.         dd2.setAge(4);
  22.         System.out.println(dd2.getName()+"年龄："+dd2.getAge());
  23.         dd2.eat();
  25.     }
  26.     //猫类同理！！
  28. }

输出：

狗狗1年龄：2
狗吃肉！！！
-————————-
狗狗2年龄：3
狗吃肉！！！
-————————-
狗狗3年龄：4
狗吃肉！！！

案例e2：

定义一个老师类：

  1. package day09;
  3. public abstract class Teacher {
  4.     private String name;
  5.     private int age;
  7.     public Teacher(){}
  8.     public Teacher(String name, int age){
  9.         this.name=name;
  10.         this.age=age;
  11.     }
  12.     public String getName() {
  13.         return name;
  14.     }
  15.     public void setName(String name) {
  16.         this.name = name;
  17.     }
  18.     public int getAge() {
  19.         return age;
  20.     }
  21.     public void setAge(int age) {
  22.         this.age = age;
  23.     }
  24.     public abstract void teach();
  25. }

定义一个基础老师类：

  1. package day09;
  3. public class BasicTeacher extends Teacher {
  4.     public BasicTeacher(){}
  5.     public BasicTeacher(String name,int age){
  6.         super(name,age);
  7.     }
  8.     public void teach() {
  9.        System.out.println("基础班"+super.getName()+"老师交基础课程！！");    
  10.     }
  13. }

定义一个高级老师类： 

  1. package day09;
  3. public class BasicTeacher extends Teacher {
  4.     public BasicTeacher(){}
  5.     public BasicTeacher(String name,int age){
  6.         super(name,age);
  7.     }
  8.     public void teach() {
  9.        System.out.println("基础班"+super.getName()+"老师交基础课程！！");    
  10.     }
  13. }

测试类：

  1. package day09;
  3. public class MainTeacher {
  5.     /**
  6.      * @param args
  7.      */
  8.     public static void main(String[] args) {
  9.         Teacher bt = new BasicTeacher();//实现多态
  10.         bt.setName("李春男");
  11.         bt.setAge(24);
  12.         System.out.println("姓名："+bt.getName()+",年龄："+bt.getAge());
  13.         bt.teach();
  14.         System.out.println("--------------");//
  15.         bt = new BasicTeacher("杨莉",24);//有参构造方法实现
  16.         System.out.println("姓名："+bt.getName()+",年龄："+bt.getAge());
  17.         bt.teach();
  18.         System.out.println("--------------");//
  19.         bt = new HighTeacher();//多态拓展，高级老师
  20.         bt.setName("李春男");
  21.         bt.setAge(24);
  22.         bt.teach();
  23.         System.out.println("--------------");//
  24.         bt = new HighTeacher("杨莉",24);//有参构造方法实现
  25.         System.out.println("姓名："+bt.getName()+",年龄："+bt.getAge());
  26.         bt.teach();
  27.     }
  29. }

输出：
姓名：李春男,年龄：24
基础班李春男老师交基础课程！！
-——————-
姓名：杨莉,年龄：24
基础班杨莉老师交基础课程！！
-——————-
高级班老师李春男交基础课程！！
-——————-
姓名：杨莉,年龄：24
高级班老师杨莉交基础课程！！

案例三：员工类：

  1. package day09;
  3. public abstract class Employee {
  4.     private String name;
  5.     private int id;
  6.     private int salary;
  8.     public Employee(){}
  9.     public Employee(String name,int id,int salary){
  10.         this.name=name;
  11.         this.id=id;
  12.         this.salary = salary;
  13.     }
  14.     public String getName() {
  15.         return name;
  16.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  20.     public int getId() {
  21.         return id;
  22.     }
  23.     public void setId(int id) {
  24.         this.id = id;
  25.     }
  26.     public int getSalary() {
  27.         return salary;
  28.     }
  29.     public void setSalary(int salary) {
  30.         this.salary = salary;
  31.     }
  32.     public abstract void work();
  34. }

程序员类： 

  1. package day09;
  3. public class Programer extends Employee {
  5.     public Programer(){}
  6.     public Programer(String name,int id,int salary){
  7.         super(name,id,salary);
  8.     }
  9.     public void work() {
  10.         System.out.println("根据需求写代码！");
  12.     }
  14. }

经理类： 

  1. package day09;
  3. public class Manager extends Employee {
  4.     private int bounds;//奖金
  6.     public Manager(){}//无参构造
  7.     public Manager(String name,int id,int salary,int bounds){//有参构造
  8.         super(name,id,salary);//传参
  9.         this.bounds=bounds;//传参
  10.     }
  11.     public void work() {
  12.         System.out.println("和客户谈需求！！！");
  13.     }
  14.     public int getBounds() {
  15.         return bounds;
  16.     }
  17.     public void setBounds(int bounds) {
  18.         this.bounds = bounds;
  19.     }
  21. }

测试类： 

  1. package day09;
  4. public class EmployeeMain {
  7.     /**
  8.      * @param args
  9.      */
  10.     public static void main(String[] args) {
  11.         //多态实现
  12.         Employee emp = new Programer();
  13.         emp.setName("李春男");
  14.         emp.setId(10001);
  15.         emp.setSalary(8000);
  16.         System.out.println("姓名："+emp.getName()+"编号："+emp.getId()+"薪金"+emp.getSalary());
  17.         emp.work();
  18.         System.out.println("********************************");
  19.         Employee emp1 = new Programer("李春男",10001,8000);
  20.         emp.setSalary(8000);
  21.         System.out.println("姓名："+emp.getName()+"编号："+emp.getId()+"薪金"+emp.getSalary());
  22.         emp.work();
  24.         //经理类
  25.        /* emp = new Manager();
  26.         emp.setName("杨莉");
  27.         emp.setId(2001);
  28.         emp.setSalary(6000);
  29.         //emp.setBounds(1100);//编译看左边，emp是父类对象引用，而bounds是子类中特有的成变量，所以不能访问，报
  32. 错！！
  33.        */    
  34.         //当遇到有子类特殊变量或者方法时，以上方式不可取，而是直接用具体的类创建对象
  36.         Manager man = new Manager();
  37.         man.setName("杨莉");
  38.         man.setId(2001);
  39.         man.setSalary(5000);
  40.         man.setBounds(1200);
  41.         System.out.println("姓名："+man.getName()+"编号："+man.getId()+"薪金"+man.getSalary());
  42.         man.work();
  43.         System.out.println("*********************************");
  44.         Manager man1 = new Manager("杨莉",2001,5000,1200);
  45.         System.out.println("姓名："+man1.getName()+"编号："+man1.getId()+"薪金"+man1.getSalary());
  46.         man1.work();
  47.     }
  50. }

输出：

姓名：李春男编号：10001薪金8000
根据需求写代码！
********************************
姓名：李春男编号：10001薪金8000
根据需求写代码！
姓名：杨莉编号：2001薪金5000
和客户谈需求！！！
*********************************
姓名：杨莉编号：2001薪金5000
和客户谈需求！！！

发表评论

表情：
评论列表 （有 0 条评论，361人围观）

还没有评论，来说两句吧...

相关阅读

    相关 JAVA抽象类、抽象方法

    类的继承的作用主要在于可以扩充已有类的功能，子类继承后可以任意选择是否实现父类的方法，想实现就实现，不想实现就不实现。换句话说，父类无法对子类是否实现自己的某个方法做强制的约定

    小咪咪小咪咪/ 0 赞/ 120 阅读

    相关 java抽象和抽象类

    先来说一下抽象与接口的区别：抽象类表示该类中可能已经有一些方法的具体定义，但是接口就仅仅只能定义各个方法的界面(方法名，参数列表，返回类型)，并不关心具体细节。 jav

    Bertha 。Bertha 。/ 0 赞/ 377 阅读

    相关 java-抽象类

    抽象类 怎样理解抽象类： 打个形象的比喻： 我们以前定义一个动物类，动物有吃的行为，但是我们没有指定这是哪个动物（不是一个具体的事物），而且动物吃的行为也不知道是哪种

    约定不等于承诺〃约定不等于承诺〃/ 0 赞/ 362 阅读

    相关 Java 抽象类

    通过继承，子类获得父类的变量和方法。 在Java中，只声明而没有实现的方法称为抽象方法，其语法规则如下： abstract <返回值类型> <抽象方法名>(\[<形式参数列

    旧城等待，旧城等待，/ 0 赞/ 394 阅读

    相关 Java抽象类

    1、特点 a、抽象类和抽象方法必须用abstract来修饰。抽象方法不能有主体（只写名字，不加大括号\{\}） b、抽象类中不一定有抽象方法，但是抽象方法必须在抽象类中

    港控/mmm°港控/mmm°/ 0 赞/ 278 阅读

    相关 Java 抽象类

    在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 ...

    灰太狼灰太狼/ 0 赞/ 2359 阅读