constantjava

❶ java中constant是干嘛用的

你进入constant这个类看看就知道了，里面都是一些项目中常用的常量，比如：用户名、密码、权限什么的。

❷ java的Util.formatDateTime和Constant为什么有错误，很多包我不知道该引入哪一个

因为不同包中的类虽然同名但类结构不同，如果你导错包了，你的Java代码要么报错，要么达不到预期目的。最好导包之前先查一下API，了解清楚同名类的区别再用。

❸ Java的const怎么用

const是constant的缩写，“恒定不变”的意思。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性和高效性。

1 用const修饰函数的参数
如果参数作输出用，不论它是什么数据类型，也不论它采用“指针传递”还是“引用传递”，都不能加const修饰，否则该参数将失去输出功能。
const只能修饰输入参数：
u 如果输入参数采用“指针传递”，那么加const修饰可以防止意外地改动该指针，起到保护作用。
例如StringCopy函数：
void StringCopy(char *strDestination, const char *strSource);
其中strSource是输入参数，strDestination是输出参数。给strSource加上const修饰后，如果函数体内的语句试图改动strSource的内容，编译器将指出错误。

u 如果输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const修饰。
例如不要将函数void Func1(int x)写成void Func1(const int x)。同理不要将函数void Func2(A a) 写成void Func2(const A a)。其中A为用户自定义的数据类型。

u 对于非内部数据类型的参数而言，象void Func(A a) 这样声明的函数注定效率比较底。因为函数体内将产生A类型的临时对象用于复制参数a，而临时对象的构造、复制、析构过程都将消耗时间。
为了提高效率，可以将函数声明改为void Func(A& a)，因为“引用传递”仅借用一下参数的别名而已，不需要产生临时对象。但是函数void Func(A& a) 存在一个缺点：“引用传递”有可能改变参数a，这是我们不期望的。解决这个问题很容易，加const修饰即可，因此函数最终成为void Func(const A& a)。
以此类推，是否应将void Func(int x) 改写为void Func(const int& x)，以便提高效率？完全没有必要，因为内部数据类型的参数不存在构造、析构的过程，而复制也非常快，“值传递”和“引用传递”的效率几乎相当。
对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const引用传递”，目的是提高效率。例如将void Func(A a) 改为void Func(const A& a)。
对于内部数据类型的输入参数，不要将“值传递”的方式改为“const引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func(int x) 不应该改为void Func(const int& x)。

2 用const修饰函数的返回值
u 如果给以“指针传递”方式的函数返回值加const修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const修饰的同类型指针。
例如函数
const char* GetString(void);
如下语句将出现编译错误：
char *str = GetString();
正确的用法是
const char *str = GetString();
u 如果函数返回值采用“值传递方式”，由于函数会把返回值复制到外部临时的存储单元中，加const修饰没有任何价值。
例如不要把函数int GetInt(void) 写成const int GetInt(void)。
同理不要把函数A GetA(void) 写成const A GetA(void)，其中A为用户自定义的数据类型。
如果返回值不是内部数据类型，将函数A GetA(void) 改写为const A& GetA(void)的确能提高效率。但此时千万千万要小心，一定要搞清楚函数究竟是想返回一个对象的“拷贝”还是仅返回“别名”就可以了，否则程序会出错。例如：

[cpp] view plainprint?
class String
{
//…
// 赋值函数
String & operate=(const String &other);
// 相加函数，如果没有friend修饰则只许有一个右侧参数
friend String operate+(const String &s1, const String &s2);
private:
char *m_data;
}
class String
{
//…
// 赋值函数
String & operate=(const String &other);
// 相加函数，如果没有friend修饰则只许有一个右侧参数
friend String operate+(const String &s1, const String &s2);
private:
char *m_data;
}

String的赋值函数operate = 的实现如下：

[cpp] view plainprint?
String& String::operate=(const String &other)
{
if (this == &other)
return *this;
delete m_data;
m_data = new char[strlen(other.data)+1];
strcpy(m_data, other.data);
return *this; // 返回的是*this的引用，无需拷贝过程
}
String& String::operate=(const String &other)
{
if (this == &other)
return *this;
delete m_data;
m_data = new char[strlen(other.data)+1];
strcpy(m_data, other.data);
return *this; // 返回的是*this的引用，无需拷贝过程
}

对于赋值函数，应当用“引用传递”的方式返回String对象。如果用“值传递”的方式，虽然功能仍然正确，但由于return语句要把 *this拷贝到保存返回值的外部存储单元之中，增加了不必要的开销，降低了赋值函数的效率。例如：
String a,b,c;
…
a = b; // 如果用“值传递”，将产生一次 *this 拷贝
a = b = c; // 如果用“值传递”，将产生两次 *this 拷贝

String的相加函数operate + 的实现如下：

[cpp] view plainprint?
String String::operate+(const String &s1, const String &s2)
{
String temp;
delete temp.data; // temp.data是仅含‘\0’的字符串
temp.data = new char[strlen(s1.data) + strlen(s2.data) + 1];
strcpy(temp.data, s1.data);
strcat(temp.data, s2.data);
return temp;
}
String String::operate+(const String &s1, const String &s2)
{
String temp;
delete temp.data; // temp.data是仅含‘\0’的字符串
temp.data = new char[strlen(s1.data) + strlen(s2.data) + 1];
strcpy(temp.data, s1.data);
strcat(temp.data, s2.data);
return temp;
}

对于相加函数，应当用“值传递”的方式返回String对象。如果改用“引用传递”，那么函数返回值是一个指向局部对象temp的“引用”。由于temp在函数结束时被自动销毁，将导致返回的“引用”无效。例如：
c = a + b;
此时 a + b 并不返回期望值，c什么也得不到，留下了隐患。

u 函数返回值采用“引用传递”的场合并不多，这种方式一般只出现在类的赋值函数中，目的是为了实现链式表达。
例如

[cpp] view plainprint?
class A
{//…
A& operate = (const A &other); // 赋值函数
};
class A
{//…
A& operate = (const A &other); // 赋值函数
};

A a, b, c; // a, b, c 为A的对象
…
a = b = c; // 正常的链式赋值
(a = b) = c; // 不正常的链式赋值，但合法
如果将赋值函数的返回值加const修饰，那么该返回值的内容不允许被改动。上例中，语句 a = b = c仍然正确，但是语句 (a = b) = c 则是非法的。

3 用const修饰成员函数
const成员函数是指在类的成员函数后面加 const的函数，如int GetNum() const; const修饰成员函数的作用是：只能读取数据成员，不能改变数据成员。const成员函数只能调用const函数，不能调用其它非const成员函数；const对象只能调用const成员函数，不能调用非const成员函数。
任何不会修改数据成员的函数都应该声明为const类型。如果在编写const成员函数时，不慎修改了数据成员，或者调用了其它非const成员函数，编译器将指出错误，这无疑会提高程序的健壮性。

❹ java中什么是静态变量，什么是常量

在C++中(以及其他一些语言，如 C#，Java 等面向对象的语言中)类的成员变量被声明为static（称为静态成员变量），意味着它为该类的所有实例所共享，也就是说当某个类的实例修改了该静态成员变量，其修改值为该类的其它所有实例所见。
比如在某个类A中声明一个static int number;初始化为0。这个number就能被所有A的实例共用。在A的构造函数里加上number++，在A的析构函数里加上number--。那么每生成一个A的实例，number就加一，每销毁一个A的实例，number就减一，这样，number就可以记录程序中共生成了多少个A的实例。
这只是静态成员的一种用法而已。

常量(constant）
也称常数，是一种恒定的或不可变的数值或数据项。
它们可以是不随时间变化的某些量和信息，也可以是表示某一数值的字符或字符串，常被用来标识、测量和比较。

❺ 网上书店查询书籍功能，定义这个 Constant.java 是什么用处的，

- -!!
类别：静态类
BY_AUTHOR BY_ISBN BY_KEYWORD分别是里面的成员
功能：实体类
用于保存从数据库取出的数值 也就是后面注释写的 作者 书 和关键字
有了这个类以后 相当于多了一道工序 以前是直接从数据库查 现在查了一次
之后 保存在实体类中 以后直接调用实体类的数据

也就是实现了 我们所说的三层架构模式

❻ java 为什么使用constant类

constant 用来修饰变量,使变量的值一旦确定不能修改。 再细点说,就是基本类型的变量赋值后不能改变其值,对象变量赋值后不能更改对象引用值

❼ Java里constant是干什么的

constant 用来修饰变量，使变量的值一旦确定不能修改。

再细点说，就是基本类型的变量赋值后不能改变其值，对象变量赋值后不能更改对象引用值

❽ java中常见的异常类

从异常类的继承架构图中可以看出：Exception 类扩展出数个子类，其中 IOException、RunntimeException 是较常用的两种。

习惯上将 Error 与 Exception 类统称为异常类，但这两者本质上还是有不同的。Error 类专门用来处理严重影响程序运行的错误，可是通常程序设计者不会设计程序代码去捕捉这种错误，其原因在于即使捕捉到它，也无法给予适当的处理，如 JAVA 虚拟机出错就属于一种 Error。

不同于 Error 类，Exception 类包含了一般性的异常，这些异常通常在捕捉到之后便可做妥善的处理，以确保程序继续运行，如 TestException7_2 里所捕捉到的 就是属于这种异常。

RunntimeException 即使不编写异常处理的程序代码，依然可以编译成功，而这种异常必须是在程序运行时才有可能发生，例如：数组的索引值超出了范围。

与RunntimeException 不同的是，IOException 一定要编写异常处理的程序代码才行，它通常用来处理与输入/输出相关的操作，如文件的访问、网络的连接等。

当异常发生时，发生异常的语句代码会抛出一个异常类的实例化对象，之后此对象与 catch 语句中的类的类型进行匹配，然后在相应的 catch 中进行处理。

(8)constantjava扩展阅读：

Java异常的分类：

Java标准裤内建了一些通用的异常，这些类以Throwable为顶层父类。

Throwable又派生出Error类和Exception类。

错误：Error类以及他的子类的实例，代表了JVM本身的错误。错误不能被程序员通过代码处理，Error很少出现。因此，程序员应该关注Exception为父类的分支下的各种异常类。

异常：Exception以及他的子类，代表程序运行时发送的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。

参考资料：网络-异常

❾ Java中调用常量

以上该类常量是该类对象的属性是不对的，属性只有在定义封装后set和get方法才出现的。只能说是该对象的成员字段。

❿ 在Java中,可以用关键字constant来声明一个常量吗

java中，声明常量用 static