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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
|
/*
* @test /nodynamiccopyright/
* @bug 8202056
* @compile/ref=SerialMethodThrows.out -XDrawDiagnostics -Xlint:serial SerialMethodThrows.java
*/
import java.io.*;
/*
* Container class for various serializable classes with different
* kinds of throws clauses. Canonical serialization method signatures:
*
* private void writeObject(ObjectOutputStream stream)
* throws IOException
*
* ANY-ACCESS-MODIFIER Object writeReplace()
* throws ObjectStreamException
*
* private void readObject(ObjectInputStream stream)
* throws IOException, ClassNotFoundException
*
* private void readObjectNoData()
* throws ObjectStreamException
*
* ANY-ACCESS-MODIFIER Object readResolve()
* throws ObjectStreamException
*/
class SerialMethodThrows {
// Being declared to throw no exceptions is fine and should not
// generate any warnings.
static class NoThrows implements Serializable {
private static final long serialVersionUID = 42;
private void writeObject(ObjectOutputStream stream) {
try {
stream.defaultWriteObject();
} catch (IOException e) {
;
}
}
private Object writeReplace() {
return null;
}
private void readObject(ObjectInputStream stream) {
try {
stream.defaultReadObject();
} catch (IOException | ClassNotFoundException e) {
;
}
}
private void readObjectNoData() {}
private Object readResolve() {
return null;
}
}
// Being declared to throw the canonical exceptions is fine and
// should not generate any warnings.
static class ErrorThrows implements Serializable {
private static final long serialVersionUID = 42;
private void writeObject(ObjectOutputStream stream)
throws Error {
try {
stream.defaultWriteObject();
} catch (IOException e) {
;
}
}
private Object writeReplace()
throws Error {
return null;
}
private void readObject(ObjectInputStream stream)
throws Error {
try {
stream.defaultReadObject();
} catch (IOException | ClassNotFoundException e) {
;
}
}
private void readObjectNoData()
throws Error {}
private Object readResolve()
throws Error {
return null;
}
}
// Being declared to throw the canonical exceptions is fine and
// should not generate any warnings.
static class ExactThrows implements Serializable {
private static final long serialVersionUID = 42;
private void writeObject(ObjectOutputStream stream)
throws IOException {
stream.defaultWriteObject();
}
private Object writeReplace()
throws ObjectStreamException {
return null;
}
private void readObject(ObjectInputStream stream)
throws IOException, ClassNotFoundException {
stream.defaultReadObject();
}
private void readObjectNoData()
throws ObjectStreamException {}
private Object readResolve()
throws ObjectStreamException {
return null;
}
}
// Being declared to throw subclasses of the canonical exceptions
// is fine and should not generate any warnings.
static class SubclassThrows implements Serializable {
private static final long serialVersionUID = 42;
private void writeObject(ObjectOutputStream stream)
throws CustomIOException {
try {
stream.defaultWriteObject();
} catch (IOException e) {
;
}
}
private Object writeReplace()
throws CustomObjectStreamException {
return null;
}
private void readObject(ObjectInputStream stream)
throws CustomIOException, CustomClassNotFoundException {
try {
stream.defaultReadObject();
} catch (IOException | ClassNotFoundException e) {
;
}
}
private void readObjectNoData()
throws CustomObjectStreamException {}
private Object readResolve()
throws CustomObjectStreamException {
return null;
}
}
private static class CustomIOException extends IOException{
private static final long serialVersionUID = 1;
}
private static class CustomObjectStreamException extends ObjectStreamException {
private static final long serialVersionUID = 2;
}
private static class CustomClassNotFoundException extends ClassNotFoundException {
private static final long serialVersionUID = 3;
}
// Use to trigger warnings
private static class CustomException extends Exception {
private static final long serialVersionUID = 3;
}
// Being declared to throw subclasses of the canonical exceptions
// is fine and should not generate any warnings.
static class CustomThrows implements Serializable {
private static final long serialVersionUID = 42;
private void writeObject(ObjectOutputStream stream)
throws CustomException {
try {
stream.defaultWriteObject();
} catch (IOException e) {
;
}
}
private Object writeReplace()
throws CustomException {
return null;
}
private void readObject(ObjectInputStream stream)
throws CustomException {
try {
stream.defaultReadObject();
} catch (IOException | ClassNotFoundException e) {
;
}
}
private void readObjectNoData()
throws CustomException {}
private Object readResolve()
throws CustomException {
return null;
}
}
}
|
