164
165 /**
166 * {@inheritDoc}
167 *
168 * <p> A {@code SecurityException} is also thrown if this object is a
169 * {@code Constructor} object for the class {@code Class} and {@code flag}
170 * is true. </p>
171 *
172 * @param flag {@inheritDoc}
173 *
174 * @throws InaccessibleObjectException {@inheritDoc}
175 * @throws SecurityException if the request is denied by the security manager
176 * or this is a constructor for {@code java.lang.Class}
177 *
178 * @spec JPMS
179 */
180 @Override
181 @CallerSensitive
182 public void setAccessible(boolean flag) {
183 AccessibleObject.checkPermission();
184 if (flag) {
185 checkCanSetAccessible(Reflection.getCallerClass());
186 }
187 setAccessible0(flag);
188 }
189
190 @Override
191 void checkCanSetAccessible(Class<?> caller) {
192 checkCanSetAccessible(caller, clazz);
193 if (clazz == Class.class) {
194 // can we change this to InaccessibleObjectException?
195 throw new SecurityException("Cannot make a java.lang.Class"
196 + " constructor accessible");
197 }
198 }
199
200 @Override
201 boolean hasGenericInformation() {
202 return (getSignature() != null);
203 }
457 * @exception IllegalArgumentException if the number of actual
458 * and formal parameters differ; if an unwrapping
459 * conversion for primitive arguments fails; or if,
460 * after possible unwrapping, a parameter value
461 * cannot be converted to the corresponding formal
462 * parameter type by a method invocation conversion; if
463 * this constructor pertains to an enum type.
464 * @exception InstantiationException if the class that declares the
465 * underlying constructor represents an abstract class.
466 * @exception InvocationTargetException if the underlying constructor
467 * throws an exception.
468 * @exception ExceptionInInitializerError if the initialization provoked
469 * by this method fails.
470 */
471 @CallerSensitive
472 @ForceInline // to ensure Reflection.getCallerClass optimization
473 public T newInstance(Object ... initargs)
474 throws InstantiationException, IllegalAccessException,
475 IllegalArgumentException, InvocationTargetException
476 {
477 if (!override) {
478 Class<?> caller = Reflection.getCallerClass();
479 checkAccess(caller, clazz, clazz, modifiers);
480 }
481 if ((clazz.getModifiers() & Modifier.ENUM) != 0)
482 throw new IllegalArgumentException("Cannot reflectively create enum objects");
483 ConstructorAccessor ca = constructorAccessor; // read volatile
484 if (ca == null) {
485 ca = acquireConstructorAccessor();
486 }
487 @SuppressWarnings("unchecked")
488 T inst = (T) ca.newInstance(initargs);
489 return inst;
490 }
491
492 /**
493 * {@inheritDoc}
494 * @since 1.5
495 */
496 @Override
|
164
165 /**
166 * {@inheritDoc}
167 *
168 * <p> A {@code SecurityException} is also thrown if this object is a
169 * {@code Constructor} object for the class {@code Class} and {@code flag}
170 * is true. </p>
171 *
172 * @param flag {@inheritDoc}
173 *
174 * @throws InaccessibleObjectException {@inheritDoc}
175 * @throws SecurityException if the request is denied by the security manager
176 * or this is a constructor for {@code java.lang.Class}
177 *
178 * @spec JPMS
179 */
180 @Override
181 @CallerSensitive
182 public void setAccessible(boolean flag) {
183 AccessibleObject.checkPermission();
184
185 if (clazz.isValue()) {
186 throw new InaccessibleObjectException(
187 "Unable to make a value class constructor \"" + this + "\" accessible");
188 }
189
190 if (flag) {
191 checkCanSetAccessible(Reflection.getCallerClass());
192 }
193 setAccessible0(flag);
194 }
195
196 @Override
197 void checkCanSetAccessible(Class<?> caller) {
198 checkCanSetAccessible(caller, clazz);
199 if (clazz == Class.class) {
200 // can we change this to InaccessibleObjectException?
201 throw new SecurityException("Cannot make a java.lang.Class"
202 + " constructor accessible");
203 }
204 }
205
206 @Override
207 boolean hasGenericInformation() {
208 return (getSignature() != null);
209 }
463 * @exception IllegalArgumentException if the number of actual
464 * and formal parameters differ; if an unwrapping
465 * conversion for primitive arguments fails; or if,
466 * after possible unwrapping, a parameter value
467 * cannot be converted to the corresponding formal
468 * parameter type by a method invocation conversion; if
469 * this constructor pertains to an enum type.
470 * @exception InstantiationException if the class that declares the
471 * underlying constructor represents an abstract class.
472 * @exception InvocationTargetException if the underlying constructor
473 * throws an exception.
474 * @exception ExceptionInInitializerError if the initialization provoked
475 * by this method fails.
476 */
477 @CallerSensitive
478 @ForceInline // to ensure Reflection.getCallerClass optimization
479 public T newInstance(Object ... initargs)
480 throws InstantiationException, IllegalAccessException,
481 IllegalArgumentException, InvocationTargetException
482 {
483 if (clazz.isValue()) {
484 throw new IllegalAccessException(
485 "cannot create new instance of value class " + clazz.getName());
486 }
487
488 if (!override) {
489 Class<?> caller = Reflection.getCallerClass();
490 checkAccess(caller, clazz, clazz, modifiers);
491 }
492 if ((clazz.getModifiers() & Modifier.ENUM) != 0)
493 throw new IllegalArgumentException("Cannot reflectively create enum objects");
494 ConstructorAccessor ca = constructorAccessor; // read volatile
495 if (ca == null) {
496 ca = acquireConstructorAccessor();
497 }
498 @SuppressWarnings("unchecked")
499 T inst = (T) ca.newInstance(initargs);
500 return inst;
501 }
502
503 /**
504 * {@inheritDoc}
505 * @since 1.5
506 */
507 @Override
|