java - オブジェクト指向設計/クラス構造の設定方法

Question

私はオブジェクト指向プログラミングにかなり慣れていないので、この問題を解決する方法を高レベルで知りたいと思っています。

仕事のカレンダー、個人のカレンダー、スポーツのカレンダーなど、さまざまなカレンダーのリストがあり、それぞれに独自のイベントがあるとします。カレンダークラスがあり、ネストされたクラスがイベントクラスになると仮定します。すべてのカレンダーのすべてのイベントを 1 つのリストに表示したいので、それらはすべて並べ替えられた配列になります。しかし、仕事のカレンダーのようなカレンダーの 1 つを削除したいとしましょう。このリスト/配列からすべての仕事のイベントが確実に削除されるようにするにはどうすればよいでしょうか。このクラス構造が高いレベルでどのように設定されるのか興味があります。どんな助けでも大歓迎です。

score 1 · Accepted Answer

これが私がそれを行う方法です。強調表示された部分は私が取り上げるものです:

calendars、、、work calendarなどpersonal calendarの異なるリストがありsports calendars、それぞれに独自のevents. すべてのカレンダーのすべてのイベントを 1 つに表示したいので、listそれらはすべて並べ替えられた配列になります。しかし、このリスト/配列からdelete one of my calendarsすべてを確認するにはどうすればよいでしょうか。work events were deleted

それは私に与えます：

emum CalendarType
{
    WORK,
    PERSONAL,
    SPORT,
}

class Event
{
    // event data, like time, place, people, etc...
    private Calendar owner;
}

class Calendar
{
    private CalendarType type; // or make this a String and get rid of the enum 
                               // if people can make their own types
    private List<Event> event;s
}

すべてのイベントを 1 つのリストにまとめて、カレンダーが少し難しいときにそれらを削除したいという部分。

私がすることは、CalendarUtilsクラスに次のようなメソッドを追加することだと思います:

public static void deleteEvents(Calendar c, List<Event> events)
{
    // loop through all the events, for each one from the calendar remove it
}

score 0 · Accepted Answer

私があなたの要求を実行する場合、次のラインナップがあります。

interface Calendar 
class DefaultCalendar implements Calendar //<- default implementation for calendar. will hold the implementation for the common behavior for all the calendars
class PersonalCalendar implements Calendar //<- implementation for calendar that holds personal events, decorator for DefaultCalendar
class SportsCalendar implements Calendar //<- implementation for calendar that holds sports events, decorator for DefaultCalendar
class WorkCalendar implements Calendar //<- implementation for calendar that holds work events, decorator for DefaultCalendar
class Event //<- the event object, setters & getters
class CalendarManager //<- object for adding, removing calendars

配置されるイベントの自然な順序を利用するためにTreeMap実装されている whichを使用します。SortedMap

Map<String, Calendar> calendars = new TreeMap<String, Calendar>();

また、イベント名の先頭にカレンダー固有の単語を追加して、表示時にイベントをカレンダーの種類 (イベントの種類) ごとにグループ化します。

@Override public void addEvent(Event event){
    //event.setName("Work Event : " + event.getEventName()); for work event
    //event.setName("Sports Event : " + event.getEventName()); for sports event
    //event.setName("Personal Event : " + event.getEventName()); for personal event
    calendar.addEvent(event);
}

したがって、マネージャーがすべてのイベントを表示するように求められると、次のようになります。

Personal Event : blah blah blah abc 123
Personal Event : blah blah blah abc 123
Sports Event : blah blah blah abc 123
Work Event : blah blah blah abc 123

さて、私が言っていることを実証するために、ここに私の実行可能なコードがあります

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.TreeMap;

/* the demo class */

public class CalendarDemo {
    public static void main(String[] args) throws ParseException{
        CalendarManager manager = new CalendarManager();

        Calendar mySportsCalendar = new SportsCalendar(new DefaultCalendar());
        Calendar myWorkCalendar = new WorkCalendar(new DefaultCalendar());
        Calendar myPersonalCalendar = new PersonalCalendar(new DefaultCalendar());

        Event myBirthday = new Event("My 23rd Birthday Celebration", "September 17, 2013", "This marks my 23rd birthday celebration!");
        Event myMothersBirthday = new Event("My Mother's 50th Birthday Celebration", "December 19, 2013", "This marks my mothers 50th birthday celebration!");

        Event tennisGame = new Event("Tennis Game With Denver", "August 11, 2013", "3rd tennis game with my nephew.");

        Event newProjectMeeting = new Event("New Project Meeting", "August 11, 2013", "Meeting with our new project.");

        myPersonalCalendar.addEvent(myBirthday);
        myPersonalCalendar.addEvent(myMothersBirthday);
        myWorkCalendar.addEvent(newProjectMeeting);
        mySportsCalendar.addEvent(tennisGame);

        manager.addCalendar("sportsCalendar", mySportsCalendar);
        manager.addCalendar("workCalendar", myWorkCalendar);
        manager.addCalendar("personalCalendar", myPersonalCalendar);

        System.out.println("Before the removal of personal calendar : ");
        System.out.println("--------------------------------------------------------------------------------");
        System.out.println(manager.displayAllCalendarEvents());

        manager.removeCalendar("personalCalendar"); //<- will delete all the events in personalCalendar;

        System.out.println("After the removal of personal calendar : ");
        System.out.println("--------------------------------------------------------------------------------");
        System.out.println(manager.displayAllCalendarEvents());
    }
}

/* the calendar interface */

interface Calendar{
    Event getEvent(String eventName);
    List<Event> getEvents();
    void addEvent(Event event);
    String getDescription();
    void setDescription(String desc);
}

/* the default implementation of calendar */

class DefaultCalendar implements Calendar{

    private List<Event> events;
    private String description;

    public DefaultCalendar(){
        events = new ArrayList<Event>();
    }

    @Override public Event getEvent(String eventName) {

        for(Event event : events){
            if(event.getEventName().equals(eventName))
                return event;
        }

        throw new IllegalArgumentException("Event name does not exist in the event list.");
    }

    @Override public void addEvent(Event event) {
        events.add(event);
    }

    @Override public String getDescription(){
        return description;
    }

    @Override public void setDescription(String desc){
        description = desc;
    }

    @Override public List<Event> getEvents() {
        return events;
    }
}

/* decorators for defaultcalendar. If you want
 * specific behavior for a specific calendar, you can
 * specify it in these classes.
 * ---------------------------------------------- */

class SportsCalendar implements Calendar{

    private Calendar calendar;

    public SportsCalendar(Calendar baseCalendar){
        calendar = baseCalendar;
    }

    @Override public String getDescription(){
        return calendar.getDescription();
    }

    @Override public void addEvent(Event event){
        event.setEventName("Sports Event : " + event.getEventName());
        calendar.addEvent(event);
    }

    @Override public Event getEvent(String eventName) {
        return calendar.getEvent("Sports Event : " + eventName);
    }

    @Override public void setDescription(String desc) {

        //do something to the passed desc
        //...
        //then pass it to the wrapped calendar;

        calendar.setDescription(desc);
    }

    @Override public List<Event> getEvents() {
        return calendar.getEvents();
    }
}

/* another decorator */

class WorkCalendar implements Calendar{

    private Calendar calendar;

    public WorkCalendar(Calendar baseCalendar){
        calendar = baseCalendar;
    }

    @Override public String getDescription(){
        return calendar.getDescription();
    }

    @Override public void addEvent(Event event){
        event.setEventName("Work Event : " + event.getEventName());
        calendar.addEvent(event);
    }

    @Override public Event getEvent(String eventName) {
        return calendar.getEvent("Work Event : " + eventName);
    }

    @Override public void setDescription(String desc){

        //do something to the passed desc
        //...
        //then pass it to the wrapped calendar;

        calendar.setDescription(desc);
    }

    @Override public List<Event> getEvents() {
        return calendar.getEvents();
    }
}

/* another decorator */

class PersonalCalendar implements Calendar{

    private Calendar calendar;

    public PersonalCalendar(Calendar baseCalendar){
        calendar = baseCalendar;
    }

    @Override public String getDescription(){
        return calendar.getDescription();
    }

    @Override public void addEvent(Event event){
        event.setEventName("Personal Event : " + event.getEventName());
        calendar.addEvent(event);
    }

    @Override public Event getEvent(String eventName) {
        return calendar.getEvent("Personal Event : " + eventName);
    }

    @Override public void setDescription(String desc) {

        //do something to the passed desc
        //...
        //then pass it to the wrapped calendar;

        calendar.setDescription(desc);
    }

    @Override public List<Event> getEvents() {
        return calendar.getEvents();
    }
}

/* the calendar manager, for adding & removing calendars */

class CalendarManager{

    private Map<String, Calendar> calendars;

    public CalendarManager(){
        calendars = new TreeMap<String, Calendar>();
    }

    public void addCalendar(String key, Calendar calendar){
        calendars.put(key, calendar);
    }

    public void removeCalendar(String key){
        calendars.remove(key);
    }

    public String displayAllCalendarEvents(){
        StringBuilder bdr = new StringBuilder();

        for(String key : calendars.keySet()){
            for(Event event : calendars.get(key).getEvents()){
                bdr.append(event.getEventName())
                .append("\t")
                .append(event.getEventDate())
                .append("\t")
                .append(event.getEventDescription())
                .append("\n");
            }
        }

        return bdr.toString();
    }
}

/* the event object */

class Event{

    private String name;
    private Date date;
    private String description;

    public Event(String name, String date, String description){
        this.name = name;
        try {
            this.date = new SimpleDateFormat("MMMM d, yyyy", Locale.ENGLISH).parse("December 19, 2013");
        } catch (ParseException e) {
            throw new IllegalArgumentException("Invalid date format!");
        }
        this.description = description;
    }

    public String getEventName() {
        return name;
    }

    public Date getEventDate() {
        return date;
    }

    public String getEventDescription() {
        return description;
    }

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

    public void setEventDate(String date) {
        try {
            this.date = new SimpleDateFormat("MMMM d, yyyy", Locale.ENGLISH).parse("December 19, 2013");
        } catch (ParseException e) {
            throw new IllegalArgumentException("Invalid date format!");
        }
    }

    public void setEventDescription(String description) {
        this.description = description;
    }
}

score 0 · Accepted Answer

クラスをネストする必要は必ずしもありません。MadProgrammer が示唆していたように、イベントである 1 つのクラスを作成し、それを Calendar クラスに実装し、必要に応じて使用します。カレンダーを削除したい場合は、そのカレンダー内のすべてのイベントを確実に削除するメソッドを含めることができます。しかし、カレンダーオブジェクトを削除するだけでうまくいくはずです。

score 0 · Accepted Answer

public abstract class BaseCalendar{//do some common functionality here or define the abstract methods so child class will provide the implementation }
public class WorkCalendar extends BaseCalendar{//do WorkCalendar specific functionality here}
public class PersonalCalendar extends BaseCalendar{//do Personalcalendar specific functionality here}
public class SportsCalendar extends BaseCalendar{//do Sportscalendar specific functionality here}
create another class for Events and create list of events for each calendar(use aggrgation here, once your calendar is destroyed your events will also destroyed)

これは、各カレンダーの動作が異なる場合に私が取るアプローチになります。

java - オブジェクト指向設計/クラス構造の設定方法

4 に答える 4

Related

Reference