1、抽象实体类
1 package com.cn.donleo.test.model;
2
3 /**
4 * @author liangd
5 * date 2020-10-22 16:40
6 * code 员工抽象类
7 */
8 public abstract class AbstractEmployee {
9 /**
10 * 姓名
11 */
12 protected String name;
13 /**
14 * 性别
15 */
16 protected boolean sex;
17 /**
18 * 年龄
19 */
20 protected Integer age;
21
22 /**
23 * 构造方法
24 * @param name
25 * @param sex
26 */
27 public AbstractEmployee(String name, boolean sex) {
28 this.name = name;
29 this.sex = sex;
30 }
31
32 /**
33 * 定义抽象方法
34 * @return
35 */
36 public abstract void getSalary();
37
38 /**
39 * 定义普通方法
40 */
41 public void getUser(){
42 System.out.println("父类非抽象方法-----员工");
43 }
44
45 }
2、继承抽象类一
1 package com.cn.donleo.test.model;
2
3 /**
4 * @author liangd
5 * date 2020-10-22 17:01
6 * code 会计实体类
7 */
8 public class Accouting extends AbstractEmployee {
9 /**
10 * 构造方法
11 *
12 * @param name
13 * @param sex
14 */
15 public Accouting(String name, boolean sex) {
16 super(name, sex);
17 }
18
19 /**
20 * 重写父类抽象方法，一定会被继承
21 */
22 @Override
23 public void getSalary() {
24 System.out.println("会计领了7000工资");
25 }
26
27 /**
28 * 重写非抽象的父类方法，可以不继承
29 */
30 public void getAccounting(){
31 System.out.println("子类非抽象方法------会计");
32 }
33 }
3、继承抽象类二
1 package com.cn.donleo.test.model;
2
3 /**
4 * @author liangd
5 * date 2020-10-22 16:51
6 * code 员工类
7 */
8 public class Manager extends AbstractEmployee{
9 /**
10 * 由于定义了带参数的构造方法，默认不带参数的构造方法失效，需要继承下来
11 *
12 * @param name
13 * @param sex
14 */
15 public Manager(String name, boolean sex) {
16 super(name, sex);
17 }
18
19 /**
20 * 子类继承父类抽象方法，需要重写
21 */
22 @Override
23 public void getSalary() {
24 System.out.println("经理领了8000工资");
25 }
26
27 /**
28 * 重写父类非抽象方法
29 */
30 public void getManager(){
31 //显示父类姓名
32 System.out.println("子类非抽象方法------经理");
33 }
34
35 }
4、测试类
1 package com.cn.donleo.test;
2
3 import com.cn.donleo.test.model.AbstractEmployee;
4 import com.cn.donleo.test.model.Accouting;
5 import com.cn.donleo.test.model.Manager;
6
7 /**
8 * @author liangd
9 * date 2020-10-22 17:06
10 * code 测试抽象类
11 */
12 public class TestAbstract {
13 /*
14 一、对抽象类的理解：
15 1、抽象类里面是不是全是抽象方法？ 不是，可以有普通方法
16 2、有抽象方法的类是不是一定是抽象类？ 是，有抽象方法类名必须加abstract
17 3、抽象类是不是必须有抽象方法？ 不是必须的
18 二、对接口的理解
19 1、接口是一个特殊的抽象类
20 2、接口中的方法可以不加修饰符
21 */
22
23 /**
24 * 抽象类和接口的区别
25 * 一、抽象类
26 * 1、抽象类使用abstract修饰；
27 * 2、抽象类不能实例化，即不能使用new关键字来实例化对象；
28 * 3、含有抽象方法（使用abstract关键字修饰的方法）的类是抽象类，必须使用abstract关键字修饰；
29 * 4、抽象类可以含有抽象方法，也可以不包含抽象方法，抽象类中可以有具体的方法；
30 * 5、如果一个子类实现了父类（抽象类）的所有抽象方法，那么该子类可以不必是抽象类，否则就是抽象类；
31 * 6、抽象类中的抽象方法只有方法体，没有具体实现
32 * 二、接口
33 * 1、接口使用interface修饰；
34 * 2、接口不能被实例化；
35 * 3、一个类只能继承一个类，但是可以实现多个接口；
36 * 4、接口中方法均为抽象方法；
37 * 5、接口中不能包含实例域或静态方法（静态方法必须实现，接口中方法是抽象方法，不能实现）
38 */
39
40 public static void main(String[] args){
41 String name = "liand";
42 boolean sex = false;
43 AbstractEmployee abstractEmployee = new AbstractEmployee(name,sex) {
44 @Override
45 public void getSalary() {
46 System.out.println("父类抽象方法---");
47 }
48 };
49 //打印父类非抽象方法
50 abstractEmployee.getUser();
51
52 //Manager和Accounting都是继承AbstractEmployee类，实现多态
53 Manager manager = new Manager(name,sex);
54 manager.getSalary();
55 manager.getManager();
56
57 Accouting accouting = new Accouting(name,sex);
58 accouting.getSalary();
59 accouting.getAccounting();
60 }
61
62 }
