`
qepipnu
  • 浏览: 76851 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

每个初学者都应该搞懂的问题

阅读更多
Java精华积累

对于这个系列里的问题,每个学Java的人都应该搞懂。当然,如果只是学Java玩玩就无所谓了。如果你认为自己已经超越初学者了,却不很懂这些问题,请将你自己重归初学者行列。内容均来自于CSDN的经典老贴。
问题一:我声明了什么!
String s = "Hello world!";
许多人都做过这样的事情,但是,我们到底声明了什么?回答通常是:一个String,内容是“Hello world!”。这样模糊的回答通常是概念不清的根源。如果要准确的回答,一半的人大概会回答错误。
这 个语句声明的是一个指向对象的引用,名为“s”,可以指向类型为String的任何对象,目前指向"Hello world!"这个String类型的对象。这就是真正发生的事情。我们并没有声明一个String对象,我们只是声明了一个只能指向String对象的 引用变量。所以,如果在刚才那句语句后面,如果再运行一句:
String string = s;
我们是声明了另外一个只能指向String对象的引用,名为string,并没有第二个对象产生,string还是指向原来那个对象,也就是,和s指向同一个对象。
问题二:"=="和equals方法究竟有什么区别?
==操作符专门用来比较变量的值是否相等。比较好理解的一点是:
int a=10;
int b=10;
则a==b将是true。
但不好理解的地方是:
String a=new String("foo");
String b=new String("foo");
则a==b将返回false。
根 据前一帖说过,对象变量其实是一个引用,它们的值是指向对象所在的内存地址,而不是对象本身。a和b都使用了new操作符,意味着将在内存中产生两个内容 为"foo"的字符串,既然是“两个”,它们自然位于不同的内存地址。a和b的值其实是两个不同的内存地址的值,所以使用"=="操作符,结果会是 false。诚然,a和b所指的对象,它们的内容都是"foo",应该是“相等”,但是==操作符并不涉及到对象内容的比较。
对象内容的比较,正是equals方法做的事。
看一下Object对象的equals方法是如何实现的:
boolean equals(Object o){
return this==o;
}
Object 对象默认使用了==操作符。所以如果你自创的类没有覆盖equals方法,那你的类使用equals和使用==会得到同样的结果。同样也可以看出, Object的equals方法没有达到equals方法应该达到的目标:比较两个对象内容是否相等。因为答案应该由类的创建者决定,所以Object把 这个任务留给了类的创建者。
看一下一个极端的类:
Class Monster{
private String content;
...
boolean equals(Object another){ return true;}
}
我覆盖了equals方法。这个实现会导致无论Monster实例内容如何,它们之间的比较永远返回true。
所 以当你是用equals方法判断对象的内容是否相等,请不要想当然。因为可能你认为相等,而这个类的作者不这样认为,而类的equals方法的实现是由他 掌握的。如果你需要使用equals方法,或者使用任何基于散列码的集合(HashSet,HashMap,HashTable),请察看一下java doc以确认这个类的equals逻辑是如何实现的。
问题三:String到底变了没有?
没有。因为String被设计成不可变(immutable)类,所以它的所有对象都是不可变对象。请看下列代码:
String s = "Hello";
s = s + " world!";
s 所指向的对象是否改变了呢?从本系列第一篇的结论很容易导出这个结论。我们来看看发生了什么事情。在这段代码中,s原先指向一个String对象,内容是 "Hello",然后我们对s进行了+操作,那么s所指向的那个对象是否发生了改变呢?答案是没有。这时,s不指向原来那个对象了,而指向了另一个 String对象,内容为"Hello world!",原来那个对象还存在于内存之中,只是s这个引用变量不再指向它了。
通过上面的说明,我们 很容易导出另一个结论,如果经常对字符串进行各种各样的修改,或者说,不可预见的修改,那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变,所以对于每一个不同的字符串,都需要一个String对象来表示。这时,应该考虑使用StringBuffer类, 它允许修改,而不是每个不同的字符串都要生成一个新的对象。并且,这两种类的对象转换十分容易。
同时,我们还可以知道,如果要使用内容相同的字符串,不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化,把它设置为初始值,应当这样做:
public class Demo {
private String s;
...
public Demo {
s = "Initial Value";
}
...
}
而非
s = new String("Initial Value");
后者每次都会调用构造器,生成新对象,性能低下且内存开销大,并且没有意义,因为String对象不可改变,所以对于内容相同的字符串,只要一个String对象来表示就可以了。也就说,多次调用上面的构造器创建多个对象,他们的String类型属性s都指向同一个对象。
上面的结论还基于这样一个事实:对于字符串常量,如果内容相同,Java认为它们代表同一个String对象。而用关键字new调用构造器,总是会创建一个新的对象,无论内容是否相同。
至 于为什么要把String类设计成不可变类,是它的用途决定的。其实不只String,很多Java标准类库中的类都是不可变的。在开发一个系统的时候, 我们有时候也需要设计不可变类,来传递一组相关的值,这也是面向对象思想的体现。不可变类有一些优点,比如因为它的对象是只读的,所以多线程并发访问也不 会有任何问题。当然也有一些缺点,比如每个不同的状态都要一个对象来代表,可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本,即 StringBuffer。
问题四:final关键字到底修饰了什么?
final使得被修饰的变量"不变",但是由于对象型变量的本质是“引用”,使得“不变”也有了两种含义:引用本身的不变,和引用指向的对象不变。
引用本身的不变:
final StringBuffer a=new StringBuffer("immutable");
final StringBuffer b=new StringBuffer("not immutable");
a=b;//编译期错误
引用指向的对象不变:
final StringBuffer a=new StringBuffer("immutable");
a.append(" broken!"); //编译通过
可 见,final只对引用的“值”(也即它所指向的那个对象的内存地址)有效,它迫使引用只能指向初始指向的那个对象,改变它的指向会导致编译期错误。至于 它所指向的对象的变化,final是不负责的。这很类似==操作符:==操作符只负责引用的“值”相等,至于这个地址所指向的对象内容是否相等,==操作 符是不管的。
理解final问题有很重要的含义。许多程序漏洞都基于此----final只能保证引用永远指向固定对象,不能保证那个对 象的状态不变。在多线程的操作中,一个对象会被多个线程共享或修改,一个线程对对象无意识的修改可能会导致另一个使用此对象的线程崩溃。一个错误的解决方 法就是在此对象新建的时候把它声明为final,意图使得它“永远不变”。其实那是徒劳的。
问题五:到底要怎么样初始化!
本问题讨论变量的初始化,所以先来看一下Java中有哪些种类的变量。
1. 类的属性,或者叫值域
2. 方法里的局部变量
3. 方法的参数
对于第一种变量,Java虚拟机会自动进行初始化。如果给出了初始值,则初始化为该初始值。如果没有给出,则把它初始化为该类型变量的默认初始值。
int类型变量默认初始值为0
float类型变量默认初始值为0.0f
double类型变量默认初始值为0.0
boolean类型变量默认初始值为false
char类型变量默认初始值为0(ASCII码)
long类型变量默认初始值为0
所有对象引用类型变量默认初始值为null,即不指向任何对象。注意数组本身也是对象,所以没有初始化的数组引用在自动初始化后其值也是null。
对 于两种不同的类属性,static属性与instance属性,初始化的时机是不同的。instance属性在创建实例的时候初始化,static属性在 类加载,也就是第一次用到这个类的时候初始化,对于后来的实例的创建,不再次进行初始化。这个问题会在以后的系列中进行详细讨论。
对于第 二种变量,必须明确地进行初始化。如果再没有初始化之前就试图使用它,编译器会抗议。如果初始化的语句在try块中或if块中,也必须要让它在第一次使用 前一定能够得到赋值。也就是说,把初始化语句放在只有if块的条件判断语句中编译器也会抗议,因为执行的时候可能不符合if后面的判断条件,如此一来初始 化语句就不会被执行了,这就违反了局部变量使用前必须初始化的规定。但如果在else块中也有初始化语句,就可以通过编译,因为无论如何,总有至少一条初 始化语句会被执行,不会发生使用前未被初始化的事情。对于try-catch也是一样,如果只有在try块里才有初始化语句,编译部通过。如果在 catch或finally里也有,则可以通过编译。总之,要保证局部变量在使用之前一定被初始化了。所以,一个好的做法是在声明他们的时候就初始化他 们,如果不知道要出事化成什么值好,就用上面的默认值吧!
其实第三种变量和第二种本质上是一样的,都是方法中的局部变量。只不过作为参数,肯定是被初始化过的,传入的值就是初始值,所以不需要初始化。
问题六:instanceof是什么东东?
instanceof是Java的一个二元操作符,和==,>,<是同一类东东。由于它是由字母组成的,所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例,返回boolean类型的数据。举个例子:
String s = "I AM an Object!";
boolean isObject = s instanceof Object;
我们声明了一个String对象引用,指向一个String对象,然后用instancof来测试它所指向的对象是否是Object类的一个实例,显然,这是真的,所以返回true,也就是isObject的值为True。
instanceof有一些用处。比如我们写了一个处理账单的系统,其中有这样三个类:
public class Bill {//省略细节}
public class PhoneBill extends Bill {//省略细节}
public class GasBill extends Bill {//省略细节}
在处理程序里有一个方法,接受一个Bill类型的对象,计算金额。假设两种账单计算方法不同,而传入的Bill对象可能是两种中的任何一种,所以要用instanceof来判断:
public double calculate(Bill bill) {
if (bill instanceof PhoneBill) {
//计算电话账单
}
if (bill instanceof GasBill) {
//计算燃气账单
}
...
}
这样就可以用一个方法处理两种子类。
然而,这种做法通常被认为是没有好好利用面向对象中的多态性。其实上面的功能要求用方法重载完全可以实现,这是面向对象变成应有的做法,避免回到结构化编程模式。只要提供两个名字和返回值都相同,接受参数类型不同的方法就可以了:
public double calculate(PhoneBill bill) {
//计算电话账单
}
public double calculate(GasBill bill) {
//计算燃气账单
}
所以,使用instanceof在绝大多数情况下并不是推荐的做法,应当好好利用多态。


java类定义????
顶层类:可以被包含于一个包中,但不能被其它类包含的类.
被封闭类:用来表示嵌套类或内部类.
封闭类:用来表示包含嵌套类或内部类的类.
内部类:作为一个外部类一个成员.内部类是一种新的类型.
成员内部类:这种内部类是封闭实例的成员,和嵌类的定义的方式差不多,只不过是嵌类用关键字static作了限定词.
局部内部类:方法内部声明的类称做局部内部类.一个方法内部唯一能定义的类就是内部类,只要一些简单的代码就可以做到.
嵌套类:一个类的定义嵌套在另一个类的定义中,被包含的类叫称做一个嵌套类.它不是一个
顶层类.一个嵌套类也可以是一个内部类,具体依赖它的定义方式.java语言中也可将嵌套类表示为顶层内部类或静态内部类.
父类和子类:由类可以相互独立,也可通过继承来相互联系.在java语言中,如果两个类具有父子关系时有两种类.父亲类称做超类或父类,孩子被称做子类.
终结型类:用final声明的类,可以保证它始终不会被用做一个父类,这保证了类不会被继承,
它的方法也不会被重置.一些核心java类是终结型的,包括对私有类型和String的包装类.
抽象类:如果不希望一个类被实例化,就用关键字abstract把它声明为一个抽象类型,这样的
一个类只能被用作一个父类,然后可以继承它的子类创建子类对象.


Thinking in Java笔记
第四章 初始化和清除(Initialization&CleanUp)
主要章节内容:
4.1 构建器
4.2 方法过载
4.3 收尾和垃圾收集
4.4 成员初始化
关键词:Constructor,finalize(),初始化顺序
重点整理:
1.构造函数
要点:
构建器(Constructor)属于一种较特殊的方法类型,因为它没有返回值.这与void返回值存在着明显的区别。对于void返回值,尽管方法本身不会自动返回什么,但仍然可以
Java初学者容易混淆的几个问题
1.String类和StringBuffer类
它们都是处理字符串的类,但是它们有一个最大的区别,那就是,String对象是存储你不能改动的文本字符
串,相反,如果你希望改动,则应使用StringBuffer类作为替换.
eg1:
......
//omit some code
String s1="You are hired!";
System.out.println(s1.replace('h','f'));//用f把字串中的h替换了
System.out.println(s1);
......
//omit some code
运行结果:
You are fired!
You are hired!
结果分析:
从结果,明显可知,s1的值并没有被改变,而第一行结果只是屏幕内容的替换.
eg2:
......
//omit some code
StringBuffer s2=new StringBuffer("Hello from Java!");
s2.replace(6,10,"to");
System.out.println(s2);
......
//omit some code
运行结果:
Hello to Java!
结果分析:
显然,s2的值已改变.
2.位逻辑与条件逻辑
首 先声明, 为了与位逻辑更好区分开来,我把通常所说的逻辑取了个别名叫做条件逻辑.它们都有各自的操作符,位逻辑操作符有:&(与运算),^(异或运算), |(或运算);条件逻辑操作符有:&&(并且),||(或者).位逻辑运算通常是针对两个数而言,实行位操作;而条件逻辑运算是针对两个 条件表达式而言,实行条件操作.其实,位逻辑操作符一样可以实现条件操作,但是此时有一个重要的区别:用位操作符时,不管操作符两边的条件表达式成不成 立,它都要通通进行运算判断,而条件逻辑操作符不一样了,如果通过左侧的操作数就可以进行它们需要的判断,那么它就不会再计算右侧的操作数了,这种情况叫 短路.废话少说!且看下例.
eg1:
......
//omit some code
double value=0;
if(value!=0 && 1/value<1000){
System.out.println("The value is not too small.");
}
else{
System.out.println("The value is too small.");
}
......
//omit some code
运行结果:
The value is too small.
结果分析:
照理说应会出现除数为0的错误,但是我刚才说了,由于条件逻辑操作符是短路操作符,显然,value!=0不成立,立即就可作出判断应执行else后的语句,所以它就不再会运算判断1/value<1000了.如果不懂请再看一例:
eg2:
......
//omit some code
double int1=0,int2=1,int3=1;
if(int1!=0 & (int2=2)==1){}
System.out.println("int2="+int2);
if(int1!=0 && (int3=2)==1){}
System.out.println("int3="+int3);
......
//omit some code
运行结果:
int2=2.0
int3=1.0
结果分析:
我想不用我分析了,你应该懂了吧.
3.实例变量与类变量
可 以通过两种方法在类中存储数据───作为实例变量和类变量.实例变量是特定于对象的,如果你有两个对象(即一个类的两个实例),每一个对象中的实例变量独 立于另一个对象中的实例变量的;另一方面,两个对象的类变量均指向相同的数据,并因此面保存相同的值,换句话说,类变量被类中的所有对象共享.差点忘了, 它们在形式上的区别,类变量在声明时比实例变量多一个static.
eg:
class data
{
public int intdata=0;//显然,intdata在这儿是实例变量
}
public class exam
{
public static void main(String[] args)
{
data a,b;
a=new data();
b=new data();
a.intdata=1;
System.out.println("b.indata="+b.intdata);
}
}
运行结果:
b.intdata=0
结果分析:
可以看出,a.intdata的值虽然变了,但并没有影响b.intdata.但是如果在data类中声明intdata时,在其前面加上static就变成类变量了(即:public static int intdata=0;),则此时运行结果会变为:b.intdata=1这次a.intdata值的改变可把b.intdata影响了,事实上,对象a和b的类变量均指向相同的数据,所有值一样,这就是类变量的作用.
4.实例方法,类方法,构造器方法
我 们通常所说的方法系指实例方法,就像c语言中的函数一样,其具体方法我就不用说了,在这里我主要是用它来区分类方法和构造器方法.类方法与实例方法最大的 区别是:在形式上类方法多一个static,在用法上,不必创建对象就可直接调用类方法(而实例方法却一定要先创建对象,再通过对象调用).
eg:
class add
{
static int addem(int op1,int op2)
{
return op1+op2;
}
}
public class xxf
{
public static void main(String[] args)
{
System.out.println("addem(2,2)="+add.addem(2,2));
} //直接用类名作为对象调用类方法
}
注: 也可按通常的方法,即先创建对象,再调用方法,不过,这时static就无任何意义了.再说说构造器方法,它是用来初始化对象中的数据的一种方法,创建很 容易,只需在类中加上一个与这个类同名的方法,不需要在前面加任何访问说明符或者返回类型,另外,构造器也一样可以向方法一样传递参数.
eg:
class data
{
private String data1;//事先声明
data(String s)
{
data1=s; /*通过接收数据来初始化变量.(注:不能在构造器内
声明变量,事先在外就要声明.)*/
}
public String getdata()
{
return data1;
}
}
public class xxf
{
public static void main(String[] args)
{
System.out.println((new data("I love you")).getdata());/*通过传递参数调用构造器新建一
个对象,再通过对象调用方法得到数据*/
}
}
5.接口与类
类 是对一类特定对象的规格说明,我们可以类定义创建对象,通过创建对象来组合所有属于该类的组件,而接口不能这样做.而接口实质上就是一个常量和抽象方法的 集合,要使用一个接口,就需要在类中实现这个接口,然后作为类定义的一部分,编写接口中声明的每一个方法,接口中的方法永远是public, abstract,接口中的常量永远是public static和final,因此不需要为它们说明属性.因为在Java中不支持多重继承,但是,可以用接口来实现类似的功能,这是接口的重要作用之一.

eg:
interface anyone //定义一个接口
{
final double PI=3.1416;
void setNumber(int number);
int getNumber();
}
interface anyother //定义另一个接口
{
void setString(String str);
String getString();
}
class xxf implement anyone,anyother //定义一个类,并使用两个接口
{
int number;
String str;
public xxf(){}
void setNumber(int number)
{
this.number=number;
}
void setString(String str)
{
this.str=str;
}
void int getNumber(){}//可以为一个空实现.
void String getString(){}
}
//在类中必须实现接口中声明的所有方法.(当然也可不必,但是要用到适配器类或用抽象类)
--------------------------------------------------------------------------------

注:这最后一个例子我试验了一下,是错的。意会就好。


经典:Java及相关字符集编码问题研究
1. 概述
本文主要包括以下几个方面:编码基本知识,java,系统软件,url,工具软件等。
在下面的描述中,将以"中文"两个字为例,经查表可以知道其GB2312编码是"d6d0 cec4",Unicode编码为"4e2d 6587",UTF编码就是"e4b8ad e69687"。注意,这两个字没有iso8859-1编码,但可以用iso8859-1编码来"表示"。
2. 编码基本知识
最早的编码是iso8859-1,和ascii编码相似。但为了方便表示各种各样的语言,逐渐出现了很多标准编码,重要的有如下几个。
2.1. iso8859-1
属于单字节编码,最多能表示的字符范围是0-255,应用于英文系列。比如,字母a的编码为0x61=97。
很明显,iso8859-1编码表示的字符范围很窄,无法表示中文字符。但是,由于是单字节编码,和计算机最基础的表示单位一致,所以很多时候,仍旧使用 iso8859-1编码来表示。而且在很多协议上,默认使用该编码。比如,虽然"中文"两个字不存在iso8859-1编码,以gb2312编码为例,应 该是"d6d0 cec4"两个字符,使用iso8859-1编码的时候则将它拆开为4个字节来表示:"d6 d0 ce c4"(事实上,在进行存储的时候,也是以字节为单位处理的)。而如果是UTF编码,则是6个字节"e4 b8 ad e6 96 87"。很明显,这种表示方法还需要以另一种编码为基础。
2.2. GB2312/GBK
这就是汉子的国标码,专门用来表示汉字,是双字节编码,而英文字母和iso8859-1一致(兼容iso8859-1编码)。其中gbk编码能够用来同时表示繁体字和简体字,而gb2312只能表示简体字,gbk是兼容gb2312编码的。
2.3. unicode
这是最统一的编码,可以用来表示所有语言的字符,而且是定长双字节(也有四字节的)编码,包括英文字母在内。所以可以说它是不兼容iso8859-1编码 的,也不兼容任何编码。不过,相对于iso8859-1编码来说,uniocode编码只是在前面增加了一个0字节,比如字母a为"00 61"。
需要说明的是,定长编码便于计算机处理(注意GB2312/GBK不是定长编码),而unicode又可以用来表示所有字符,所以在很多软件内部是使用unicode编码来处理的,比如java。
2.4. UTF
考虑到unicode编码不兼容iso8859-1编码,而且容易占用更多的空间:因为对于英文字母,unicode也需要两个字节来表示。所以 unicode不便于传输和存储。因此而产生了utf编码,utf编码兼容iso8859-1编码,同时也可以用来表示所有语言的字符,不过,utf编码 是不定长编码,每一个字符的长度从1-6个字节不等。另外,utf编码自带简单的校验功能。一般来讲,英文字母都是用一个字节表示,而汉字使用三个字节。
注意,虽然说utf是为了使用更少的空间而使用的,但那只是相对于unicode编码来说,如果已经知道是汉字,则使用GB2312/GBK无疑是最节省 的。不过另一方面,值得说明的是,虽然utf编码对汉字使用3个字节,但即使对于汉字网页,utf编码也会比unicode编码节省,因为网页中包含了很 多的英文字符。
3. java对字符的处理
在java应用软件中,会有多处涉及到字符集编码,有些地方需要进行正确的设置,有些地方需要进行一定程度的处理。
3.1. getBytes(charset)
这是java字符串处理的一个标准函数,其作用是将字符串所表示的字符按照charset编码,并以字节方式表示。注意字符串在java内存中总是按 unicode编码存储的。比如"中文",正常情况下(即没有错误的时候)存储为"4e2d 6587",如果charset为"gbk",则被编码为"d6d0 cec4",然后返回字节"d6 d0 ce c4"。如果charset为"utf8"则最后是"e4 b8 ad e6 96 87"。如果是"iso8859-1",则由于无法编码,最后返回 "3f 3f"(两个问号)。
3.2. new String(charset)
这是java字符串处理的另一个标准函数,和上一个函数的作用相反,将字节数组按照charset编码进行组合识别,最后转换为unicode存储。参考 上述getBytes的例子,"gbk" 和"utf8"都可以得出正确的结果"4e2d 6587",但iso8859-1最后变成了"003f 003f"(两个问号)。
因为utf8可以用来表示/编码所有字符,所以new String( str.getBytes( "utf8" ), "utf8" ) === str,即完全可逆。
3.3. setCharacterEncoding()
该函数用来设置http请求或者相应的编码。
对于request,是指提交内容的编码,指定后可以通过getParameter()则直接获得正确的字符串,如果不指定,则默认使用iso8859- 1编码,需要进一步处理。参见下述"表单输入"。值得注意的是在执行setCharacterEncoding()之前,不能执行任何 getParameter()。java doc上说明:This method must be called prior to reading request parameters or reading input using getReader()。而且,该指定只对POST方法有效,对GET方法无效。分析原因,应该是在执行第一个getParameter()的时候, java将会按照编码分析所有的提交内容,而后续的getParameter()不再进行分析,所以setCharacterEncoding()无效。 而对于GET方法提交表单是,提交的内容在URL中,一开始就已经按照编码分析所有的提交内容,setCharacterEncoding()自然就无 效。
对于response,则是指定输出内容的编码,同时,该设置会传递给浏览器,告诉浏览器输出内容所采用的编码。
3.4. 处理过程
下面分析两个有代表性的例子,说明java对编码有关问题的处理方法。
3.4.1. 表单输入
User input *(gbk:d6d0 cec4) browser *(gbk:d6d0 cec4) web server iso8859-1(00d6 00d 000ce 00c4) class,需要在class中进行处理:getbytes("iso8859-1")为d6 d0 ce c4,new String("gbk")为d6d0 cec4,内存中以unicode编码则为4e2d 6587。
l 用户输入的编码方式和页面指定的编码有关,也和用户的操作系统有关,所以是不确定的,上例以gbk为例。
l 从browser到web server,可以在表单中指定提交内容时使用的字符集,否则会使用页面指定的编码。而如果在url中直接用?的方式输入参数,则其编码往往是操作系统本身的编码,因为这时和页面无关。上述仍旧以gbk编码为例。
l Web server接收到的是字节流,默认时(getParameter)会以iso8859-1编码处理之,结果是不正确的,所以需要进行处理。但如果预先设 置了编码(通过request. setCharacterEncoding ()),则能够直接获取到正确的结果。
l 在页面中指定编码是个好习惯,否则可能失去控制,无法指定正确的编码。
3.4.2. 文件编译
假设文件是gbk编码保存的,而编译有两种编码选择:gbk或者iso8859-1,前者是中文windows的默认编码,后者是linux的默认编码,当然也可以在编译时指定编码。
Jsp *(gbk:d6d0 cec4) java file *(gbk:d6d0 cec4) compiler read uincode(gbk: 4e2d 6587; iso8859-1: 00d6 00d 000ce 00c4) compiler write utf(gbk: e4b8ad e69687; iso8859-1: *) compiled file unicode(gbk: 4e2d 6587; iso8859-1: 00d6 00d 000ce 00c4) class。所以用gbk编码保存,而用iso8859-1编译的结果是不正确的。
class unicode(4e2d 6587) system.out / jsp.out gbk(d6d0 cec4) os console / browser。
l 文件可以以多种编码方式保存,中文windows下,默认为ansi/gbk。
l 编译器读取文件时,需要得到文件的编码,如果未指定,则使用系统默认编码。一般class文件,是以系统默认编码保存的,所以编译不会出问题,但对于 jsp文件,如果在中文windows下编辑保存,而部署在英文linux下运行/编译,则会出现问题。所以需要在jsp文件中用 pageEncoding指定编码。
l Java编译的时候会转换成统一的unicode编码处理,最后保存的时候再转换为utf编码。
l 当系统输出字符的时候,会按指定编码输出,对于中文windows下,System.out将使用gbk编码,而对于response(浏览器),则使用 jsp文件头指定的contentType,或者可以直接为response指定编码。同时,会告诉browser网页的编码。如果未指定,则会使用 iso8859-1编码。对于中文,应该为browser指定输出字符串的编码。
l browser显示网页的时候,首先使用response中指定的编码(jsp文件头指定的contentType最终也反映在response上),如果未指定,则会使用网页中meta项指定中的contentType。
3.5. 几处设置
对于web应用程序,和编码有关的设置或者函数如下。
3.5.1. jsp编译
指定文件的存储编码,很明显,该设置应该置于文件的开头。例如:<%@page pageEncoding="GBK"%>。另外,对于一般class文件,可以在编译的时候指定编码。
3.5.2. jsp输出
指定文件输出到browser是使用的编码,该设置也应该置于文件的开头。例如:<%@ page contentType="text/html; charset= GBK" %>。该设置和response.setCharacterEncoding("GBK")等效。
3.5.3. meta设置
指定网页使用的编码,该设置对静态网页尤其有作用。因为静态网页无法采用jsp的设置,而且也无法执行response.setCharacterEncoding()。例如:
如果同时采用了jsp输出和meta设置两种编码指定方式,则jsp指定的优先。因为jsp指定的直接体现在response中。
需要注意的是,apache有一个设置可以给无编码指定的网页指定编码,该指定等同于jsp的编码指定方式,所以会覆盖静态网页中的meta指定。所以有人建议关闭该设置。
3.5.4. form设置
当浏览器提交表单的时候,可以指定相应的编码。例如:。一般不必不使用该设置,浏览器会直接使用网页的编码。
4. 系统软件
下面讨论几个相关的系统软件。
4.1. mysql数据库
很明显,要支持多语言,应该将数据库的编码设置成utf或者unicode,而utf更适合与存储。但是,如果中文数据中包含的英文字母很少,其实unicode更为适合。
数据库的编码可以通过mysql的配置文件设置,例如default-character-set=utf8。还可以在数据库链接URL中设置,例如: useUnicode=true&characterEncoding=UTF-8。注意这两者应该保持一致,在新的sql版本里,在数据库链接 URL里可以不进行设置,但也不能是错误的设置。
4.2. apache
appache和编码有关的配置在httpd.conf中,例如AddDefaultCharset UTF-8。如前所述,该功能会将所有静态页面的编码设置为UTF-8,最好关闭该功能。
另外,apache还有单独的模块来处理网页响应头,其中也可能对编码进行设置。
4.3. linux默认编码
这里所说的linux默认编码,是指运行时的环境变量。两个重要的环境变量是LC_ALL和LANG,默认编码会影响到java URLEncode的行为,下面有描述。
建议都设置为"zh_CN.UTF-8"。
4.4. 其它
为了支持中文文件名,linux在加载磁盘时应该指定字符集,例如:mount /dev/hda5 /mnt/hda5/ -t ntfs -o iocharset=gb2312。
另外,如前所述,使用GET方法提交的信息不支持request.setCharacterEncoding(),但可以通过tomcat的配置文件指定字符集,在tomcat的server.xml文件中,形如:。这种方法将统一设置所有请求,而不能针对具体页面进行设置,也不一定和browser使用的编码相同,所以有时候并不是所期望的。
5. URL地址
URL地址中含有中文字符是很麻烦的,前面描述过使用GET方法提交表单的情况,使用GET方法时,参数就是包含在URL中。
5.1. URL编码
对于URL中的一些特殊字符,浏览器会自动进行编码。这些字符除了"/?&"等外,还包括unicode字符,比如汉子。这时的编码比较特殊。
IE有一个选项"总是使用UTF-8发送URL",当该选项有效时,IE将会对特殊字符进行UTF-8编码,同时进行URL编码。如果改选项无效,则使用 默认编码"GBK",并且不进行URL编码。但是,对于URL后面的参数,则总是不进行编码,相当于UTF-8选项无效。比如"中文.html?a=中文 ",当UTF-8选项有效时,将发送链接"%e4%b8%ad%e6%96%87.html?a=x4ex2dx65x87";而UTF-8选项无效时, 将发送链接"x4ex2dx65x87.html?a=x4ex2dx65x87"。注意后者前面的"中文"两个字只有4个字节,而前者却有18个字节, 这主要时URL编码的原因。
当web server(tomcat)接收到该链接时,将会进行URL解码,即去掉"%",同时按照ISO8859-1编码(上面已经描述,可以使用 URLEncoding来设置成其它编码)识别。上述例子的结果分别是"ue4ub8uadue6u96u87.html?a= u4eu2du65u87"和"u4eu2du65u87.html?a=u4eu2du65u87",注意前者前面的"中文"两个字恢复成了6个字符。 这里用"u",表示是unicode。
所以,由于客户端设置的不同,相同的链接,在服务器上得到了不同结果。这个问题不少人都遇到,却没有很好的解决办法。所以有的网站会建议用户尝试关闭UTF-8选项。不过,下面会描述一个更好的处理办法。
5.2. rewrite
熟悉的人都知道,apache有一个功能强大的rewrite模块,这里不描述其功能。需要说明的是该模块会自动将URL解码(去除%),即完成上述 web server(tomcat)的部分功能。有相关文档介绍说可以使用[NE]参数来关闭该功能,但我试验并未成功,可能是因为版本(我使用的是 apache 2.0.54)问题。另外,当参数中含有"?& "等符号的时候,该功能将导致系统得不到正常结果。
rewrite本身似乎完全是采用字节处理的方式,而不考虑字符串的编码,所以不会带来编码问题。
5.3. URLEncode.encode()
这是Java本身提供对的URL编码函数,完成的工作和上述UTF-8选项有效时浏览器所做的工作相似。值得说明的是,java已经不赞成不指定编码来使用该方法(deprecated)。应该在使用的时候增加编码指定。
当不指定编码的时候,该方法使用系统默认编码,这会导致软件运行结果得不确定。比如对于"中文",当系统默认编码为"gb2312"时,结果是"%4e% 2d%65%87",而默认编码为"UTF-8",结果却是"%e4%b8%ad%e6%96%87",后续程序将难以处理。另外,这儿说的系统默认编码 是由运行tomcat时的环境变量LC_ALL和LANG等决定的,曾经出现过tomcat重启后就出现乱码的问题,最后才郁闷的发现是因为修改修改了这 两个环境变量。
建议统一指定为"UTF-8"编码,可能需要修改相应的程序。
5.4. 一个解决方案
上面说起过,因为浏览器设置的不同,对于同一个链接,web server收到的是不同内容,而软件系统有无法知道这中间的区别,所以这一协议目前还存在缺陷。
针对具体问题,不应该侥幸认为所有客户的IE设置都是UTF-8有效的,也不应该粗暴的建议用户修改IE设置,要知道,用户不可能去记住每一个web server的设置。所以,接下来的解决办法就只能是让自己的程序多一点智能:根据内容来分析编码是否UTF-8。
比较幸运的是UTF-8编码相当有规律,所以可以通过分析传输过来的链接内容,来判断是否是正确的UTF-8字符,如果是,则以UTF-8处理之,如果不是,则使用客户默认编码(比如"GBK"),下面是一个判断是否UTF-8的例子,如果你了解相应规律,就容易理解。
public static boolean isValidUtf8(byte[] b,int aMaxCount){
int lLen=b.length,lCharCount=0;
for(int i=0;i
byte lByte=b[i++];//to fast operation, ++ now, ready for the following for(;;)
if(lByte>=0) continue;//>=0 is normal ascii
if(lByte<(byte)0xc0 || lByte>(byte)0xfd) return false;
int lCount=lByte>(byte)0xfc?5:lByte>(byte)0xf8?4
:lByte>(byte)0xf0?3:lByte>(byte)0xe0?2:1;
if(i+lCount>lLen) return false;
for(int j=0;j=(byte)0xc0) return false;
}
return true;
}
相应地,一个使用上述方法的例子如下:
public static String getUrlParam(String aStr,String aDefaultCharset)
throws UnsupportedEncodingException{
if(aStr==null) return null;
byte[] lBytes=aStr.getBytes("ISO-8859-1");
return new String(lBytes,StringUtil.isValidUtf8(lBytes)?"utf8":aDefaultCharset);
}
不过,该方法也存在缺陷,如下两方面:
l 没有包括对用户默认编码的识别,这可以根据请求信息的语言来判断,但不一定正确,因为我们有时候也会输入一些韩文,或者其他文字。
l 可能会错误判断UTF-8字符,一个例子是"学习"两个字,其GBK编码是" xd1xa7xcfxb0",如果使用上述isValidUtf8方法判断,将返回true。可以考虑使用更严格的判断方法,不过估计效果不大。
有一个例子可以证明google也遇到了上述问题,而且也采用了和上述相似的处理方法,比如,如果在地址栏中输入"http: //www.google.com/search?hl=zh-CN&newwindow=1&q=学习",google将无法正确识 别,而其他汉字一般能够正常识别。
最后,应该补充说明一下,如果不使用rewrite规则,或者通过表单提交数据,其实并不一定会遇到上述问题,因为这时可以在提交数据时指定希望的编码。另外,中文文件名确实会带来问题,应该谨慎使用。
6. 其它
下面描述一些和编码有关的其他问题。
6.1. SecureCRT
除了浏览器和控制台与编码有关外,一些客户端也很有关系。比如在使用SecureCRT连接linux时,应该让SecureCRT的显示编码(不同的session,可以有不同的编码设置)和linux的编码环境变量保持一致。否则看到的一些帮助信息,就可能是乱码。
另外,mysql有自己的编码设置,也应该保持和SecureCRT的显示编码一致。否则通过SecureCRT执行sql语句的时候,可能无法处理中文字符,查询结果也会出现乱码。
对于Utf-8文件,很多编辑器(比如记事本)会在文件开头增加三个不可见的标志字节,如果作为mysql的输入文件,则必须要去掉这三个字符。(用 linux的vi保存可以去掉这三个字符)。一个有趣的现象是,在中文windows下,创建一个新txt文件,用记事本打开,输入"连通"两个字,保 存,再打开,你会发现两个字没了,只留下一个小黑点。
6.2. 过滤器
如果需要统一设置编码,则通过filter进行设置是个不错的选择。在filter class中,可以统一为需要的请求或者回应设置编码。参加上述setCharacterEncoding()。这个类apache已经给出了可以直接使 用的例子SetCharacterEncodingFilter。
6.3. POST和GET
很明显,以POST提交信息时,URL有更好的可读性,而且可以方便的使用setCharacterEncoding()来处理字符集问题。但GET方法形成的URL能够更容易表达网页的实际内容,也能够用于收藏。
从统一的角度考虑问题,建议采用GET方法,这要求在程序中获得参数是进行特殊处理,而无法使用setCharacterEncoding()的便利,如 果不考虑rewrite,就不存在IE的UTF-8问题,可以考虑通过设置URIEncoding来方便获取URL中的参数。
6.4. 简繁体编码转换
GBK同时包含简体和繁体编码,也就是说同一个字,由于编码不同,在GBK编码下属于两个字。有时候,为了正确取得完整的结果,应该将繁体和简体进行统 一。可以考虑将UTF、GBK中的所有繁体字,转换为相应的简体字,BIG5编码的数据,也应该转化成相应的简体字。当然,仍旧以UTF编码存储。
例如,对于"语言 語言",用UTF表示为"xE8xAFxADxE8xA8x80 xE8xAAx9ExE8xA8x80",进行简繁体编码转换后应该是两个相同的 "xE8xAFxADxE8xA8x80>"。


JAVA中几个易混淆关键词的正确理解】

行为规范了你能对对象发出的请求。你的CLASS,也就是对象,也就是MM,你把她设计出来了,而且你很BT,只给她设计了礁鲂形 喊 ?)和MAKE爱与我()。那么她便不可能接受其它客户端class(某个帅哥?)的请求,如果在某个class里,你写成了MM.爱F4(),那么编译器就会出错。
你理所当然把MM的属性设成美,你不希望别人来改变这个事实,那么,你就要把这个属性定义为private,这样MM便不会在第二天醒来成为传说中的KL。这在第一章里标题为:被隐藏的实施细节。一个属性,有四种修饰符,public,private,protected,空(默认,friendly)。分别代表的意思是任何对象可以访问,本对象内部可以访问,本对象(class)的继承者可以访问,同一个包(package)的其它对象可以访问。
我们总是想尽可能地让自己的代码变的简洁,这便需要重复运用实现码。JAVA提供了这种方式,其途径有两种:组合和继承,假设有一个类为A,A有一个行为doSomething(),还有一个类B,不也想dosomething,那么你可以在B里产生一个方法doSomethingToo( A.doSomething(); )。这叫做组合。继承是另外一种方法,你可以直接用关键词extends,让B继承自A,那么你不用特殊额外表达,B在外界看来也是有doSomething的能力的。那么我们要问,我们什么时候要组合,什么时候用继承呢?BRUCE讲,当Bis a A的时候我们用继承。这不太好理解,我们再举个MM的例子。MM具备吃饭(eatYou( 进食;消化))的行为,MM衍生开来有好色的MM、爱打屁的MM等,但她们都是MM,也就是isa的关系,这个时候你要设计好色的MM的时候就用继承,用extends。而GG不是MM,但是GG is like a MM,因为GG也可以吃饭。这个时候我们就不用再去写eatYou()这个方法了,直接在GG这个类里写eatYou(MM.eatYou(); )那么,GG也具备了进食、消化的功能。其实我们要常常用到组合,在程序里,用继承的地方是比较少的。
在继承当中,有两个特殊行为需要我们关注:覆写(overriding)和重载(overloading)。现在你只需记住:如果baseclass和derive class的某个方法名称相同,引数相同,则为覆写(overriding),名称相同,引数相同,则为重载(overloading)。
面向对象一个显著的优点就是多形(多态)性。我本来是不想在这第一部分写代码的,但是似乎这个问题用语言表达不够直观,所以就写了个最简单的能说明多形性的问题。看代码先。。。
//Love.java
class MM{
public void toSeeGG(){
System.out.println("xxx");
}
}
class HaoseMM extends MM{
public void toSeeGG(){
System.out.println("诱惑GG!!!");
}
}
class BenfenMM extends MM{
public void toSeeGG(){
System.out.println("好羞涩哦....");
}
}
public class Love{
public static void loveGG(MM i){
i.toSeeGG();
}
public static void main(String[] args){
MM mm1 = new HaoseMM();
MM mm2 = new BenfenMM();
loveGG(mm1);
loveGG(mm2);
}
}
该代码运行的结果是:
诱惑GG!!!
好羞涩哦....
我们看到由MM衍生出来有好色MM(HaoseMM),本分MM(BenMM),MM们都可能会看到帅哥,但是好色MM和本分MM看帅哥的眼神是不一样的,如程序中定义。在爱(Love)这个类里,我们定义一个方法loveGG,我们给它传递一个参数,是基类(baseclass)MM,然后toSeeGG()。通过本文最开头的描诉,我们知道,HaoseMM和BenMM与MM的关系是is a的关系,所以我们在用到loveGG(mm1)和loveGG(mm2)时候编译器不会出错。我们看到,程序自动各自执行了haoseMM和BenfenMM的toSeeGG(),而不是打印出“xxx”。这就是多形性。之所以会如此神奇,是因为JAVA运行时环境提供了动态绑定技术。动态绑定会让你产生的MM在JAVA运行时环境里按照你的指示分别作出行为。OK,我们不需要知道动态绑定是怎么运做的,我们只要知道这是什么,因为我们还在第一章。上溯造型(upcasting)这个概念也在这里被提出来了。在loveGG(MMi)这个方法里,方法接受的是MM,可是loveGG也接受HaoseMM和BenfenMM,这个特性就叫上溯造型。
我们在上面的程序中看到了一句没有用的代码,就是在MM类里的System.out.println("xxx");。没有人关心基类MM是怎么看帅哥,因为它只是一个模版,所以我们干脆就不要这句代码,而且我们连{}也不要了,直接改写这个方法为publicabstract void toSeeGG();,那么这个方法称做抽象方法(abstract method)。基类MM对我们来说没有实现的必要,于是我们把classMM{...}改写为abstract class MM{...},那么这个类叫做抽象类(abstract class)。我们不禁要问,那么抽象类能不能含有非抽象的函数呢。答曰:可以。但是这在实际中没有什么用处,唯一用到的地方是:1,main()函数,用来测试你的类;2,考试中。那么我们还要问,子类可以不覆写父类中抽象方法行不行?答曰:如果子类也是abstract,那么可以,否则不行。
比抽象类做的更彻底的是接口(注意,这里的接口是JAVA中真正意义的接口,非上文一开始的接口,也既行为)。接口被设计出来的目的就是要让你继承的。等………,这是第一章,只让大家知道一些概念就行了,上面我们说的太多了。
BRUCE是个彻底的NN大师,我们接下来看到他把JAVA的低效率问题说的是那么的理所当然,以至于我们看完后情不自禁也要说:
恩,JAVA就应该这样做,让C++见鬼去吧。面向对象,于是所有东东都是对象,有对象便有对象的产生和毁灭。程序运行的时候,对象产生在内存中。内存分配有三种策略,分别是静态的,栈式的(stack),和堆式的(heap)。C++使用前两种策略,JAVA仅使用后者。两者有什么区别呢?喜欢寻根究底的朋友请参考本站JSP/JAVA分坛的“栈存储(stack)和堆存储(heap)的区别”,我们只要记住,后者在内存中的寻址要花更长的时间,因此JAVA的效率低。但是JAVA提供了根据heap特点产生的垃圾回收机制。垃圾回收机制完成这样的任务,当你的对象不在使用的时候它会自动察觉并消灭。你不用再担心发生内存泄露了。而这是每个C++程序员最头疼的事情。所以,你选择吧,是要安全还是要效率。

不错的题目和解答,说明了JAVA的多态 接口 动态加载类 等
为某研究所编写一个通用程序,用来计算每一种交通工具运行1000公里所需的时间,已知每种交通工具的参数都是3个整数A、B、C的表达式。现有两种工具:Car 和Plane,其中Car 的速度运算公式为:A*B/C,Plane 的速度运算公式为:A+B+C。需要编写三类:ComputeTime.java,Plane.java,Car007.java和接口Common.java,要求在未来如果增加第3种交通工具的时候,不必修改以前的任何程序,只需要编写新的交通工具的程序。其运行过程如下,从命令行输入ComputeTime的四个参数,第一个是交通工具的类型,第二、三、四个参数分别时整数A、B、C,举例如下:
  计算Plane的时间:"java ComputeTime Plane 20 30 40"
  计算Car007的时间:"java ComputeTime Car007 23 34 45"
  如果第3种交通工具为Ship,则只需要编写Ship.java,运行时输入:"java ComputeTime Ship 22 33 44"
  提示:充分利用接口的概念,接口对象充当参数。
  实例化一个对象的另外一种办法:Class.forName(str).newInstance();例如需要实例化一个Plane对象的话,则只要调用Class.forName("Plane").newInstance()便可。

解答代码:
访到classpath 路径下即可,请从下往上编译
目录结构
CalTime
--------|--------
| |
| |
vehicle ComputTime.java
|
---------
| |
| |
all Palne.java /Car.java
|
|
Common.java
代码如下:
1. ComputTime.java 请确保输入正确,其中没有捕捉NumberFromatException
import CalTime.vehicle.all.Common;
import java.lang.*;
public class ComputeTime {
public static void main(String args[]) {
System.out.println("交通工具: "+args[0]);
System.out.println(" 参数A: "+args[1]);
System.out.println(" 参数B: "+args[2]);
System.out.println(" 参数C: "+args[3]);
double A=Double.parseDouble(args[1]);
double B=Double.parseDouble(args[2]);
double C=Double.parseDouble(args[3]);

double v,t;
try {
Common d=(Common) Class.forName("CalTime.vehicle."+args[0]).newInstance();
v=d.runTimer(A,B,C);
t=1000/v;
System.out.println("平均速度: "+v+" km/h");
System.out.println("运行时间:"+t+" 小时");
} catch(Exception e) {
System.out.println("class not found");
}
}
}
2.Plane.java
package CalTime.vehicle;
import CalTime.vehicle.all.Common;
public class Plane implements Common {
public double runTimer(double a, double b, double c) {
return (a+ b + c);
}
}
3. Car.java
package CalTime.vehicle;
import CalTime.vehicle.all.Common;
public class Car implements Common {
public double runTimer(double a, double b, double c) {
return ( a*b/c );
}
}
4.Common.java
package CalTime.vehicle.all;
public interface Common {
double runTimer(double a, double b, double c);
}
演示了接口的经典使用方法。嗬嗬,只有意会,不可言传。 Thinking in Java 对此也做出了深刻的分析,可以查看下。
JAVA和C++区别

1.指针
JAVA语言让编程者无法找到指针来直接访问内存无指针,并且增添了自动的内存管理功能,从而有效地防止了c/c++语言中指针操作失误,如野指针所造成的系统崩溃。但也不是说JAVA没有指针,虚拟机内部还是使用了指针,只是外人不得使用而已。这有利于Java程序的安全。
2.多重继承
c++支持多重继承,这是c++的一个特征,它允许多父类派生一个类。尽管多重继承功能很强,但使用复杂,而且会引起许多麻烦,编译程序实现它也很不容易。Java不支持多重继承,但允许一个类继承多个接口(extends+implement),实现了c++多重继承的功能,又避免了c++中的多重继承实现方式带来的诸多不便。
3.数据类型及类
Java是完全面向对象的语言,所有函数和变量部必须是类的一部分。除了基本数据类型之外,其余的都作为类对象,包括数组。对象将数据和方法结合起来,把它们封装在类中,这样每个对象都可实现自己的特点和行为。而c++允许将函数和变量定义为全局的。此外,Java中取消了c/c++中的结构和联合,消除了不必要的麻烦。
4.自动内存管理
Java程序中所有的对象都是用new操作符建立在内存堆栈上,这个操作符类似于c++的new操作符。下面的语句由一个建立了一个类Read的对象,然后调用该对象的work方法:
Read r=new Read();
r.work();
语句Read r=new Read();在堆栈结构上建立了一个Read的实例。Java自动进行无用内存回收操作,不需要程序员进行删除。而c十十中必须由程序贝释放内存资源,增加了程序设计者的负扔。Java中当一个对象不被再用到时,无用内存回收器将给它加上标签以示删除。JAVA里无用内存回收程序是以线程方式在后台运行的,利用空闲时间工作。
5.操作符重载
Java不支持操作符重载。操作符重载被认为是c十十的突出特征,在Java中虽然类大体上可以实现这样的功能,但操作符重载的方便性仍然丢失了不少。Java语言不支持操作符重载是为了保持Java语言尽可能简单。
6.预处理功能
Java不支持预处理功能。c/c十十在编译过程中都有一个预编泽阶段,即众所周知的预处理器。预处理器为开发人员提供了方便,但增加丁编译的复杂性。JAVA虚拟机没有预处理器,但它提供的引入语句(import)与c十十预处理器的功能类似。
7. Java不支持缺省函数参数,而c十十支持
在c中,代码组织在函数中,函数可以访问程序的全局变量。c十十增加了类,提供了类算法,该算法是与类相连的函数,c十十类方法与Java类方法十分相似,然而,由于c十十仍然支持c,所以不能阻止c十十开发人员使用函数,结果函数和方法混合使用使得程序比较混乱。
Java没有函数,作为一个比c十十更纯的面向对象的语言,Java强迫开发人员把所有例行程序包括在类中,事实上,用方法实现例行程序可激励开发人员更好地组织编码。
8 字符串
c和c十十不支持字符串变量,在c和c十十程序中使用Null终止符代表字符串的结束,在Java中字符串是用类对象(strinR和stringBuffer)来实现的,这些类对象是Java语言的核心,用类对象实现字符串有以下几个优点:
(1)在整个系统中建立字符串和访问字符串元素的方法是一致的;
(2)J3阳字符串类是作为Java语言的一部分定义的,而不是作为外加的延伸部分;
(3)Java字符串执行运行时检空,可帮助排除一些运行时发生的错误;
(4)可对字符串用“十”进行连接操作。
9“goto语句
“可怕”的goto语句是c和c++的“遗物”,它是该语言技术上的合法部分,引用goto语句引起了程序结构的混乱,不易理解,goto语句子要用于无条件转移子程序和多结构分支技术。鉴于以广理由,Java不提供goto语句,它虽然指定goto作为关键字,但不支持它的使用,使程序简洁易读。
l0.类型转换
在c和c十十中有时出现数据类型的隐含转换,这就涉及了自动强制类型转换问题。例如,在c十十中可将一浮点值赋予整型变量,并去掉其尾数。Java不支持c十十中的自动强制类型转换,如果需要,必须由程序显式进行强制类型转换。
11.异常
JAVA中的异常机制用于捕获例外事件,增强系统容错能力
try{//可能产生例外的代码
}catch(exceptionType name){
//处理
}
其中exceptionType表示异常类型。而C++则没有如此方便的机制。

分享到:
评论

相关推荐

    Java精华积累每个初学者都应该搞懂的问题.txt

    ### Java精华积累每个初学者都应该搞懂的问题 在学习Java的过程中,有许多基础知识是每位初学者都需要掌握的。本文将从给定的文件标题、描述、标签以及部分内容中提炼出几个重要的知识点进行详细解读,帮助大家更好...

    Java精华积累每个初学者都应该搞懂的问题

    每个学Java的人都应该搞懂。当然,如果只是学Java玩玩就无所谓了。如果你认为自己已经超越初学者了,却不很懂这些问题,请将你自己重归初学者行列。

    每个JAVA初学者都应该搞懂的问题!

    ### 每个JAVA初学者都应该搞懂的问题详解 #### 问题一:我声明了什么! 在Java中,当我们执行 `String s = "HelloWorld!";` 这样的语句时,实际上是在做两件事情:一是声明了一个类型为String的引用变量`s`,二是...

    每个JAVA初学者都应该搞懂的问题.rar

    这个名为“每个JAVA初学者都应该搞懂的问题”的压缩包文件,显然是为那些刚开始学习Java的人准备的一份详细教程。让我们来探讨一下其中可能包含的知识点。 首先,我们看到一个名为“每个JAVA初学者都应该搞懂的问题...

    每个Java初学者都应该搞懂的六个问题

    【标题】: "每个Java初学者都应该搞懂的六个问题" 【描述】: 本文针对Java初学者,列出了六个核心问题,旨在帮助他们更好地理解和掌握Java编程的基础知识。 【标签】: "1" 【正文】: 对于Java初学者来说,理解和...

    【经典推荐】每个初学者都应该搞懂的问题!

    `,尽管`a`和`b`看起来都应该指向相同的内容,但`==`运算符将返回`false`,因为它们实际上分别指向内存中不同位置的两个独立的字符串对象。这里,`==`比较的是引用而非对象的实际内容。 为了比较对象的内容是否相等...

    java初学者应该搞懂的六个问题

    Java初学者在学习过程中会遇到很多关键概念,以下六个问题是每个Java学习者都应该掌握的。 1. **对象与引用的理解** - 在Java中,声明`String s = "Hello world!";`实际上是声明了一个名为`s`的引用变量,它指向了...

    每个学Java的人都应该搞懂

    ### 每个学Java的人都应该搞懂的关键概念 在Java编程的学习旅程中,有若干核心概念是每位学习者必须掌握的。本文将基于提供的部分信息深入解析这些关键知识点,帮助初学者更好地理解并运用Java。 #### Java中的...

    java 每个新手都要搞懂弄明白的

    Java 是一种广泛使用的编程语言,尤其适合初学者学习。在这个系列中,我们将深入探讨几个关键的概念,这些都是每个Java新手必须理解...对于每个初学者来说,深入掌握这些概念将有助于更好地理解和编写高效的Java代码。

    每个学Java的人都应该搞懂的问题

    ### 每个学Java的人都应该搞懂的问题 在学习Java的过程中,会遇到许多经典问题,这些问题不仅是初学者常犯的错误来源,也是深入理解Java语言特性的重要途径。本文将针对给定文件中的几个核心问题进行详细解析,帮助...

    一天搞懂深度學習

    李宏毅教授的教程也提供了深度学习的基本技术概览,这不仅帮助初学者入门,也为已经有一定基础的研究者提供了进阶的思路和方法。 综上所述,李宏毅教授的《一天搞懂深度学习》是一本适合不同层次读者的书籍。它不仅...

    一天搞懂深度学习

    "一天搞懂深度学习"这个主题涵盖了深度学习的基础概念、核心模型以及实际应用,旨在帮助初学者快速理解和掌握这一技术。 首先,我们来探讨深度学习的基本概念。深度学习的核心是神经网络,它由一系列的层(如输入层...

    台大李宏毅一天搞懂深度学习公开课课件(ppt)下

    《一天搞懂深度学习》是台湾大学李宏毅教授的知名公开课,这门课程以其深入浅出的讲解和丰富的实例深受学习者喜爱,是初学者踏入深度学习领域的理想选择。李宏毅教授的课程覆盖了深度学习的基础理论、重要模型以及...

Global site tag (gtag.js) - Google Analytics