Java学习

final

• final修饰类：不能被继承
• final修饰方法：不能被子类改写
• final修饰变量：基本类型不能修改值，对象类型不能修改引用（可以修改成员值）

抽象类

abstract class

@interface注解

java用@interface Annotation{ } 定义一个注解 @Annotation，一个注解是一个类。
注解@Retention可以用来修饰注解，是注解的注解，称为元注解。

常见元注解详情 元注解：

1.@Target,
2.@Retention,
3.@Documented,
4.@Inherited

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
public @interface MtConfig {
    String clientId() default "";

    String key();

    String nodeName() default "";
}

常见注解：
@Override
@Deprecate
@SuppressWarnings

自定义异常

用interface定义常量vs用类定义常量

public interface Constants {
    int A = 100;
    int B = 100;
    int C = 100;
    int D = 100;
} 

Java中常量定义在interface和class的区别

类定义常量和接口定义常量:

1、类定义常量，需要定义成final且定义一个private的构造方法，这样做是为了不让其他类继承，禁止实例化此类，调用时直接以"类.常量"的方式调用。

2、接口中定义的"变量"，其实就是常量，接口中的"变量"默认都是 "public static final"类型，即为常量，因此接口可以省略"public static final"而直接写成 “type variable”。

3、用如上的类定义常量，不能实例化也不能被继承，看起来完美无缺。

4、接口定义常量，虽不能实例化，确可以被其他类实现；

因此有这么一种设计模式"The constant interface pattern". 所谓的"常量接口模式"， 就是其他类要使用接口中定义的常量，就实现该接口. 我认为这是对接口的烂用. 接口中定义的常量应为所有类频繁使用的常量，但并不是每个类都使用了接口中定义的所有常量，因而导入了不必要的常量到这个类中，并且导入后这个类的子类也会基础导入的常量，这样会导致混乱，应当避免此种用法。

5、在interface和class中定义相同的常量，interface生成的class文件比class生成的class文件会更小，而且更简洁，效率更高。可以使用jad和javap反编译去分析一下。

个人总结：

1、不要使用"常量接口模式"，此模式会导致类中的常量混乱，增加维护难度。注意！是常量接口模式时不要使用，而对于普通的设计是可以使用接口去实现的。

2、不要使用静态导入，import static *****，因为import static会导致可维护性下降，维护的人看代码时，不是那么清楚或者不那么迅速的知道这个常量位于哪个文件中。建议使用常量的地方直接 “接口.常量名” 的方式使用。

3、还有用这种方式定义常量: public abstract class Constants {}，很容易看出这种方式定义常量的目的：禁止实例化。但是"abstract class"的目的是为了让其他类继承，因此语意别扭，同样具有interface定义常量的确定，即可以被继承， 其实解决上述问题更优美的方式是用final修饰类并给类定义一个private构造方法。

4、对于用是用interface定义常量还是使用class定义常量，看个人喜好. 个人觉得interface定义常量更为优美：代码更简洁， 生成的class文件更小，JVM不要考虑类的附加特性，如方法重载等，因而更为高效。这是一种反模式的用法，很多人不喜欢这种用法，如果我们知道它的优缺点，延长避短，也是无可厚非的，还有一点是不要把这种用法用成"常量接口模式"，个人觉得"常量接口模式"确实是一种对interface的"pool use"。

枚举 enum

泛型

相当于C++中的模板
Java泛型

int和Integer的区别

1. Integer是int的包装类，int则是java的一种基本数据类型
2. Integer变量必须实例化后才能使用，而int变量不需要
3. Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值
4. Integer的默认值是null，int的默认值是0

延伸： 关于Integer和int的比较

1、由于Integer变量实际上是对一个Integer对象的引用，所以两个通过new生成的Integer变量永远是不相等的（因为new生成的是两个对象，其内存地址不同）。

Integer i = new Integer(100);
Integer j = new Integer(100);
System.out.print(i == j); //false

2、Integer变量和int变量比较时，只要两个变量的值是向等的，则结果为true（因为包装类Integer和基本数据类型int比较时，java会自动拆包装为int，然后进行比较，实际上就变为两个int变量的比较）

Integer i = new Integer(100);
int j = 100；
System.out.print(i == j); //true

3、非new生成的Integer变量和new Integer()生成的变量比较时，结果为false。（因为非new生成的Integer变量指向的是java常量池中的对象，而new Integer()生成的变量指向堆中新建的对象，两者在内存中的地址不同）

Integer i = new Integer(100);
Integer j = 100;
System.out.print(i == j); //false

4、对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false

Integer i = 100;
Integer j = 100;
System.out.print(i == j); //true
Integer i = 128;
Integer j = 128;
System.out.print(i == j); //false

对于第4条的原因：
java在编译Integer i = 100 ;时，会翻译成为Integer i = Integer.valueOf(100)；，而java API中对Integer类型的valueOf的定义如下：

public static Integer valueOf(int i){
    assert IntegerCache.high >= 127;
    if (i >= IntegerCache.low && i <= IntegerCache.high){
        return IntegerCache.cache[i + (-IntegerCache.low)];
    }
    return new Integer(i);
}

java对于-128到127之间的数，会进行缓存，Integer i = 127时，会将127进行缓存，下次再写Integer j = 127时，就会直接从缓存中取，就不会new了