Java StackOverflower在android中为类编写包裹时出错

我有一个班叫学生。在这个类中，我有一个相同类（即学生类）的对象字段。当我将这个类对象作为包裹发送到我的应用程序的另一个组件时。它抛出堆栈溢出错误

所以我的问题是，我怎样才能使包含同一类字段的类成为可包裹的类。 这是我的密码

import android.os.Parcel;
import android.os.Parcelable;

import java.util.ArrayList;

public class Chapter implements Parcelable{
    private String chapterId;
    private String chapterNumber;
    private String chapterName;
    private String src;
    private int startTime;
    private int endTime;
    private Chapter parentChapter;
    private ArrayList<Chapter> chapterList;


    public Chapter(){}

    protected Chapter(Parcel in) {
        chapterId = in.readString();
        chapterNumber = in.readString();
        chapterName = in.readString();
        src = in.readString();
        startTime = in.readInt();
        endTime = in.readInt();
        parentChapter = in.readParcelable(Chapter.class.getClassLoader());
        chapterList = in.createTypedArrayList(Chapter.CREATOR);
    }

    public static final Creator<Chapter> CREATOR = new Creator<Chapter>() {
        @Override
        public Chapter createFromParcel(Parcel in) {
            return new Chapter(in);
        }

        @Override
        public Chapter[] newArray(int size) {
            return new Chapter[size];
        }
    };

    String getChapterName() {
        return chapterName;
    }

    void setChapterName(String chapterName) {
        this.chapterName = chapterName;
    }

    public String getSrc() {
        return src;
    }

    public void setSrc(String src) {
        this.src = src;
    }

    void setChapterNumber(String chapterNumber) {
        this.chapterNumber = chapterNumber;
    }

    void setChapterId(String chapterId) {
        this.chapterId = chapterId;
    }

    ArrayList<Chapter> getChapterList() {
        return chapterList;
    }

    void setChapterList(ArrayList<Chapter> chapterList) {
        this.chapterList = chapterList;
    }

    public int getStartTime() {
        return startTime;
    }

    public void setStartTime(int startTime) {
        this.startTime = startTime;
    }

    void setEndTime(int endTime) {
        this.endTime = endTime;
    }

    public Chapter getParentChapter() {
        return parentChapter;
    }

    public void setParentChapter(Chapter parentChapter) {
        this.parentChapter = parentChapter;
    }


    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(chapterId);
        dest.writeString(chapterNumber);
        dest.writeString(chapterName);
        dest.writeString(src);
        dest.writeInt(startTime);
        dest.writeInt(endTime);
        dest.writeParcelable(parentChapter, flags);
        dest.writeTypedList(chapterList);
    }
}

导入android.os.packet；
导入android.os.Parcelable；
导入java.util.ArrayList；
公共类章节实现了Parcelable{
私有字符串章；
私有字符串chapterNumber；
私有字符串chapterName；
私有字符串src；
私人内部启动时间；
私有内部结束时间；
私人章节家长章节；
私有ArrayList章节列表；
公共章（）{}
受保护章节（包裹中）{
chapterId=in.readString（）；
chapterNumber=in.readString（）；
chapterName=in.readString（）；
src=in.readString（）；
startTime=in.readInt（）；
endTime=in.readInt（）；
parentChapter=in.readParcelable（Chapter.class.getClassLoader（））；
chapterList=in.createTypedArrayList（Chapter.CREATOR）；
}
公共静态最终创建者=新创建者（）{
@凌驾
公共章createFromParcel（地块中）{
返回新章节（中）；
}
@凌驾
公共章[]新数组（整数大小）{
返回新章节[大小]；
}
};
字符串getChapterName（）{
返回chapterName；
}
void setChapterName（字符串chapterName）{
this.chapterName=chapterName；
}
公共字符串getSrc（）{
返回src；
}
公共void setSrc（字符串src）{
this.src=src；
}
void setChapterNumber（字符串chapterNumber）{
this.chapterNumber=chapterNumber；
}
void setChapterId（字符串chapterId）{
this.chapterId=chapterId；
}
ArrayList getChapterList（）{
返回章节列表；
}
void setChapterList（ArrayList chapterList）{
this.chapterList=chapterList；
}
public int getStartTime（）{
返回起始时间；
}
公共无效设置开始时间（int startTime）{
this.startTime=startTime；
}
void setEndTime（int endTime）{
this.endTime=endTime；
}
公共章节getParentChapter（）{
返回父母章节；
}
公共无效setParentChapter（第parentChapter章）{
this.parentChapter=parentChapter；
}
@凌驾
公共int描述内容（）{
返回0；
}
@凌驾
公共无效写入包裹（包裹目的地，内部标志）{
目的地书面限制（第三章）；
目的地书面记录（章号）；
目的地书面记录（章名）；
目的地书面限制（src）；
目的写入（开始时间）；
目的写入（结束时间）；
目的地可写可强制（父章、标志）；
目的地writeTypedList（章节列表）；
}
}

删除

dest.writeparceable（父章节，标志）

加

chapterList = in.createTypedArrayList(Chapter.CREATOR);

for( Chapter c : chapterList ) {
  c.setParentChapter(this);
}