Enregistrer JTable au format binaire

Bonjour,

Je fait une application de gestion et je bloque sur plusieurs points:
- Quand je coche sur samedi ou dimanche dans mon planning, je voudrais colorier les colonnes samedi ou dimanche et les rendre non éditable
- Quand je suis sur le formulaire de choix d'une année, je souhaiterais placer le label au dessus de la liste
- Quand je suis sur mon planning et que je vais dans mon menu et que je fait nouveau, le formulaire s'affiche derrière la JTable au lieu de supprimer la JTable et d'afficher le formulaire à la place
- Quand je clique sur Sauvegarder dans mon menu je souhaiterait enregistrer ma JTable au format binaire en y conservant les différentes données
- Quand je clique sur Ouvrir dans mon menu, je souhaiterait ouvrir mon planning tel qu'il a été sauvegarder par la fonctionnalité ci-dessus.
- Je vois pas également comment séparer le model (données) de la vue/controlleur
Voici le code de mon application:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
public class MenuBar extends JMenuBar implements ActionListener {
	/**
         * serialVersionUID
         */
	private static final long serialVersionUID = 1L;
	private JMenuBar barreMenu;
	private JMenu fichier, edition;
	private JMenuItem ouvrir, nouveau, sauvegarder, fermer, copier, coller;
	private ChoixAnnee choixAnnee;
	private Accueil frameAccueil;
	private Serialiser serialise;
	public MenuBar(Accueil accueil){
		this.frameAccueil = accueil;
		barreMenu = this;
		fichier = new JMenu("Fichier");
		barreMenu.add(fichier);
		nouveau = new JMenuItem("Nouveau");
		fichier.add(nouveau);
		nouveau.addActionListener(this);
		ouvrir = new JMenuItem("Ouvrir");
		fichier.add(ouvrir);
		sauvegarder = new JMenuItem("Sauvegarder");
		fichier.add(sauvegarder);
		sauvegarder.addActionListener(this);
		fermer = new JMenuItem("Fermer");
		fichier.add(fermer);
		edition = new JMenu("Edition");
		barreMenu.add(edition);
		copier = new JMenuItem("Copier");
		edition.add(copier);
		coller = new JMenuItem("Coller");
		edition.add(coller);
 
	}
 
	public void actionPerformed(ActionEvent event) {
		Object source = event.getSource();
 
		if (source.equals(nouveau)) {
			choixAnnee = new ChoixAnnee();
			frameAccueil.add(choixAnnee);
			this.updateUI();
		}
 
		if(source.equals(sauvegarder)){
		    JFileChooser chooser = new JFileChooser();
		    chooser.setCurrentDirectory(new File("/Documents"));
		    int retrival = chooser.showSaveDialog(null);
		    if (retrival == JFileChooser.APPROVE_OPTION) {
		        try {
		            String fw = (chooser.getSelectedFile()+".bin");
					serialise = new Serialiser(fw);
					CalendarWeekViewer calendrier = null;
					serialise.serialiser(calendrier);
		            //fw.write(sb.toString());
		        } catch (Exception ex) {
		            ex.printStackTrace();
		        }
		    }		
		}
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Accueil extends JFrame{
	/**
         * serialVersionUID
         */
	private static final long serialVersionUID = 1L;
	private MenuBar barreMenu;
	public Accueil(){
		setTitle("Gestion d'emploi du temps");
		initUI();
	}
 
	private void initUI() {
		//Permet de récupérer la taille de l'écran pour afficher l'application sur tout l'écran
		setExtendedState(JFrame.MAXIMIZED_BOTH);
 
		barreMenu = new MenuBar(this);
		setJMenuBar(barreMenu);
	}
 
	public static void main(String[] args) {
    	Accueil frame = new Accueil();
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    	frame.setVisible(true);
    }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public class ChoixAnnee extends JPanel implements ActionListener{
	/**
         * serialVersionUID
         */
	private static final long serialVersionUID = 1L;
	private JList liste;
    private String[] annee = {"2010-2011", "2011-2012", "2012-2013", "2013-2014",
    "2014-2015", "2015-2016", "2016-2017", "2017-2018", "2018-2019", "2019-2020"};
    private JButton creer;
    private JPanel panneau1;
    private JLabel label;
    private CalendarWeekViewer calendrier;
    public ChoixAnnee(){
    	panneau1 = new JPanel();
    	liste = new JList(annee);
    	creer = new JButton("Créer le calendrier");
    	label = new JLabel("Veuillez choisir une année scolaire pour créer le planning");
        label.setFont(new Font(null, Font.BOLD, 16));
    	liste.setSelectedIndex(5);
    	liste.setSelectionMode(ListSelectionModel.SINGLE_SELECTION) ;
    	JScrollPane ascenseur = new JScrollPane(liste);
    	ascenseur.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
    	panneau1.setLayout(new BorderLayout());
    	panneau1.add(BorderLayout.CENTER, ascenseur);
    	panneau1.add(BorderLayout.SOUTH, creer);
    	this.add(label);
    	this.add(panneau1);
    	creer.addActionListener(this);
    }
 
    public void actionPerformed(ActionEvent event) {
		Object source = event.getSource();
 
		if (source.equals(creer)) {
            Object valeur = liste.getSelectedValue();
			Annee annee = new Annee();
			String uneAnnee = annee.convertirUneAnnee(valeur.toString());
			this.removeAll();
			calendrier = new CalendarWeekViewer(uneAnnee);
			JPanel panneau = new JPanel();
			panneau.setLayout(new BorderLayout());
			panneau.add(calendrier);
			this.add(panneau);
			this.revalidate();
			this.repaint();
		}
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
public class CalendarWeekViewer extends JPanel implements ActionListener, ItemListener {
 
    /**
         * serialVersionUID
         */
	private static final long serialVersionUID = 1L;
	Calendar calendar;
    DateFormat dateFormatter;
 
    CalendarWeekTableModel tableModel;
 
    JLabel monthLabel, yearLabel;
    JTable table;
    int anneeChoisit;
    int anneeActuelle;
    int anneeDefinitif = 0;
    private WeekPanel weekPanel;
	private JCheckBox saturdayCheck;
	private JCheckBox sundayCheck;
	private final static Color COLOR_SELECTION = Color.GRAY;
 
	public CalendarWeekViewer(String uneAnnee) {
		Annee annee = new Annee();
		anneeChoisit = annee.anneeChoisit(uneAnnee);
 
        calendar = Calendar.getInstance();
		anneeActuelle = calendar.get(Calendar.YEAR);
		if(anneeActuelle < anneeChoisit){
			anneeDefinitif = anneeChoisit - anneeActuelle; 
			calendar.add(Calendar.YEAR, +anneeDefinitif);
		}else if(anneeActuelle > anneeChoisit){
			anneeDefinitif = anneeActuelle - anneeChoisit;
			calendar.add(Calendar.YEAR, -anneeDefinitif);
		}else{
			calendar.add(Calendar.YEAR, 0);
		}
 
        calendar.set(Calendar.MONTH,Calendar.SEPTEMBER); // on se positionne sur le mois de septembre (le début de notre liste de semaines)    	   
        calendar.set(Calendar.WEEK_OF_MONTH, 1); // on se positionne sur la première semaine du mois
        calendar.set(Calendar.DAY_OF_WEEK, calendar.getFirstDayOfWeek()); // on se positionne sur le premier jour officiel
 
        dateFormatter = new SimpleDateFormat("MMMM yyyy");
        createComponents();
    }
 
    private void createComponents() {
    	JLabel holidays = new JLabel("Jours Non-ouvrés");
    	holidays.setFont(new Font(null, Font.BOLD, 12));
    	JPanel checkBox = new JPanel();
    	checkBox.add(holidays);
    	saturdayCheck = new JCheckBox("Samedi");
    	sundayCheck = new JCheckBox("Dimanche");
    	checkBox.add(saturdayCheck);
    	checkBox.add(sundayCheck);
 
    	saturdayCheck.addItemListener(this);
    	sundayCheck.addItemListener(this);
        yearLabel = new JLabel("Année : "+anneeChoisit+ "-"+(anneeChoisit+1));
        yearLabel.setFont(new Font(null, Font.BOLD, 20));
 
        monthLabel = new JLabel(getWeekLabel());
        monthLabel.setFont(new Font(null, Font.PLAIN, 18));
        monthLabel.setVerticalAlignment(JLabel.CENTER);
        monthLabel.setHorizontalAlignment(JLabel.CENTER);
 
        tableModel = new CalendarWeekTableModel(calendar);
        table = new JTable((TableModel)tableModel);
        table.setPreferredScrollableViewportSize(new Dimension(1400, 600));
        table.setDefaultRenderer(String.class, new CalendarWeekRenderer());
        table.setRowHeight(200);
        TableColumnModel tableColumnModel = table.getColumnModel();
 
        for (int i=0; i < tableColumnModel.getColumnCount(); ++i) {
            TableColumn tableColumn = tableColumnModel.getColumn(i);
            tableColumn.setPreferredWidth(200);
        }
 
        JScrollPane tableScrollPane = new JScrollPane(table);
 
        JPanel southPanel = new JPanel(new BorderLayout()); // le panel intermédiaire
 
        // on créé le weekPanel	
        weekPanel = new WeekPanel(this, calendar, anneeActuelle, anneeChoisit);
        // on met le weekPanel dans le panel intermédiaire
        southPanel.add(weekPanel, BorderLayout.SOUTH);
        JPanel panneau1 = new JPanel(new BorderLayout());
        panneau1.setPreferredSize(new Dimension(1400, 600));
        panneau1.add(monthLabel, BorderLayout.NORTH);
        panneau1.add(tableScrollPane, BorderLayout.CENTER);
        panneau1.add(southPanel, BorderLayout.SOUTH);
        JPanel panneau3 = new JPanel(new BorderLayout());
        JPanel panneau2 = new JPanel(new BorderLayout());
        panneau2.add(yearLabel, BorderLayout.WEST);
        panneau2.add(checkBox, BorderLayout.EAST);
        panneau3.add(panneau2, BorderLayout.NORTH);
        panneau3.add(panneau1);
        this.add(panneau3);
    }
 
    public void setWeek(Calendar selection) {
    	calendar.setTime( selection.getTime());
            monthLabel.setText(getWeekLabel());
        	tableModel.fireTableStructureChanged(); 
        	weekPanel.updateSelection();
    }
 
    private String getWeekLabel() {
 
    	Calendar calendar = Calendar.getInstance(); // on créé un nouveau calendar pour pas modifier le calendar qui nous sert pour savoir quelle semaine on affiche
    	calendar.setTime(this.calendar.getTime()); // on recopie dedans la date actuellement mise dans le calendar qui ser pour savoir quelle semaine on affiche
 
    	int week = calendar.get(Calendar.WEEK_OF_YEAR); // on récupère le numéro de la semaine
 
        // le premier jour de cette semaine
    	Date premierJour = calendar.getTime();
    	int monthPremierJour = calendar.get(Calendar.MONTH); // bug ici (il y avait int monthPremierJour = calendar.get(Calendar.MONDAY); donc n'importe quoi)!!!
 
        // le dernier jour de cette semaine
    	calendar.add(Calendar.WEEK_OF_YEAR, 1);
    	calendar.add(Calendar.DAY_OF_WEEK, -1);
    	Date dernierJour = calendar.getTime();
 
    	int monthDernierJour = calendar.get(Calendar.MONTH);
 
    	return WeekPanel.getWeekLabel(week, premierJour, dernierJour, monthPremierJour, monthDernierJour); 
    }
 
	public void actionPerformed(ActionEvent arg0) {
 
	}
 
	@Override
	public void itemStateChanged(ItemEvent event) {
		Object source = event.getSource();
		if (source.equals(saturdayCheck)) {
			tableModel.getColumnName(6);
			tableModel.isCellEditable(1, 5);
			setBackground(COLOR_SELECTION);
		}
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
public class WeekPanel extends JPanel {
 
	/**
         * serialVersionUID
         */
	private static final long serialVersionUID = 1L;
	private static final int CALENDAR_START = Calendar.SEPTEMBER;
	private final static Color COLOR_ODD = Color.WHITE;
	private final static Color COLOR_SELECTION = Color.YELLOW;
	private final Calendar calendar;
	private JLabel[] labels;
	private Calendar selection; // la sélection est gérée par un Calendar et non plus un int
	private CalendarWeekViewer viewer;
	private JPanel weekPanel;
	private int anneeActuelle;
	private int anneeChoisit;
	private int anneeDefinitif = 0;
	private Map<Integer, Integer> weeks=new HashMap<>(); // on a besoin de retrouver la position d'une semaine dans la liste de label
 
	public WeekPanel(CalendarWeekViewer viewer, Calendar calendar, int anneeActuelle, int anneeChoisit) {
		this.viewer=viewer;
		this.calendar = calendar;
		this.anneeActuelle = anneeActuelle;
		this.anneeChoisit = anneeChoisit;
 
		// comme on ne va plus de la semaine 0 à la dernière, mais d'une semaine en plein milieu de l'année à une autre de l'année suivantre, on ne peut plus utiliser un entier pour la sélection : il est plus simple d'utiliser un calendar (parce qu'on a besoin d'une numéro de la seamine, mais aussi de l'année)
		selection = copyCalendar(calendar);
 
		setLayout(new BorderLayout());
 
		Calendar premiereSemaine = getPremiereSemaine(CALENDAR_START, anneeActuelle, anneeChoisit); 
		Calendar derniereSemaine = getDerniereSemaine(CALENDAR_START);
 
		int nbSemaines = compteSemaines(premiereSemaine, derniereSemaine);
		labels=new JLabel[nbSemaines];
 
		weekPanel = new JPanel(new GridLayout(1, 0));
 
		Calendar semaine = Calendar.getInstance(); // on a besoin de parcourir les semaines...
		semaine.setTime(premiereSemaine.getTime()); // on les parcourt de la première à la dernière
		for(int i=0; i<nbSemaines; i++) {
			final Calendar week = copyCalendar(semaine);
			weeks.put(week.get(Calendar.WEEK_OF_YEAR), i); // ceci nous permet de facilement trouver le numéro d'une semaine dans la liste de label
			JLabel label = new JLabel(getWeekLabel(semaine), JLabel.CENTER);
			label.setBorder(BorderFactory.createEmptyBorder(0, 5, 0, 5));
			label.setOpaque(true);
			labels[i]=label;
			setLabelColor(week);
			label.setEnabled(true);
			label.addMouseListener(new MouseAdapter() {
				@Override
				public void mouseClicked(MouseEvent e) {
					setSelection(week);
				}
			});
			weekPanel.add(label);
			semaine.add(Calendar.WEEK_OF_YEAR, 1); // on avance d'une semaine
		}
		setLabelColor(selection);
 
		JScrollPane slider = new JScrollPane(weekPanel);
		slider.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS);
		add(slider, BorderLayout.CENTER);
	}
 
 
	private Calendar copyCalendar(Calendar calendar) {
		Calendar copy = Calendar.getInstance();
		copy.setTime(calendar.getTime());
		return copy;
 	}
 
 
	private int compteSemaines(Calendar premiereSemaine,
			Calendar derniereSemaine) {
        Calendar calendar = copyCalendar(premiereSemaine); // on prend une nouvelle instance 
		int count=0;
		while(calendar.get(Calendar.WEEK_OF_YEAR)!=derniereSemaine.get(Calendar.WEEK_OF_YEAR)) { // tant qu'on a pas atteint la dernière semaine
			count++; // on compte une semaine de plus
			calendar.add(Calendar.WEEK_OF_YEAR, 1); // on avance d'une semaine
		}
		return count + 1; // on ajoute 1 parce qu'il faut compte la dernière semaine (qu'on a pas compter dans la boucle)
	}
 
 
	public Calendar getPremiereSemaine(int month, int uneAnneeActuelle, int uneAnneeChoisit) {
        Calendar calendar = Calendar.getInstance();
 
		if(uneAnneeActuelle < uneAnneeChoisit){
			anneeDefinitif = uneAnneeChoisit - uneAnneeActuelle; 
			calendar.add(Calendar.YEAR, + anneeDefinitif);
		}else if(uneAnneeActuelle > uneAnneeChoisit){
			anneeDefinitif = uneAnneeActuelle - uneAnneeChoisit;
			calendar.add(Calendar.YEAR, - anneeDefinitif);
		}else{
			calendar.add(Calendar.YEAR, 0);
		}
 
        calendar.set(Calendar.MONTH,month); // on se positionne sur le mois demandé 
        calendar.set(Calendar.WEEK_OF_MONTH, 1); // on se positionne sur la première semaine du mois
        calendar.set(Calendar.DAY_OF_WEEK, calendar.getFirstDayOfWeek()); // on se positionne sur le premier jour officiel
 
        return calendar;
	}
 
	public Calendar getDerniereSemaine(int month) {
		Calendar calendar = getPremiereSemaine(month, anneeActuelle, anneeChoisit); // on se place sur la première semaine du mois
		calendar.add(Calendar.YEAR, 1); // on avance d'un an
		calendar.add(Calendar.WEEK_OF_YEAR, -1); // on recule d'une semaine
		return calendar;
	}
 
	private void setLabelColor(Calendar calendar) {
		JLabel label=labels[weeks.get(calendar.get(Calendar.WEEK_OF_YEAR))]; // on utilise la map pour savoir le numéro du label correspondant à la semaine
		if ( calendar.equals(selection) ) {
			label.setBackground(COLOR_SELECTION); // la semaine sélectionnée
		}else{
			label.setBackground(COLOR_ODD);
		} 
 
	}
 
	public void updateSelection() {
		Calendar oldSelection = selection;
		selection = copyCalendar(calendar);
		setLabelColor(oldSelection);
		setLabelColor(selection);
		weekPanel.scrollRectToVisible(labels[weeks.get(selection.get(Calendar.WEEK_OF_YEAR))].getBounds());
	}
 
	private void setSelection(Calendar selection) {
		Calendar oldSelection = this.selection;
		this.selection = selection;
		setLabelColor(oldSelection);
		setLabelColor(selection);
		viewer.setWeek(selection);
	}
 
	private String getWeekLabel(Calendar week) {
 
		Calendar calendar = copyCalendar(week);
 
		// le premier jour de cette semaine
		Date premierJour = calendar.getTime();
		int monthPremierJour = calendar.get(Calendar.MONTH);
 
		// le dernier jour de cette semaine
		calendar.add(Calendar.WEEK_OF_YEAR, 1);
		calendar.add(Calendar.DAY_OF_WEEK, -1);
		Date dernierJour = calendar.getTime();
 
		int monthDernierJour = calendar.get(Calendar.MONTH);
 
        return getWeekLabel(week.get(Calendar.WEEK_OF_YEAR), premierJour, dernierJour, monthPremierJour, monthDernierJour);		
 
	}
 
	private final static DateFormat DATE_DEBUT_FORMAT = new SimpleDateFormat(
			"dd");
	private final static DateFormat DATE_FORMAT = new SimpleDateFormat(
			"dd MMMM");
 
	public static  String getWeekLabel(int week, Date premierJour, Date dernierJour, int monthPremierJour, int monthDernierJour) {
		String debut;
		if (monthDernierJour == monthPremierJour) {
			debut = DATE_DEBUT_FORMAT.format(premierJour);
		} else {
			debut = DATE_FORMAT.format(premierJour);
		}
 
		String milieu = DATE_FORMAT.format(dernierJour);
 
		String fin = " (" + week + ")";
 
		return debut + " - " + milieu + fin;
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
public class CalendarWeekTableModel extends AbstractTableModel {
 
    /**
         * serialVersionUID
         */
	private static final long serialVersionUID = 1L;
 
	private Calendar calendar;
 
    private List<Journee> modeleJournee = new ArrayList<Journee>(); 
 
    public CalendarWeekTableModel(Calendar calendar) {
    	this.calendar = calendar;
    }
 
    public int getColumnCount() {
    	// ramene les 7 jours de la semaine
        return 7;
    }
 
    public int getRowCount() {
    	// ramene le nombre de ligne
    	// nombre de demi journée 
    	return 2;
    }
 
    public String getColumnName(int col) {
        return getDayName(col);
    }
 
    public Object getValueAt(int row, int col) {
    	return "";
    }
 
    public boolean isCellEditable(int row, int col) {
    	return true;
    }
 
    public void setValueAt(Object value, int row, int col) {
    	 Journee journee = modeleJournee.get(col);
    	 if(col ==0) {
    		 journee.getMatin().setLibelle(value.toString());    		 
    	 }
    	 if(col ==1) {
    		 journee.getApresmidi().setLibelle(value.toString());    		 
    	 } 
    }
 
    	  private String getDayName(int day) {
    	    	Calendar calendarDay = Calendar.getInstance();
    	    	calendarDay.setTime(calendar.getTime());
    			calendarDay.add(Calendar.DATE, day);
    			return calendarDay.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.LONG, Locale.getDefault())+" "+calendarDay.get(Calendar.DATE); // bug sur cette ligne calendar au lieu de calendarDay
    		}
 
 
    protected void intialiserJournee() {
    	// initalisation de la journée 
    	for(int i =0; i<7; i++)
    	{
    		modeleJournee.add(new Journee());	
    	}
    }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Serialiser implements Serializable {
    /**
         * serialVersionUID
         */
	private static final long serialVersionUID = 1L;
	private static String fichier;
	public Serialiser(String fichier) {
		Serialiser.fichier = fichier;
	}
 
	public void serialiser(CalendarWeekViewer calendrier){
		try{
	        FileOutputStream  fout=new FileOutputStream(fichier);
	        ObjectOutputStream  oout=new ObjectOutputStream(fout);
	        oout.writeObject(calendrier);
	        System.out.println("Le planning a été sérialisé !");
	        oout.close();
	        fout.close();
		}  catch(IOException ioe) {
		        ioe.printStackTrace();
		}
	}
}

Les classes métiers:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class ModuleJour {
 
	private String libelle = "";
 
	public String getLibelle() {
		return libelle;
	}
 
	public void setLibelle(String libelle) {
		this.libelle = libelle;
	}
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class Journee {
 
	private ModuleJour matin;
 
	private ModuleJour apresmidi;
 
	public Journee() {
		super();
		matin = new ModuleJour();
		apresmidi = new ModuleJour();
	}
 
	public ModuleJour getMatin() {
		return matin;
	}
 
	public void setMatin(ModuleJour matin) {
		this.matin = matin;
	}
 
	public ModuleJour getApresmidi() {
		return apresmidi;
	}
 
	public void setApresmidi(ModuleJour apresmidi) {
		this.apresmidi = apresmidi;
	}
 
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public class Annee {
	private String annee;
 
	public Annee(String annee){
		this.setAnnee(annee);
	}
 
	public Annee() {
		// TODO Auto-generated constructor stub
	}
 
	public String getAnnee() {
		return annee;
	}
 
	public void setAnnee(String annee) {
		this.annee = annee;
	}
 
	public String convertirUneAnnee(String anneeListe){
		String uneAnnee;
		uneAnnee = anneeListe.substring(0, 4);
		return uneAnnee;
	}
 
	public int anneeChoisit(String uneAnnee){
		SimpleDateFormat curFormater = new SimpleDateFormat("yyyy"); 
		Date dateObj = null;
		int year = 0;
 
		try {
			dateObj = curFormater.parse(uneAnnee);
			Calendar calendar2 = Calendar.getInstance();
			calendar2.setTime(dateObj);
			year = calendar2.get(Calendar.YEAR);
		} catch (ParseException e) {
			e.printStackTrace();
		} 
 
		return year;
	}
}

Merci de votre aide