利用继承和多态，规避GreenDao数据类无法继承字段

有个内核SDK的数据类型A，其中有些字段。
还有基于A的数据类型B，继承复用A的字段，需要所有字段存在GreenDao数据库中，。
直接继承的话，GreenDao会忽视父类的字段。

我想到workaround方案就是子类需要父类的那些字段，就写上同名字段，这样GreenDao生成的子类get方法，可以同时被SDK内和上层调用。
同时上层和sdk互相传递数据也不用转换或者复制。

    class Parent {
        int i = 3;

        @Override
        public String toString() {
            return "Parent{" +
                    "i=" + i +
                    '}';
        }

        String getStrPub() {
            return "parent";
        }

        private String getStrPri() {
            return "parent-private";
        }
    }

    class Child extends Parent {
        int i = 5;

        @Override
        public String toString() {
            return "Child{" +
                    "super.i=" + super.i +
                    ", i=" + i +
                    '}';
        }

        public String getStrPub() {
            return "Child";
        }

        private String getStrPri() {
            return "Child-private";
        }
    }

    public void test() {
        Parent parent = new Parent();
        Parent teen = new Child();
        Child child = new Child();

        //child has both parent and self variable
        System.out.println(parent + " " + parent.i);
        System.out.println(teen + " " + teen.i);// if announce by parent, call it`s variable is parent`s
        System.out.println(child + " " + child.i);

        teen.i = 7;
        System.out.println("\n" + teen + " " + teen.i + " " + ((Child)teen).i);

        //child has only self`s method. Override
        System.out.println(parent.getStrPub() + " " + parent.getStrPri());
        System.out.println(teen.getStrPub() + " " + teen.getStrPri());// if announce by parent, call it`s method is parent`s.
        System.out.println(child.getStrPub() + " " + child.getStrPri());
    }

Parent{i=3} 3
Child{super.i=3, i=5} 3
Child{super.i=3, i=5} 5

Child{super.i=7, i=5} 7 5
parent parent-private
Child parent-private
Child Child-private

子类和父类同名同类型的属性，实际上并列存在于子类对象中，对象声明是父或子，调用时就调用对应父或子的字段。
子类和父类同名的非private方法，会覆盖。private方法无法覆盖，会并列存在。

父类的属性，体现的是 封装。
子类继承，体现的是 继承。
在父类sdk中，调用public get方法，实际调用的是子类的方法，并且SDK只有运行时才知道调用的是哪个子类的方法， 体现的是 多态。

这里引用一位博主的一段话

作者：jianyuerensheng
来源：CSDN
原文：https://blog.csdn.net/jianyuerensheng/article/details/51602015

在这里我们需要明确，继承存在如下缺陷：

1、父类变，子类就必须变。

2、继承破坏了封装，对于父类而言，它的实现细节对与子类来说都是透明的。

3、继承是一种强耦合关系。

所以说当我们使用继承的时候，我们需要确信使用继承确实是有效可行的办法。那么到底要不要使用继承呢？《Think in java》中提供了解决办法：问一问自己是否需要从子类向父类进行向上转型。如果必须向上转型，则继承是必要的，但是如果不需要，则应当好好考虑自己是否需要继承。