充电Java知识（Java编程思想(第四版)）

来源于“Java编程思想(第四版)”

1）得到系统信息
System.getProperties().list(System.out);

System.out.println(System.getProperty("user.name"));
System.out.println(System.getProperty("java.library.path"));

2）泛型
java.util.Collection<E>
用法：
Collection<String> list = new LinkedList<String>();
publlic class Parace<T> {
    // ...
}
还可以这么表示：
List<? extends Pet>
接口可以这么编写
interface Processor<T,E extends Exception> {
    void process(List<T> resultCollector) throws E;
}
类也可以这样
class ProcessRunner<T,E extends Exception> extends ArrayList<Processor<T,E>> {
    List<T> processAll() throws E {
        // ...
        return .....;
    }
}

几种表示方式如下：
Processor<T,E extends Exception>
Processor<T extends Exception>
Processor<? extends Exception>
Processor<T,E>
Processor<T>

3）Class用法
Class<?>
java.lang.Class<T>
返回值可以这样 public <T extends AbsProduct> T createProduct(Class<T> c) {

4）==是比较引用还是内容？equals是比较引用还是内容？
答：==是引用比较，equals也是引用比较，为什么下述代码是内容比较呢？
        String s1 = new String("string");
        String s2 = new String("string");
        System.out.println(s1 == s2); // false
        System.out.println(s1.equals(s2)); // true
因为String的方法equals()重写了Object的equals()

5）可变参数
// 调用
variableParameter(111, 222, 333);
// 方法
    public static void variableParameter(int... n)  {
        System.out.println("--- 可变参数 ---");
        System.out.println("--- 可变参数 长度 ---"+n.length);
        for (int a : n) {
            System.out.println(a);
        }
    }

6）基本类型之间的强制转换
具体规则：
（1）布尔型和其它基本数据类型之间不能相互转换；
（2）byte型可以转换为short、int、、long、float和double；
（3）short可转换为int、long、float和double；
（4）char可转换为int、long、float和double；
（5）int可转换为long、float和double；
（6）long可转换为float和double；
（7）float可转换为double；

由低级到高级分别为：
byte ---（short，char) --- int --- long --- float --- double

范围：
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127

包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767

包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648
最大值：Integer.MAX_VALUE=2147483647（21亿）

包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808
最大值：Long.MAX_VALUE=9223372036854775807

包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38

包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308

包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：Character.MAX_VALUE=65535

转换时遵循的原则：
1）容量小的类型自动转换为容量的类型；
2）容量大的类型转换为容量小的类型时，要加强制转换符；
3）byte，short，char之间不会互相转换，并且三者在计算时首先转换为int类型；
4）实数常量默认为double类型， 整数常量默认为int类型；
5）short与char不能相互转换，byte与char不能相互转换；

7）List和Map容器
还有容器list和map的东西（List和Map）
HashMap
LinkedHashMap
TreeMap
*****等等
------------------------ 可独立编写成文档

8）持有引用
有三个引用
SoftReference    以实现内存敏感的高速缓存。
WeakReference    为实现“规范映射”而设计的。
PhantomReference    用以调度回收前的清理工作，它比Java终止机制更灵活。

ReferenceQueue
------------------------ 可独立编写成文档

9）volatile关键字
volatile关键字就是提示VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。
如下：
private volatile boolean canceled = false;
注：
好像volatile与synchronized同等，synchronized比volatile安全。
由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。
同步情况下一般都用synchronized

10）ThreadLocal
ThreadLocal当作静态域存储，保证不会出现竞争条件。
------------------------ 可独立编写成文档

11）并发包java.util.concurrent
java.util.concurrent引入了大量设计用来解决并发问题的新类
学习使用它们将有助于你编写出更加简单而健壮的并发程序。
如：
java.util.concurrent.CyclicBarrier 护栏
------------------------ 可独立编写成文档

12）线程
------------------------ 可独立编写成文档

13）
System.nanoTime()可产生纳秒为单位的时间。

14）final、static、static final使用说明
<1>、final用法
1）用在变量，不能修改，
2）用在对象，引用不能被修改
3）用在方法public final int method()，不允许子类覆写和当编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。
4）用在方法里的参数public int method(final int a)，int a不能修改，类似成员变量和成员对象
5）用在类头public final class A(){}，不能被继承
6）用在局部变量或对象，一个内部类对象使用局部变量或对象时，要给局部变量或对象加上final修饰符，
如果将一个访问了final的局部变量的内部类进行反编译，可以发现该变量是被作为构造函数的参数传入进去的，当然与之一起传入的参数还有外部类引用this。
相关文章：
局部内部类为什么只能访问final局部变量？
http://blog.csdn.net/edisonlg/article/details/7183373


<2>、static用法
1）用于变量或对象时，只有一个实例
2）用于方法时，可以直接通过类名调用（静态方法中不能用this和super关键字，就是不带static的成员变量和成员成员方法）
3）用于代码块时，static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。
4）用于类时，通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。如下代码所示：
定义为静态内部类，主要是为了可以像一个类一样使用方便，直接new，这种情况一般为public static class A(){}
或者是为了自己使用方便，这种情况一般为private static class A(){}

public class ClientApp {
    public static void main(String[] args) {
    // 使用
        OuterCls.InnerCls inner = new OuterCls.InnerCls();
    }
}

class OuterCls {
    public static class InnerCls { // 静态内部类
        InnerCls(){
            System.out.println("InnerCls");
        }
    }
}


<3>、static final用法（static表示全局，final表示常量，static final表示全局常量）
1）如果一个数据既是static又是final，那么它会拥有一块无法改变的存储空间。
2）两者是一样的
public final static int i = 10;
public static final int i = 10;