为您找到与java构造函数和构造方法的区别相关的共200个结果:
switch和if语句都是Java的选择语句,这两种语句都是允许在程序运行时控制程序的执行过程。那么,switch和if在具体用法上什么具体区别,下面读文网小编给你介绍一下Java中switch和if语句的区别。
首先要看一个问题,if 语句适用范围比较广,只要是 boolean 表达式都可以用 if 判断;而 switch 只能对基本类型进行数值比较。两者的可比性就仅限在两个基本类型比较的范围内。
说到基本类型的数值比较,那当然要有两个数。然后重点来了——
if 语句每一句都是独立的,看下面的语句:
if (a == 1) ...
else if (a == 2) ...
这样 a 要被读入寄存器两次,1 和 2 分别被读入寄存器一次。于是你是否发现其实 a 读两次是有点多余的,在你全部比较完之前只需要一次读入寄存器就行了,其余都是额外开销。但是 if 语句必须每次都把里面的两个数从内存拿出来读到寄存器,它不知道你其实比较的是同一个 a。
于是 switch case 就出来了,把上面的改成 switch case 版本:
switch (a) {
case 0:
break;
case 1:
}
因为特定的规则,他一开始就知道你要比 a,于是 a 一次性读取,相比 if 节约了很多开销。
然后根据大量的实际程序测试(不考虑不同的编译器优化程度差异,假设都是最好的优化),那么Switch语句击中第三个选项的时间跟if/else if语句击中第三个选项的时间相同。
击中第一,第二选项的速度if语句快,击中第四以及第四之后的选项的速度switch语句快。
所以,如果所有选项出现概率相同的话,结论就是:5个选项(包括default)的情况下,switch和if/else if相同。低于5个选项if快,高于5给选项switch快!
浏览量:4
下载量:0
时间:
在编程的时候往往会出现系统编译时无法检测到的错误,可是在运行时会出错,如果在可能出错的地方抛出异常,那样便严整了代码的正确性.比如数组越界,分母为0,文件等。 编程中会用try语句和throw语句来对编程运行过程中出现的异常情况进行处理。那么这两种有什么区别呢?下面小编带你去了解一下。
Java通过面向对象的方法进行异常处理,把各种不同的异常进行分类,并提供了良好的接口。在Java中,每个异常都是一个对象,它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象,该对象中包含有异常信息,调用这个对象的方法可以捕获到这个异常并进行处理。
Java的异常处理是通过5个关键词来实现的:try、catch、throw、throws和finally。一般情况下是用try来执行一段程序,如果出现异常,系统会抛出(throws)一个异常,这时候你可以通过它的类型来捕捉(catch)它,或最后(finally)由缺省处理器来处理。
用try来指定一块预防所有“异常”的程序。紧跟在try程序后面,应包含一个catch子句来指定你想要捕捉的“异常”的类型。
throw语句用来明确地抛出一个“异常”。throws用来标明一个成员函数可能抛出的各种“异常”。
Finally为确保一段代码不管发生什么“异常”都被执行一段代码。可以在一个成员函数调用的外面写一个try语句,在这个成员函数内部写另一个try语句保护其他代码。
每当遇到一个try语句,“异常”的框架就放到堆栈上面,直到所有的try语句都完成。如果下一级的try语句没有对某种“异常”进行处理,堆栈就会展开,直到遇到有处理这种“异常”的try语句。
package book.exception;
/**
* 抛出异常和声明异常
* @author joe
*
*/
public class ThrowAndThrows {
/**
* 计算一个数字的平方根
* @param nStr 以字符串的形式提供数字
* @return 返回平方根
* @throws Exception 当用户输入的字符串为空,
* 或者字符串无法转换成数字,或者转换成的数字小于0,都会抛出异常
*/
public static double sqrt(String nStr) throws Exception {
if (nStr == null) {
https://用trow关键字抛出异常,当异常被抛出时,程序会跳出该方法
throw new Exception("输入的字符不能为空!");
}
double n = 0;
try {
n = Double.parseDouble(nStr);
} catch(NumberFormatException e) {
https://将parseDouble方法可能抛出的异常NumberFormatException捕获,
https://然后将捕获的异常重新封装并输出
throw new Exception("输入的字符串必须能够转化成数字!", e);
}
if (n < 0 ){
throw new Exception("输入的字符串转化成的数字必须大于0!");
}
return Math.sqrt(n);
}
public static void main(String[] args) throws Exception {
try{
ThrowAndThrows.sqrt("-124.56");
} catch(Exception e) {
https://将sqrt方法声明的可能抛出的Exception异常捕获
https://打印捕获的异常的堆栈信息,从堆栈信息中可以发现异常发生的位置和原因
System.out.println("Got a Exception:" + e.getMessage());
e.printStackTrace();
throw e; https://不做进一步处理,将异常向外抛出
}
https://将sqrt声明了可能会抛出的异常向外抛出,必须在方法声明中使用throws
ThrowAndThrows.sqrt("-124.56");
}
}
程序输出结果:
Got a Exception:输入的字符串转化成的数字必须大于0!
java.lang.Exception: 输入的字符串转化成的数字必须大于0!
at book.exception.ThrowAndThrows.sqrt(ThrowAndThrows.java:30)
at book.exception.ThrowAndThrows.main(ThrowAndThrows.java:37)
Exception in thread "main" java.lang.Exception: 输入的字符串转化成的数字必须大于0!
at book.exception.ThrowAndThrows.sqrt(ThrowAndThrows.java:30)
at book.exception.ThrowAndThrows.main(ThrowAndThrows.java:37)
源码分析:
在main方法里,由于sqrt方法的声明中有throws关键字,所以,在调用该方法时,必须对throws后面声明的异常进行处置,处置的方法有两种:
(1)main方法处理该异常,使用try.....catch语句,将可能会出现的异常的代码放在try块内,将处理异常的代码放在catch块内,并指明catch能够捕获的异常的类型,当异常被捕获时,执行catch块内的语句。
(2)main方法不处理该异常,将异常向外层程序抛出。在方法声明中使用throws关键字抛出异常,方法体中不需要使用try...catch语句。
异常类Exception的getMessage方法用来获取一场的描述信息,printStackTrace方法用来打印异常的堆栈信息,通过堆栈信息能够查明异常发生的原因和位置,在调试的时候常用。
浏览量:3
下载量:0
时间:
Java和.Net的区别就像Windows和Linux的区别,正因为Java学习门槛非常高,很多学习者被淘汰了下来,这样能够撑过一个个难关学习下来的开发人员都是水平比较高的人员。因此.Net初级开发人员的工资平均是比Java初级开发人员的工资平均略低的。但是由于.Net中高级人才非常缺乏,因此掌握.Net深入技术的开发人员在企业内部是非常吃香的,招聘人员经常发出这样的感叹“招合适的Java工程师能招来一堆,招合适的.Net工程师一个月都招不来几个”。
.Net秉承了微软技术的入门简单的特点,经过短时间的学习就可以掌握拖拉控件的快速开发方式,很多人被.Net的快速开发方式所满足,认为自己“学成了”,不再深入研究,因此人才市场上充斥着很多只会拖控件、而不懂.Net更深入一步技术的.Net开发人员,比如很多ASP.Net的书上都是讲ASP.Net服务端控件,很多所谓“精通ASP.Net”的人连什么是Http、HTML、JavaScript、Dom等基本概念都稀里糊涂,实际公司项目中很多功能点的实现不是简单的拖一个ASP.Net服务端控件就能搞定的,因此看似学习.Net的人非常多,但是真正满足企业要求的人则比较少;而Java则入门门槛比较高,如果想要配置一个Hello World级别的学习环境就会涉及到很多技术,开发环境也要学习者自行配置,对于初学者来说可能花费一周时间都无法配置一个最简单的环境出来,Java的开发环境也不像.Net开发环境那么可用性强。
浏览量:2
下载量:0
时间:
计算机编程有很多专业的术语,如构造函数,有人会说构造函数不是编程方法吗?其实这两者还是有些区别的,下面小编告诉你。
public class UserManagerImpl implements UserManager {
private UserDao userDao;
public UserManagerImpl(UserDao userDao){
this.userDao=userDao;
}
public void save(String username,String password){
this.userDao.save(username, password);
}
}
浏览量:4
下载量:0
时间:
抽象类与接口紧密相关。然而接口又比抽象类更抽象,它们之间明显存在区别。那到底存在哪些方面的区别呢?下面读文网小编给大家讲讲Java中抽象类与接口的区别。
1,抽象类里可以有构造方法,而接口内不能有构造方法。
2,抽象类中可以有普通成员变量,而接口中不能有普通成员变量。
3,抽象类中可以包含非抽象的普通方法,而接口中所有的方法必须是抽象的,不能有非抽象的普通方法。
4,抽象类中的抽象方法的访问类型可以是public ,protected和默认类型,但接口中的抽象方法只能是public类型的,并且默认即为public abstract类型。
5,抽象类中可以包含静态方法,接口内不能包含静态方法。
6,抽象类和接口中都可以包含静态成员变量,抽象类中的静态成员变量的访问类型可以任意,但接口中定义的变量只能是public static类型,并且默认为public static类型。
7,一个类可以实现多个接口,但只能继承一个抽象类。
8.接口更多的是在系统框架设计方法发挥作用,主要定义模块之间的通信,而抽象类在代码实现方面发挥作用,可以实现代码的重用。
浏览量:3
下载量:0
时间:
Java中sleep和wait都是用来进行线程控制的,这两者之间有什么区别呢?下面,读文网小编带你去了解一下sleep与wait的区别。
sleep是Thread类的静态方法。sleep的作用是让线程休眠制定的时间,在时间到达时恢复,也就是说sleep将在接到时间到达事件事恢复线程执行。例如:
try{
System.out.println("I'm going to bed");
Thread.sleep(1000);
System.out.println("I wake up");
}
catch(IntrruptedException e) {
}
wait是Object的方法,也就是说可以对任意一个对象调用wait方法,调用wait方法将会将调用者的线程挂起,直到其他线程调用同一个对象的notify方法才会重新激活调用者。例如:
https://Thread 1
try{
obj.wait();https://suspend thread until obj.notify() is called
}
catch(InterrputedException e) {
}
浏览量:2
下载量:0
时间:
Java中,我们应该知道最基本的就是定义变量和声明变量了,定义与声明这两者是有区别的,小编在此整理了Java中定义与声明的区别,供大家参阅,希望大家在阅读过程中有所收获!
所谓定义就是(编译器)创建一个对象,为这个对象分配一块内存,并给它取上一个名字,这个名字就是就是我们经常所说的变量名或对象名。
声明有2重含义:
(1) 告诉编译器,这个名字已经匹配到一块内存上,下面的代码用到变量或者对象是在别的地方定义的。声明可以出现多次。
(2) 告诉编译器,这个名字已经被预定了,别的地方再也不能用它来作为变量名或对象名。
浏览量:2
下载量:0
时间:
初学Java的人,可能在在很长一段时间里,对对象和引用的基本概念都是很模糊的,老是分不清楚两者的区别。下面,读文网小编给你整理一些有关对象和引用的区别供有需要的人参考。
相互关联体现在:
1)当对象的引用变量指向对象时,他们两就联系起来,改变引用的属性,就会改变对象的属性;
2)如果同一个对象被多个引用变量引用的话,则这些引用变量将共同影响这个对象本身。
相互独立体现在:
3)一个对象可以被不同的引用变量操纵,同时一个引用变量也可以指向不同的对象,但是同一时刻只能指向一个对象;
4)从存储空间上来说,对象和引用也是独立的,对象一般存储在堆中,而引用存储在堆栈(存储速度更快)中。
浏览量:2
下载量:0
时间:
Java中有throw语句和throws语句,这两种语句都是用来抛出异常的。那么,这两种语句在具体运行的时候又有哪些区别呢?下面小编带你去了解一下。
用户程序自定义的异常和应用程序特定的异常,必须借助于 throws 和 throw 语句来定义抛出异常。
throw是语句抛出一个异常。
语法:
throw (异常对象);
throw e;
throws是方法可能抛出异常的声明。用在声明方法时,表示该方法可能要抛出异常。
语法:
[(修饰符)](返回值类型)(方法名)([参数列表])[throws(异常类)]{......}
public void doA(int a) throws Exception1,Exception3{......}
浏览量:3
下载量:0
时间:
NET是微软的王牌,不能跨平台,运行时,速度和Java基本不相上下,但是.NET的开发速度很快,但是安全性总是.NET开发者的瓶颈,在有就是在.NET中的线程很难控制.
Java是跨平台的,而且Java开发的安全性最高,线程很好控制,运行速度是依据框架而定的,如果用Struts开发Web它的速度会比较平均,但是用JSF它的启动很慢,但是一旦加载完毕后,速度飞快,只要不清楚浏览器记录,它就会永远保持此速度.但是Java也存在许多问题,比如开发速度及其缓慢,搭建框架时需要弄许多配置文件。
比较:
1.在 web 开发方面 java 绝对第一, 因为java 比 .net、 php更加稳定,安全,开发效率高,功能更加强大。java 在web 应用方面 光java服务器就有好多(tomcat,jboss,weblogic,websphere),这些都可以运行java项目,而.net 只可以在微软的IIS服务器上运行局限性很大。
2.在单机软件开发方面,如果开发windows应用那还是 .net 好一些,因为windows 和 .net都是微软的产品所以在开发window应用方面.net更兼容一些。
3.在智能设备软件开发上,java更强,你该知道 android 智能手机 ,它的应用都是用java 开发的,其实在android出来之前,就有J2me 能开发手机上的软件了。
总的说来,java 的前景比.net 好,现在做java 的公司绝对比.net 多。两者在上述三个方面都能做,我在上面三个方面比较了一下哪个更强。 也就是说 java 比 .net更强。这么说吧,一般银行的网上系统都选用 java开发,这就不言而喻了。
浏览量:2
下载量:0
时间:
对于Java中重载和覆盖的概念,很多人到现在都是搞不清楚,下面小编举例给大家讲讲这两者的区别。
下面是对override和overload的测试程序,其中注释中的内容都是会产生编译错误的代码,我们将注释去掉,看看在编译时会产生什么效果。
https:// 对overload测试的文件:OverloadTest.java
public class OverloadTest {
https:// 下面几个方法用来验证可以通过定义不同的参数类型和参数的数目进行方法重载。
public void fun(){
System.out.println("method fun in OverloadTest, no parameter");
}
public void fun(float f) {
System.out.println("method fun in OverloadTest, parameter type: float");
}
public void fun(int i){
System.out.println("method fun in OverloadTest, parameter type: int");
}
public void fun(int i1, int i2) {
System.out.println("method fun in OverloadTest, parameter type: int, int");
}
https:// 下面的两个方法用来验证可以通过定义不同的参数顺序进行方法重载。
https:// 需要注意:这里的参数肯定不是相同的类型,否则的顺序的先后就毫无意义。
public void fun1(int i, float f) {
System.out.println("method fun1 in OverloadTest, sequence of parameters is: int, float");
}
public void fun1(float f, int i) {
System.out.println("method fun1 in OverloadTest, sequence of parameters is: float, int");
}
https:// 下面的两个方法用来验证方法抛出的异常对于重载的影响.
https:// 无论是异常的类型还是异常的个数都不会对重载造成任何的影响。
public void fun2() throws TestException {
System.out.println("fun2 in OverloadTest, exception: TestException");
}
public void fun2(int i) throws TestException, TestException1 {
System.out.println("fun2 in OverloadTest, exception: TestException, TestException1");
}
public void fun2(float f) throws Exception {
System.out.println("fun2 in OverloadTest, exception: Exception");
}
https:// 不能通过抛出的异常类型来重载fun方法。
https://public void fun(int i) throws Exception {
https:// System.out.println("method fun in OverloadTest, parameter type: int, exception: Exception");
https://}
https:// ? 不能通过返回值重载fun方法。
https://public boolean fun(int i) throws Exception {
https:// System.out.println("method fun in OverloadTest, parameter type: int, exception: Exception, return: boolean");
https:// return true;
https://}
private void fun3() { }
https:// 不能通过不同的访问权限进行重载
public void fun3() { }
public static void main(String[] args) {
https:// 这里只是定义了OverloadTest的实例,所以test不会调用
https:// OverloadTest1中的方法。
OverloadTest test = new OverloadTest1();
https:// 这里定义了OverloadTest1的实例,因为OverloadTest1是OverloadTest
https:// 的子类,所以test1会调用OverloadTest中的方法。
OverloadTest1 test1 = new OverloadTest1();
try {
int i = 1, j = 2, m = 3;
https:// 这里不会调用OverloadTest1的fun方法
https:// test.fun(i, m, j);
test1.fun(i, j, m);
test1.fun();
https:// 这个调用不会执行,因为fun3()在OverloadTest中访问权限是priavte
https://test1.fun3();
test1.fun3(i);
} catch(Exception e) { }
}
}
class OverloadTest1 extends OverloadTest{
https:// 在子类中重载fun
public void fun(int i, int m, int n) {
System.out.println("Overload fun1 in OverloadTest1, parameter type: int, int, int");
}
https:// 这个不是对父类中方法的重载,只是一个新的方法。
public void fun3(int i) {
System.out.println("fun2 in OverloadTest1");
}
}
https:// 对override测试的文件:OverrideTest.java
public class OverrideTest {
public void fun() throws TestException {
System.out.println("method fun in OverrideTest");
}
private void fun1() {
System.out.println("method fun1 in OverrideTest");
}
public static void main(String[] args) {
OverrideTest test = new OverrideTest1();
try {
test.fun();
test.fun1();
} catch(Exception e) { }
}
}
class OverrideTest1 extends OverrideTest{
https:// 以下正常Override
public void fun() throws TestException2 {
System.out.println("fun in OverrideTest1");
}
https:// 不能Override父类中的方法,因为它定义了不同的异常类型和
https:// 返回值。
https://public int fun() throws TestException1 {
https:// System.out.println("method fun in Test");
https:// return 1;
https://}
https:// 不能Override父类中的方法,因为它抛出了比父类中非法范围
https:// 更大的异常。
https://public void fun() throws Exception {
https:// System.out.println("fun in OverrideTest1");
https://}
https:// 这个方法并没有Override父类中的fun1方法,因为这个方法在
https:// 父类是private类型,所以这里只是相当于定义了一个新方法。
public void fun1() {
System.out.println("method fun1 in Test");
}
}
class TestException extends Exception{
public TestException(String msg) {
super(msg);
}
}
class TestException1 extends TestException {
public TestException1(String msg) {
super(msg);
}
}
class TestException2 extends TestException {
public TestException2(String msg) {
super(msg);
}
}
浏览量:3
下载量:0
时间:
Java和PHP都是编程语言,大家知道它们最大的区别就是一个是静态语言,一个是动态语言。下面,读文网小编再详细的解释一下这两者的具体区别和比,希望对你有帮助。
1、系统的技术架构比较
分层是将系统进行有效组织的方式,分而治之的思想是计算机领域中非常重要的思想。在好的分层思想引导下,便能实现“高内聚、低耦合”,也能将具体的问题 割裂开来,易于控制、易于延展,更易于分配资源。PHP只能实现简单的分布式两层或三层的架构,而JAVA在这方面就十分强大,可以实现多层的网络架构。运用MVC的设计模式,可使电子商务软件具有更加高效、合理的系统架构。技术架构的落后,使运用PHP编写的电子商务软件先天不足,而后天又无法补足其先天上的劣势。使得系统在可拓展性、需求应变性上与JAVA编写的电子商务软件系统的差距越来越大。架构的差距,注定了PHP做的电子商务充其量是个小家碧玉,始终无法和JAVA这种大家闺秀同台竞技。
2、数据库访问比较
PHP可编译成具有与许多数据库相连接的函数。将自己编写外围的函数去间接存取数据库。通过这样的途径当更换使用的数据库时,可以轻松地修改编码以适应这样的变化。但PHP提供的数据库接口支持彼此不统一,比如对Oracle,MySQL,SQL2000的接口,彼此都不一样。由于PHP对于不同的数据库采用不同的数据库访问接口,所以数据库访问代码的通用性不强。
3、安全性对比
在JAVA的面前,PHP丢掉了很多的优势。在代码的安全性上尤为突出。PHP的开发程序在别人拿到代码后,可以很容易的进行修改。而JAVA开发的程序由于无法看到完整的源代码,只能看到一些编译好的类文件.class,所以安全性较高。加之系统架构的优势,在安全性上PHP和JAVA是相去甚远。如果非要将PHP和JAVA在安全性上做个比较的话,同一个小偷光顾PHP那是随便拿来随便改,想拿什么拿什么,拿的高兴还能大笔一辉某某到此一游。而光顾JAVA的时候,便会发现警察把守,内设自动报警装置,即便突破重重阻扰后进入居室。那值钱的东西都放在加密后的保险柜中,只能望洋兴叹、铩羽而归。
4、前瞻性和拓展性
从整体来说,PHP适用于中小型系统,而JAVA适用于大型系统。PHP能够将单一的事件做好,但却不适合完成集成度较高的多项并发事件。为什么说PHP适合中小型系统而不适合做大系统呢?
首先,PHP缺乏多层结构支持。而对于大型的系统负荷站点,只能采用分布计算。将数据库、应用逻辑层和表示逻辑层彼此分开,并将同层的根据流量分开,组成二维数组。而PHP恰恰缺乏这种支持。
其次,PHP提供的数据库接口不统一,要将多个不同的数据库数据统一需要花费很大的力气。而JAVA则没有这种缺陷,可通过SUN JAVA的JAVA Class和EJB获得规模支持,通过EJB/CORBA以及众多厂商的Application Server获得结构支持。如ProBIZ的Merchant one电子商务软件产品系列。
#p#副标题#e#
浏览量:2
下载量:0
时间:
Java中用final定义的变量可以看做一个常量,那么static与final之间有什么区别呢?下面小编告诉你。
final可修饰类、域(变量和常量)、方法 (而static不修饰类)
1、final修饰类,表示该类不可被继承。
如定义了一个final类:
final class SnowBird{
int i;
String s;
static void fly(){
System.out.println("snowbird is flying");
}
}
https://现在定义一个类,试图继承SnowBird类:
public class Bird extends SnowBird{
public static void main(String[] args){
SnowBird.fly();
}
}
把上面的两个类拷贝到文件中,文件名保存为Bird.java ,现在编译看看会出现什么问题?
出错信息是:cannot inherit from final SnowBird
表明final 类不可被继承。
那么,final修饰变量是怎么样呢?
2、final修饰变量
程序中经常需要定义各种类型的常量,如:3.24268,"201"等等。这时候我们就用final来修饰一个类似于标志符名字。如:
final String connectNumber = "201";
final表明 connectNumber是一个常量,它的取值在整个过程都不会改变。
如果把final 去掉则connectNumber就成为变量了。
有时我们为了节省空间,常量通常声明为 static .因为如上所说的 static 用的是类的内存空间。
3、修饰方法:
final修饰的方法,称为最终方法。最终方法不可被子类重新定义,即不可被覆盖。
如父类定义了public void fly(){ ....}
则子类就不能定义
public void fly(){。。。。。。}
但注意覆盖与重载的区别。不能被覆盖并不是不能被重载,如你还可以定义
public void fly(int i){.....},
举个例子如下:
class FinalValue {
static final int i = 1;
final void fly(){
System.out.println("SnowBird is flying over FinalValue ");
}
}
class TestFinal extends FinalValue {
int i = 2;
void fly(){
System.out.println("SnowBird is flying over TestFinal");
System.out.println("In class FinalValue static Final i = "+ FinalValue.i);
System.out.println("In class TestFinal i = "+ i);
}
void fly(String s){
System.out.println("fly("+ s + ")");
}
}
public class Test {
public static void main(String args[]){
TestFinal tf = new TestFinal();
tf.fly();
tf.fly("ok");
System.out.println(tf.i);
}
}
把上面的程序保存为Test.java编译看看,出现什么错误?
然后,把TestFinal类中的 void fly(){ ... } 注解掉
即 如下
/* void fly(){
System.out.println("SnowBird is flying over TestFinal");
System.out.println("In class FinalValue static Final i = "+ FinalValue.i);
System.out.println("In class TestFinal i = "+ i);
}*/
浏览量:2
下载量:0
时间:
在程序中存在大量的数据来代表程序的状态,其中有些数据在程序的运行过程中值会发生改变而有些不能发生改变,这些数据在程序中分别被叫做变量和常量。下面小编跟大家讲讲Java中变量和常量之间的区别,一起来看看。
常量:其值不变即为常量。
语法:
数据类型 常量名 = 值;
double PI = 3.14;
备注:
一般默认常量名大写。
变量与常量之间关系(量间关系)
先来一个简单的实例,好了解 Java 里变量与常量之间的关系。
下面的程序里声明了两种 Java 经常使用到的变量,分别为整型变量 num 与字符变量 ch。为它们赋值后,再把它们的值分别显示在控制台上:
下面的程序声明了两个变量,一个是整型,一个是字符型
输出结果:
3 是整数!
z 是字符!
说明:
声明了两种不同类型的变量 num 与 ch,并分别将常量 3 与字符“z”赋值给这两个变量,最后再将它们显示在显示器上。声明一个变量时,编译程序会在内存里开辟一块足以容纳此变量的内存空间给它。不管变量的值如何改变,都永远使用相同的内存空间。因此,善用变量将会是一种节省内存的方式。
常量是不同于变量的一种类型,它的值是固定的,例如整数常量、字符串常量。通常给变量赋值时,会将常量赋值给它,在程序 TestJava 中,第 6 行 num 是整型变量, 而 3 则是常量。 此行的作用是声明 num 为整型变量, 并把常量 3 这个值赋给它。
相同的,第 7 行声明了一个字符变量 ch,并将字符常量'z'赋给它。当然,在程序进行的过程中,可以为变量重新赋值,也可以使用已经声明过的变量。
常量代表程序运行过程中不能改变的值。
常量在程序运行过程中主要有2个作用。
分别为代表常数,便于程序的修改和增强程序的可读性。
常量的语法格式和变量类型,只需要在变量的语法格式前面添加关键字final即可。在Java编码规范中,要求常量名必须大写。
则常量的语法格式如下
final 数据类型 常量名称 = 值;
final 数据类型常量名称1 = 值1, 常量名称2 = 值2,……常量名称n = 值n;
例如:
final double PI = 3.14;
final char MALE=‘M’,FEMALE=‘F’;
在Java语法中,常量也可以首先声明,然后再进行赋值,但是只能赋值一次,示例代码如下:
final int UP;
UP = 1;
常量的两种用途对应的示例代码分别如下:
代表常数
final double PI = 3.14;
int r =5;
double l = 2 * PI * r;
double s = PI * r * r;
在该示例代码中,常量PI代表数学上的∏值,也就是圆周率,这个是数学上的常数,后续的变量r代表半径,l代表圆的周长,s代表圆的面积。
则如果需要增加程序计算时的精度,则只需要修改PI的值3.14为3.1415926,重新编译程序,则后续的数值自动发生改变,这样使代码容易修改,便于维护。
增强程序的可读性
int direction;
final int UP = 1;
final int DOWN = 2;
final int LEFT = 3;
final int RIGHT = 4;
在该示例代码中,变量direction代表方向的值,后续的四个常量UP、DOWN、LEFT和RIGHT分辨代表上下左右,其数值分别是1、2、3和4,这样在程序阅读时,可以提高程序的可读性。
猜你感兴趣:
浏览量:2
下载量:0
时间:
学过Java的都知道javac,它是Java语言的编译器,那么,这两者有什么具体的区别呢?下面读文网小编给大家介绍一下Java和javac的区别。
Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。
javac工具读由java语言编写的类和接口的定义,并将它们编译成字节代码的class文件。javac 可以隐式编译一些没有在命令行中提及的源文件。用 -verbose 选项可跟踪自动编译。
如果main.class属于c:jarabc.jar,并且在com.cnblogs.jeffchen这个包里,那么执行java -classpath c:classes;c:jarabc.jar;c:zipabc.zip;com.cnblogs.jeffchen.main即可, 但是如果classpath中包含多个jar包呢?并且其他jar包中也有com.cnblogs.jeffchen会发生什么情况?
在windows下,文件路径的分割符为反斜杠 类或者java文件列表的分割符为分号 ;
在linux下文件路径的分隔符位斜杠 /类或者java文件列表的分隔符为冒号 :
下面小编列举一个在linux下编译和运行的例子
/usr/local/java/bin/javac -classpath /tmp/javatest/lib/mail-1.3.3.jar -d /tmp/javatest/bin/ /tmp/javatest/src/jp/co/realseed/Capability.java
/usr/local/java/bin/java -classpath /tmp/javatest/lib/mail-1.3.3.jar:/tmp/javatest/bin/ jp.co.realseed.Capability
浏览量:2
下载量:0
时间:
众所周知,静态语言和动态语言是不一样的,那么,它们具体有哪些不同呢?就这个问题,小编以Java代表静态语言,以PHP代表动态语言,来跟大家分享两者八个方面的区别。
PHP只能实现简单的分布式两层或三层的架构,而JAVA在这方面就比较强大,可以实现多层的网络架构。数据库层(持久化层)、应用(业务)逻辑层、表示逻辑层彼此分开,而且现在不同的层都已经有一些成熟的开发框架的支持。
例如Struts就是利用java的Web开发技术实现了MVC的设计模式,而在业务逻辑层也有Spring框架,数据库持久化层有Hibernate等框架。这些框架可以方便开发者高效、合理、科学得架构多层的商业应用。
浏览量:3
下载量:0
时间:
HashMap和Hashtable是 Java Collection Framework 的两个重要成员,它们之间存在什么样的区别呢?下面读文网小编带你去了解了解一下。
HashTable不允许null值(key和value都不可以),HashMap允许null值(key和value都可以)。即 HashTable不允许null值其实在编译期不会有任何的不一样,会照样执行,只是在运行期的时候Hashtable中设置的话回出现空指针异常。 HashMap允许null值是指可以有一个或多个键所对应的值为null。当get()方法返回null值时,即可以表示 HashMap中没有该键,也可以表示该键所对应的值为null。因此,在HashMap中不能由get()方法来判断HashMap中是否存在某个键,而应该用containsKey()方法来判断。
浏览量:2
下载量:0
时间: