Java类包+final声明

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 2
        out.println("data2");           //data2
        out.println(new FinalData());   //0 2
        out.println(data);              //10 2
    }
}

输出：
        -----9
        -----9
        -----9
        -----9
        -----9
        -----9
        7 9
        data2
        14 9
        7 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的a1
    private static final int a2 = rand.nextInt(10); //赋值定义为static final 的a2

    public static void main(String[] args) {
        FInalStaticData fdata = new FInalStaticData();  //实例化一个对象
        out.println("实例化对象调用a1的值：" + fdata.a1);     //实例化对象调用a1的值：5
        out.println("实例化对象调用a2的值：" + fdata.a2);     //实例化对象调用a2的值：9
        
        FInalStaticData fdata2 = new FInalStaticData(); //重新实例化一个对象
        out.println("重新实例化对象调用a1的值：" + fdata2.a1);  //重新实例化对象调用a1的值：1
        out.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形式。