泛型机制
见《
Java泛型机制（Java 5）》
注解
1. 概述
注解（Annotation）相当于一种标记，在程序中加了注解就等于为程序打上了某种标记。编译器、开发工具和其他程序就可以利用注解来完成检查，提醒等功能。
普通程序要获取注解，可以通过反射的方式，以实现特定功能。
2. 特点
- 注解可以加在包，类（包括class，interface，annotation，enum），域，方法，方法的参数以及局部变量上。
- java.lang包中提供了最基本的注解。
3. 格式
- 若注解无属性，或所有的属性均有默认定义
@注解名 - 若注解只有一个名为value的属性；或有一个名为value的属性，且其他属性均有默认定义
@注解名(值)
- 若注解有多个属性
@注解名(属性名=值, ...)
4. 元注解
- 元注解实际就是注解的注解，一般用于标记该注解的作用范围和生命周期。
- 常用的元注解有两种：@Target用于标记作用范围，@Retention用于标记生命周期。
- @Target包含了1个属性：ElementType[] value，其中ElementType为枚举类型，包含了所有的作用范围的枚举。
PACKAGE（包）
FIELD（字段）
ANNOTATION_TYPE（注释类型）
CONSIRUCTOR（构造器）
METHOD（方法）
PARAMETER（参数）
TYPE（类、接口、注解或枚举）
LOCAL_VARIABLE（局部变量） - @Retention包含了1个属性：RetentionPolicy value，其中RetentionPolicy为枚举类型，包含：
SOURCE，表明该注解仅保留在源文件，即对编译过程有效；
CLASS，表明该注解一直保留到class文件中，该值为默认值；
RUNTIME，表明该注解一直保留到运行阶段的字节码实例中，运行时有效。
5. 三种基本注解
- @Deprecated
用以表明该元素已过时，不推荐使用。
作用范围：构造器，域，方法，包，局部变量，方法参数，类（包括class，interface，annotation，enum）
生命周期：RUNTIME，由于调用别人开发的class仍然需要有过时提醒，所以运行时保留。 - @Override
用以表明该方法为重写方法。
作用范围：方法。
生命周期：SOURCE，由于该注解是给编译器检查之用，所以源文件保留即可。
例如：equals方法若参数没有写成Object，则变为重载而非重写，若加上该注解，则编译器报错有效避免潜在错误。 - @SuppressWarnings
用以表明忽略某种警告。
作用范围：构造器，域，方法，局部变量，方法参数，类（包括class，interface，annotation，enum）
声明周期：SOURCE，同理，由于该注解是给编译器警告提示之用，所以源文件保留即可。
属性：String[] value：用于表明忽略哪一种警告。
- 示例
package annotation;public class AnnotationDemo implements Comparable<String>{@SuppressWarnings("unused") // 表明忽略未使用的变量警告public static void main(String[] args) {int a = 0;deprecatedFunc();}@Override // 表明重写方法public int compareTo(String o) {return 0;}@Deprecated // 表明该方法已过时public static void deprecatedFunc() {}}
6. 自定义注解
6.1 注解调用
一般注解调用分为三个阶段：
- 定义：使用@interface关键字定义注解A。
- 使用：在类B上需要使用该注解时使用@A调用该注解。
- 反射使用：类C使用反射获取类B的注解A，并使用。（由于反射是运行时技术，所以要在反射时使用的注解必须由@Retention声明为RUNTIME。）
6.2 格式
使用@interface声明注解。
示例：
package annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME) // 标示该注解保持到运行时有效
@Target({ElementType.TYPE, ElementType.METHOD}) // 标示该注解可以使用在类型（包括类，接口，注解和枚举）和方法上
public @interface AnnotationCustom {
String value(); // 该注解有1个属性，value属性较为特殊，在调用时可以不用声明value
}
6.3 注解调用示例
这里使用6.2定义好的注解：
package annotation;
@SuppressWarnings("unused")
public class AnnotationCustomDemo {
public static void main(String[] args) {
// 获取AnnotationLoader类字节码实例
Class<AnnotationLoader> clazz = AnnotationLoader.class;
// 判断该类是否有注解标示
if (clazz.isAnnotationPresent(AnnotationCustom.class)) {
// 获取该注解实例
AnnotationCustom ac = clazz.getAnnotation(AnnotationCustom.class);
// 获取注解属性
String str = ac.value(); // java
}
}
}
@AnnotationCustom("java")
class AnnotationLoader {
}
6.4 注解属性
6.4.1 概述
注解属性可以为注解带来更加细分的标示作用，比如在忽略警告注解内，属性的作用就可以用来区分需要忽略的警告的类型。
注解可以理解为一个类，而注解的属性可以理解为类的方法，而属性的类型可以理解为方法的返回值类型。
注解名可以理解为类名，而加了@的具体注解的调用，可以理解为该注解的实例。
6.4.2 格式
同接口中定义方法类似，一般没有修饰符。例如：
String value();
int[] count();
可以使用关键字default来给属性加上默认值，这时调用该注解时就可以不必指定该属性的值。例如：
EnumColor color() default EnumColor.RED;
int[] num() default {1, 2, 3};
6.4.3 属性成分
注解属性的返回值类型可以为以下类型：
- 八种基本数据类型
- String类型
- Class类型
- 枚举类型
- 注解类型
- 前五种类型的数组
6.4.4 调用
示例注解
package annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface AnnotationAttribute {
String value(); // String
Class<?> clazz() default AnnotationAttribute.class; // Class类型
EnumColor color() default EnumColor.RED; // 枚举
int[] num() default {1, 2, 3}; // 数组
AnnotationCustom annotation() default @AnnotationCustom("java"); // 注解
}
示例调用（以下调用方式均可）
@AnnotationAttribute("java")
@AnnotationAttribute(value="java", clazz=String.class)
@AnnotationAttribute(value="java", num={1, 2, 3})
@AnnotationAttribute(value="java", num=1)
@AnnotationAttribute(value="java", annotation=@AnnotationCustom("java"))
6.4.5 反射调用
这里使用6.4.4的注解。
package annotation;@AnnotationAttribute(value = "it", clazz = String.class, num = 6, annotation = @AnnotationCustom("java"))public class AnnotationAttributeDemo {@SuppressWarnings("unused")public static void main(String[] args) {// 获取该类字节码实例Class<AnnotationAttributeDemo> clazz = AnnotationAttributeDemo.class;// 判断该类是否有注解if (clazz.isAnnotationPresent(AnnotationAttribute.class)) {// 获取该类注解AnnotationAttribute aa = clazz.getAnnotation(AnnotationAttribute.class);// 获取该注解的属性String str = aa.value(); // "it"Class<?> c = aa.clazz(); // class java.lang.StringEnumColor ec = aa.color(); // REDint[] num = aa.num(); // {6}AnnotationCustom ac = aa.annotation(); // @annotation.AnnotationCustom(value=java)}}}
枚举
1. 概述
枚举是一种类型，该类型的变量均是一些有限且特定的值。比如一个星期有7天，分别为周日到周六；比如交通灯的三种颜色等等。在枚举出现之前，我们常常使用数组来进行表示，用查表法来获取需要的数据。但是用这种方法往往产生很多意想不到的错误，比如下标越界，实际意义和值对应的随意性经常产生不可预知且较难发现的错误，比如一个不存在的值。所以Java 5引入了枚举类型。
以下的例子是在枚举出现以前的实现方法：
package enumtype;
public abstract class TrafficLights {
// 交通灯显示时间
private int time;
// 由于不允许额外创建实例，所以私有化构造器
private TrafficLights(int time) {
this.time = time;
}
/*
* 因为不允许私自创建对象，所以类加载时即创建有限且特定的实例，使用static方法；
* 因为外部需要访问，所以public权限；
* 因为不可修改，所以final修饰
* 使用匿名内部类创建实例，传入显示时间参数，并重写抽象方法，实现下个灯的获取。
*/
public static final TrafficLights RED = new TrafficLights(40) {
@Override
TrafficLights nextLight() {
return GREEN;
}
};
public static final TrafficLights GREEN = new TrafficLights(30) {
@Override
TrafficLights nextLight() {
return YELLOW;
}
};
public static final TrafficLights YELLOW = new TrafficLights(3) {
@Override
TrafficLights nextLight() {
return RED;
}
};
abstract TrafficLights nextLight();
public int getTime() {
return this.time;
}
}
调用
package enumtype;public class EnumDemo {public static void main(String[] args) {int time1 = TrafficLights.GREEN.getTime(); // 30int time2 = TrafficLights.YELLOW.nextLight().getTime(); // 40}}
2. 特点
- 枚举相当于一个类，而其中的特定的值相当于这个类的实例。
- 在比较两个枚举类型的值时，永远不需要调用equals方法，而直接使用“==”就可以了。
- 枚举中可以添加域，构造器和方法。当然，构造器只是在构造枚举常量时被调用。
- 枚举类型不可以被继承，即相当于被fianl修饰。
- 所有的枚举类均是java.lang.Enum<E>的子类，所以可以使用Enum类中的方法。
3. 泛型说明
Enum类型在Java API的定义如下：
public abstract class Enum<E extends Enum<E>>
extends Object
implements Comparable<E>, Serializable
这里的泛型使用类似递归定义的形式：<E extends Enum<E>>，目的是为了实现父类实例（即Enum实例）能够获取或者使用子类实例作为方法的参数或返回值。
例如要设计一个能够获取子类对象的类：
a. 首先，定义父类，并且定义获取子类的抽象方法（由于子类不确定，所以具体实现必须由具体子类实现）。
abstract class Father {
abstract <T> T get();
}
b. 其实，定义子类，复写方法。
class Son extends Father {
@Override
Son get() {
return new Son();
}
}
c. 这里出现问题，警告：Type safety: The return type Son for func() from the type Son needs unchecked conversion to conform to T from the type Father.也就是说，返回值类型Son必须和父类中的定义T保持一致，否则需要取消安全检查。所以这里父类中就不能使用泛型方法，而是使用泛型类，将子类类型作为类型参数传入父类，重新设计如下：
abstract class Father<T> {
abstract T get();
}
class Son extends Father<Son> {
@Override
Son get() {
return new Son();
}
}
d. 大部分问题是解决了，但是仍然不够严谨，因为父类中的泛型参数T没有丝毫限制，导致子类可以传入任何类型到父类的类型参数中，所以这里父类使用泛型限定<T extends Father>来解决问题，而Father是带泛型的，所以修改为类似这种递归形式的泛型定义：<T extends Father<T>>，具体代码如下：
abstract class Father<T extends Father<T>> {
abstract T get();
}
class Son extends Father<Son> {
@Override
Son get() {
return new Son();
}
}
而这里的枚举类型的定义就是如此定义的，以方便其方法对子类类型的使用，如下方法：
static <T extends Enum<T>> T valueOf(Class<T> enumType, String name)
4. 常用方法
一般枚举的方法都是从父类Enum处继承而来，但是values()和valueOf(String name)方法例外，通过反汇编可以看到，该方法是编译器编译阶段添加入枚举中的。
- 获取枚举名称，优先使用toString方法
String name()
String toString() - 获取枚举的顺序
int ordinal() - 通过枚举名称获取该枚举，是toString的逆方法
static <T extends Enum<T>> T valueOf(Class<T> enumType, String name) - 获取包含枚举中所有元素的枚举数组
static <T extends Enum<T>> T[] values() - 通过名称获取该枚举
static <T extends Enum<T>> T valueOf(String name)
示例
package enumtype;
public class EnumDemo {
@SuppressWarnings("unused")
public static void main(String[] args) {
Week weekday = Week.MON;
// 获取枚举值的名称
String str1 = weekday.name(); // "MON"
String str2 = weekday.toString(); // "MON"
// 获取枚举索引
int i = weekday.ordinal(); // 1
// 获取所有枚举值
Week[] ws = Week.values(); // {SUN, MON, TUE, WED, THU, FIR, SAT}
// 通过枚举名称获取枚举值
Week w1 = Week.valueOf("WED"); // WED
Week w2 = Week.valueOf(Week.class, "THU"); // THU
}
}
enum Week {
SUN, MON, TUE, WED, THU, FIR, SAT;
}
5. 枚举成员
5.1 概述
由于枚举也相当于一个特殊的Java类，所以枚举中也可以定义域，构造器和方法。
5.2 特点
- 枚举中的其他成员必须定义在枚举列表之后，并且枚举列表后必须用“;”结束。
- 枚举中的构造器必须是私有的。
- 枚举中在构造枚举常量时常使用匿名内部类。
- 当枚举只有一个特定元素时，可以作为单例使用。
5.3 示例
package enumtype;public enum TrafficLightsEnum {// 调用int参数构造器初始化，并使用匿名内部类的方式重写抽象方法并具体实现。// 相当于TrafficLightsEnum RED = new TrafficLightsEnum(40) {...}RED(40) {@Overridepublic TrafficLightsEnum nextLight() {return GREEN;}},GREEN(30) {@Overridepublic TrafficLightsEnum nextLight() {return YELLOW;}},YELLOW {@Overridepublic TrafficLightsEnum nextLight() {return RED;}};// 显示时间，默认为3秒private int time = 3;// 空参数构造器，必须私有private TrafficLightsEnum() {};// int参数构造器，对显示时间初始化，必须私有private TrafficLightsEnum(int time) {this.time = time;}// 公有抽象方法，返回下一个灯public abstract TrafficLightsEnum nextLight();// 公有方法，返回该灯的显示时间public int getTime() {return time;}}
6. 枚举单例
使用枚举来构造单例非常简单，因为枚举中的元素是固定的，不允许修改的，所以当一个枚举只有一个元素的时候就可以当做单例使用。
示例
package enumtype;
public enum Singleton {
INSTANCE;
}
简单三行代码就可以创建一个单例，而且具有其他单例模式不具备的优势，所以推荐使用：
- 线程安全：使用类加载器机制来保证线程安全。
- 抗序列化攻击：由于枚举提供了自己的序列化机制，能够在序列化时仍然保持单例（细节未知）。
- 抗反射攻击：在反射攻击中创建额外的枚举实例将会报告非法参数错误，不可以在反射中创建枚举实例（细节未知）。
Lock锁机制
见
《Java多线程》线程安全/线程通讯。
静态导入
1. 概述
在使用某些静态方法时，可以使用静态导入的方式来免去类名，尤其在类名较长的情况下可以让代码更加简洁。当然如果出现方法重名的情况下，类名是不可避免的。
2. 格式
import static 类名.静态方法名
这样在调用该方法时就可以直接使用方法名调用而不需要书写类名。
3. 示例
import static java.lang.Math.max;public class StaticImport {public static void main(String[] args) {int max = max(3, 4);System.out.println(max);}}
增强for循环
1. 格式
for ({VariableModifier} UnannType VariableDeclaratorId : Expression ) {Statement;}
2. 特点
- Expression必须是数组或者Iterator的实现。
- 对集合进行遍历时，无法对元素进行操作。可以看成是迭代器的简洁形式。
- 增强for循环必须制定迭代目标，且无索引，所以功能上较为简单。
3. 示例
int[] arr = {1, 2, 3};List<String> list = new ArrayList<String>();list.add("java");list.add("it");list.add("android");for (int i : arr) {System.out.println(i);}for (String string : list) {System.out.println(string);}
可变参数
1. 概述
当方法需要传入多个同类型参数时，以往都是使用数组作为参数传入，这样一来就必须定义数组才能作为实际参数。而可变参数的意义在于不需要定义数组，可以将多个同类型参数直接填入参数列表中传入方法。而方法中仍然是将这些参数作为数组看待。
2. 格式
{VariableModifier} UnannType {Annotation} ... VariableDeclaratorId
3. 特点
- 可变参数只能作为方法的最后一个参数。
- 参数类型和“...”之间不建议加入空格。
- 方法内仍然将可变参数作为数组处理。
4. 示例
public static void main(String[] args) {
int result1 = add(1, 2); // 3
int result2 = add(1, 2, 3); // 6
int result3 = add(new int[]{1, 2, 3}); // 6
}
public static int add(int... elements) {
int sum = 0;
for (int i : elements) {
sum += i;
}
return sum;
}
自动装箱和拆箱
1. 概述
- 自动装箱：将基本数据类型自动转换为对应的基本数据类型包装类实例。
- 自动拆箱：将基本数据类型包装类实例自动转换为基本数据类型数据。
2. 示例
Integer i = 13; // 自动装箱int num = i + 1; // 自动拆箱
3. 内存驻留机制（享元模式）
和String类似，基本数据类型包装类也采用了享元模式，在自动装箱时，如果数值范围在byte范围内，则共享内存空间。
Integer a1 = 127;Integer a2 = 127;System.out.println( a1 == a2); // trueInteger b1 = 128;Integer b2 = 128;System.out.println( b1 == b2); // false
扫一扫
213
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
