1.包的特性：

1. Java类包简称包，同一个包中的类互相访问时，可以不指定包名。

2. Java包命名规则是全部使用小写。

3.在类中指定包名时，需要将package表达式放置在程序的第一行。

4. javac -d ./bin/ ./com/lzw/*.java:

        通过 -d 参数，用于指定编译后类文件产生的位置,这样编译成功后 将在当前运行路径下的bin目录中产生com/lzw路径，并在该路径下出现相应源文件的类文件。

2.import导入静态成员

        import除了导入包之外，还可以导入静态成员。

        import static 静态成员

package com.lzw;import static java.lang.Math.max;
import static java.lang.System.out;public class importTest {public static void main(String[] args) {out.println("1和4的最大值是：" + max(1, 4));   //1和4的最大值是：4}
}

3.final关键字使用

final关键字可以用于声明变量，方法，类。

3.1 final变量（即常量）

        3.3.1 被final声明的变量，不可以再改变值；

        3.3.2 在声明的同时，不许对其进行赋值操作；

        3.3.3 final还可以修饰对象引用；

                数组也可以被看做为一个对象来引用，一旦对象引用被final修饰后，它只能恒定指向一个对象，无法改变其指向另一个对象；一个被final+static修饰的字段，只会占据一段不能改变的存储空间。

package com.lzw;import static java.lang.System.out;import java.util.Random;class Test {int i = 0;
}public class FinalData {static Random rand = new Random();private final int VALUE_1 = 9;  //定义一个final常量private static final int VALUE_2 = 10;  //声明一个final,static常量private final Test test = new Test();   //声明一个final引用private Test test2 = new Test();    //声明一个不少final的引用private static final int[] a = {1, 2, 3, 4, 5, 6}; //声明一个final的数组private final int i4 = rand.nextInt(20);    //返回一个随机整数private static final int i5 = rand.nextInt(20);public String toString() {return i4 + " " + i5 + " ";}public static void main(String[] args) {FinalData data = new FinalData();
//      data.test = new Test();   不能将指定为final的引用指向其他引用
//      data.VALUE_1++;   不能修改定义为final的常量值data.test2 = new Test();    //可以将没有设定为final的引用指向其他引用for (int i = 0; i < data.a.length; i++) {a[i] = 9;out.println("-----" + a[i]);}out.println(data);              //10 2out.println("data2");           //data2out.println(new FinalData());   //0 2out.println(data);              //10 2}
}输出：-----9-----9-----9-----9-----9-----97 9data214 97 9

package com.lzw;import static java.lang.System.out;
import java.util.Random;public class FInalStaticData {private static Random rand = new Random();  //实例化一个Random类对象private final int a1 = rand.nextInt(10);    //赋值定义为final的a1private static final int a2 = rand.nextInt(10); //赋值定义为static final 的a2public static void main(String[] args) {FInalStaticData fdata = new FInalStaticData();  //实例化一个对象out.println("实例化对象调用a1的值：" + fdata.a1);     //实例化对象调用a1的值：5out.println("实例化对象调用a2的值：" + fdata.a2);     //实例化对象调用a2的值：9FInalStaticData fdata2 = new FInalStaticData(); //重新实例化一个对象out.println("重新实例化对象调用a1的值：" + fdata2.a1);  //重新实例化对象调用a1的值：1out.println("重新实例化对象调用a2的值：" + fdata2.a2);  //重新实例化对象调用a2的值：9}
}

        从上述运行结果看，定义final的常量不是恒定不变的，将随机数赋值给final常量，可以做到每次运行程序时改变a1的值，但a2的值因为被声明称static final形式，所以恒定不变。a2是在装载时被初始化，而不是每次创建新对象时都被初始化；而a1会在每次实例化新对象时被改变。 

3.2 final方法

        被final声明的方法，不能被重写。被private修饰的成员，不能被其他类访问。

package com.lzw;class Parents {private final void doIt() {System.out.println("父类.doIt()");}final void doIt2() {System.out.println("父类.doIt2()");}public void doIt3() {System.out.println("父类.doIt3()");}
}class Sub extends Parents {public final void doIt() {System.out.println("子类.doIt()");}//    final void doIt2(){}    父类的final方法不能被重写覆盖public void doIt3() {System.out.println("子类.doIt3()");}
}public class FinalMethod {public static void main(String[] args) {Sub s = new Sub();s.doIt();           //子类.doIt()s.doIt2();          //父类.doIt2()s.doIt3();          //子类.doIt3()System.out.println("----------------");Parents p = s;  //向上转型p.doIt2();          //父类.doIt2()p.doIt3();          //子类.doIt3()}
}

3.3 final类

        语法：

        final class 类名{}

        3.3.1 被final声明的类，不能被继承。

        3.3.2 final类中所有的方法都隐式地被设置为final形式，但是成员变量可以定义为非final形式。