1. The SecurityManager
class for JVM check methods can be defined differently based on context because different contexts may have different security requirements and r
estrictions. For example, a web application may need to r
estrict acc
ess to certain r
esourc
es, while a d
esktop application may not have the same r
estrictions.
2. The identifier T in the declaration of the method sort repr
esents a generic type parameter that can be replaced with any type when the method is called. For example, if we have an array of integers, we can call the sort method like this:
```
Integer[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
Comparator<Integer> c = Comparator.naturalOrder();
Collections.sort(arr, c);
```
3. The notation <? super T> in the declaration of sort means that the Comparator can accept any type that is a super
class of T. For example, if we have a
class Animal and a sub
class Dog, we can use a Comparator that accepts any super
class of Dog to sort an array of Dogs:
```
Dog[] dogs = ...;
Comparator<Animal> c = ...;
Collections.sort(dogs, c);
```
4. An anonymous
inner class in Java is a
class that is defined and instantiated at the same time, without a separate
class definition. For example, we can define an anonymous
inner class to implement an
interface and pass it as an argument to a method:
```
Runnable r = new Runnable() {
public void run() {
System.out.println("Hello, world!");
}
};
r.run();
```
5. The same example using a lambda expr
ession would look like this:
```
Runnable r = () -> System.out.println("Hello, world!");
r.run();
```
6. You might prefer to use an anonymous
class instead of a lambda expr
ession when you need to define a
class that has additional behavior or state beyond the method being called. You might prefer to use a lambda expr
ession when you only need to define a single method and want to keep the code more concise.
7. (Auto)boxing and (auto)unboxing in Java refer to the automatic conversion between primitive typ
es and their corr
esponding object wrapper typ
es. For example, an int can be automatically boxed to an Integer, and an Integer can be automatically unboxed to an int.
8. The annotation @Override in Java indicat
es that a method is intended to override a method in a super
class or
interface. Adding this annotation can help catch errors at compile time and make the code more readable.
9. Wildcards in Java are used in generic programming to allow a generic type to accept any type that meets a certain criteria. For example, a List<? extends Number> can accept a List of any sub
class of Number.
10. Bounded wildcards in Java r
estrict the typ
es that can be used with a generic type parameter. For example, a List<? extends Number> can only accept typ
es that are sub
classes of Number, while a List<? super Integer> can accept typ
es that are super
classes of Integer. An example of using a bounded wildcard would be:
```
public static double sum(List<? extends Number> list) {
double total = 0.0;
for (Number n : list) {
total += n.doubleValue();
}
return total;
}
```
519
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
