Java第八天 2007年5月8日
一、复习
接口
是个特殊的抽象类,属性:公开静态常量,方法:公开抽象方法
没有构造方法
接口之间可以多继承,一个类在继承另外一个类的同时,和可以实现多个接口
优点:
1、实现多继承,不会破坏类之间的单继承简单的树状关系。区分主类型和次要类型。
2、标准,解耦合工具
标准的使用者和标准的实现者通过借口隔离开,使得接口实现者的改变对使用者没有影响
接口的回调:
有了接口之后,先有接口使用者,后有接口的实现者,把接口实现者对象传给接口使用者,接口使用者通过接口,调用接口实现这中的方法
二、Object
java中所有的类的父类或直接或间接的或隐含的都是Object类。
java不允许循环继承,也就是互相继承是不可以的。
主要方法:
(1)finalize():对象被垃圾收集的时候最后调用的方法
不能把释放资源的代码写在其中,程序员不能控制调用时机
(2)equals(): 对象内容的比较
Object类中的boolean equals(Object o)方法是用来比较对象的内容是否相等,其返回值是boolean类型的值,相同为真,不同则为假。
实际上还是比较对象地址是否相同。String类覆盖了equals()方法,他比较是对象中的内容是否相同。
子类中也推荐覆盖Object类中继承的equals()方法,自己制定比较规则
自反性:s.equals(s) true
对称性:s1.equals(s2) true
s2.equals(s1) true
传递性:s1.equals(s2) true
s2.equals(s3) true
则 s1.equals(s3) true
覆盖equals()方法的步骤
boolean equals(Object o){
if(this==o) return true;//1,看看是不是一个对象
if(o==null) return true;//2,看看对象是不是空
if(!(o instanceof 本类类名)) return false;//看看是不是本类对象
......//根据本类设计。
}
(3)toString():返回对象的字符串表现形式
Object类中的toString()方法他返回的是类名加上他的地址的一个字符串。在子类中推荐覆盖toString()方法。
System.out.println(person);实际上打印的是person对象toString方法的返回值.
练习:
Employe类 属性:name,age,salary
把equals().toString()方法覆盖
三、封装类
JAVA为每一个简单数据类型提供了一个封装类,使每个简单数据类型可以被Object来装载。
除了int(Integer)和char(Character),其余类型首字母大写即成封装类类型名。
转换字符的方式:
int I=10;
String s=I+” ”;
String s1=String.valueOf(i);
Int I=10;
Interger I_class=new integer(I);
封装类.字符串.基本类型
int--------------------(Integer(x.toString))---------------->Integer
String -----------------(Integer.valueOf() )---------------->Integer
Integer-----------------(x.toString() )--------------------->String
int----------------------(100+””)------------------------->String
String------------------(Integer.parseInt() )--------------->int
Integer-----------------(Integer.intValue() )--------------->int
四、异常
帮错误发生的时候减少损失,提高容错性
1、常的分类
Throwable有两个子类:Error和Exception。
一个Error对象表示一个程序错误,指的是底层的、低级的、不可恢复的严重错误。此时程序一定会退出,因为已经失去了运行所必须的物理环境。
对于Error错误我们无法进行处理,因为我们是通过程序来应对错误,可是程序已经退出了。
我们可以处理的Throwable类中只有Exception类的对象(例外/异常)。
Throwable
|
------------------
| |
Error Exception
|
--------------
| |
RuntimeException 非Runtime异常
未检查异常 已检查异常
由于程序员疏忽造成的 不可避免的
可避免的 必须处理
可处理,可不处理
2、异常的产生和传递
throw new一个异常对象; ---表示抛出一个异常
throw new NullPointerException();
相当于return,函数返回上一级
传递:
沿着方法调用链反向传递!
当一个方法中出现异常,而没有作处理,则以异常对象为返回值返回调用处(逐级传递)
异常返回给虚拟机时,虚拟机终止退出,程序结束
3、异常的处理
(1)声明抛出
是方法声明的第五部分 throws+异常名字(多个异常用“,”分隔)
出现异常,不处理,抛给上一级处理
并且子类抛出异常的范围不能比父类抛出异常的范围更宽。
(2)捕获异常
try - catch
try - catch - finally
try - finally //不捕获异常,当异常发生,返回上一级之前,要运行finally中的代码
以上语句可以嵌套
返回类型 方法名(参数){
try{
可能出错语句
正常语句
}catch(异常类 e){ //某种异常的引用
对异常的处理
}
正常语句
}
捕获多个异常:
程序任何时刻只发生一个异常
可对产生的每个异常分别捕捉,也可由同一异常进行处理,前提是这个共用的异常应该是所有这些该被捕获的异常的父类,但是,对于非受查异常不成立
当try后面有多个语句块时,注意catch异常的顺序,子类必须放在父类的前面
finally关键字
无论异常是否发生,一定会执行的代码,可放在finally块内。
要点:没有异常产生时:正常执行try{}catch(){} —> 进入finally语句块 —> 方法中剩余代码
有异常产生时(捕找到) —> 进入catch处理 —> 进入finally语句块 —> 方法中剩余代码
有异常产生时(没捕找到)—> 进入finally语句块 —> 离开方法
一般写一些释放资源的代码
在try - catch 块中遇到System.exit(0);则不会执行finally中的代码
Throwable有一个message属性。在使用catch的时候可以调用:
Catch(IOException e){System.out.println(e.getMessage())}; //打印出来的是创建(throw new)异常对象的时候,给定的参数
Catch(IOException e){e.printStackTrace()}; //打印堆栈追踪信息
以上两条语句都是可以打印出错的过程信息。告诉我们出错类型所历经的过程,在调试的中非常有用。
开发中的两个道理:
①如何控制try的范围:根据操作的连动性和相关性,如果前面的程序代码块抛出的错误影响了后面程序 代码的运行,那么这个我们就说这两个程序代码存在关联,应该放在同一个try中。
②对已经查出来的例外,有throw(消极)和try catch(积极)两种处理方法。
对于throws把异常抛到try catch能够很好地处理异常的位置(即放在具备对异常进行处理的能力的位置 )。如果没有处理能力就继续上抛。
4、自定义异常
(1)继承Exception类
(2)构造方法:
不带参数的构造方法
带参数的构造方法:参数指出错误性质,super(message);把参数传递给父类构造异常
作业
(1)为Account类及其子类添加toString方法和equals方法
(2)(Exception)
为BAM添加几个异常类
BalanceNotEnoughException :用于取钱的时候余额不足的情况(包括账户余额超过透支额的情况)
RegisterException:用于开户异常的情况,例如密码两次输入不一致等情况
LoginException:用户登录异常的情况,例如id错误,密码错误
LoanException:贷款额不能为负数,如果用户试图将贷款额置为负数,则会抛出这个异常
以上四个异常类有一个共同的父类 BusinessException
并妥善的处理这些异常
Java第九天 2007年5月9日
一、复习
1、Object 所有的类直接或间接的父类
finalize:垃圾收集的时候调用
toString:返回对象的字符串形式
equals:判断两个对象内容是否相同
2、包装类
8种基本类型各自提供了对象形式
3、异常处理
提高容错性
异常的分类:Throwable
Error :错误,不可避免,不可处理
Exception:Runtime:未检查:可处理可不处理,首先应该努力避免异常(本可避免的)
非Runtime:已检查:必须要处理
异常对象的产生:throw 抛出异常,沿着方法调用链反向传递
异常处理:throws 消极,声明抛出
try-catch 捕获异常
try-catch-finally
try-finally
方法覆盖 :子类覆盖方法不能比父类被覆盖方法抛出更多的,范围更宽的异常
4、自定义异常
二、断言
在JDK1.4之后开始出现,是一个调试工具
其后跟的是布尔类型的表达式,如果表达式结果为真不影响程序运行。如果为假系统出现低级错误(Error),在屏幕上出现assert信息。
assert a%2==0;
编译器的默认设置:把断言语句忽律
javac -source 1.4 源文件名 //表示用1.4新特性编译
java -enableassert(-ea) 类名 //打开断言功能
assert a%2==0:"a必须是偶数"; //出现错误时的提示信息
assert只是用于调试。在产品编译完成后上线assert代码就被删除了。
三、内部类
内部类也就是定义在类内部的类。是编译时语法。
内部类的分类:
成员内部类、
局部内部类、
静态内部类、
匿名内部类(图形监听时要用到,要掌握)。
1、成员内部类
四个访问权限修饰符都可以修饰成员内部类。
内部类和外部类在编译时是不同的两个类,内部类对外部类没有任何依赖。
内部类是一种编译时语法,在编译时生成的各自的字节码文件(Outer.class和Outer$Inner.class),内部类和外部类没有关系。
内部类中可以访问外部类的私有成员。(与C++的友员相比,不破坏封装)
作为外部类的一个成员存在,与外部类的属性、方法并列。
内部类和外部类的实例变量可以共存。
在内部类中访问实例变量:this.属性
在内部类访问外部类的实例变量:外部类名.this.属性。
在外部类的外部访问内部类,使用out.inner.
成员内部类的特点:
(1)内部类作为外部类的成员,可以访问外部类的私有成员或属性。(即使将外部类声明为private,但是对于处于其内部的内部类还是可见的。)
(2)用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。
注意:内部类是一个编译时的概念,一旦编译成功,就会成为完全不同的两类。
对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。
(3)成员内部类不能含有静态成员。***
建立内部类对象时应注意:
在外部类的内部可以直接使用inner s=new inner();(因为外部类知道inner是哪个类,所以可以生成对象。)
而在外部类的外部,要生成(new)一个内部类对象,需要首先建立一个外部类对象(外部类可用),然后在生成一个内部类对象。内部类的类名是外部类类名.内部类类名。
Outer o=new Outer();
Outer.Inner in=o.new.Inner()。
2、静态内部类
(注意:前三种内部类与变量类似,所以可以对照参考变量)
静态内部类定义在类中,任何方法外,用static class定义。
静态内部类只能访问外部类的静态成员。
生成(new)一个静态内部类对象不需要外部类对象:这是静态内部类和成员内部类的区别。
静态内部类的对象可以直接生成:
Outer.Inner in=new Outer.Inner();
而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。
静态内部类不可用private来进行定义。
3、局部内部类
在方法中定义的内部类称为局部内部类。
与局部变量类似,在局部内部类前不加修饰符public和private,其范围为定义它的代码块。
注意:
局部内部类不仅可以访问外部类私有实例变量,还可以访问外部类的局部常量(也就是局部变量必须为final的)
在类外不可直接访问局部内部类(保证局部内部类对外是不可见的)。
在方法中才能调用其局部内部类。
通过内部类和接口达到一个强制的弱耦合,用局部内部类来实现接口,并在方法中返回接口类型,使局部内部类不可见,屏蔽实现类的可见性。
4、匿名内部类
匿名内部类是一种特殊的局部内部类,它是通过匿名类实现接口,并只创建一次。
匿名内部类的特点:
(1)一个类用于继承其他类或是实现接口,并不需要增加额外的方法,只是对继承方法的事先或是覆盖。
(2)只是为了获得一个对象实例,不许要知道其实际类型。
(3)类名没有意义,也就是不需要使用到。
注:一个匿名内部类一定是在new的后面,用其隐含实现一个接口或实现一个类,没有类名,根据多态,我们使用其父类名。
因其为局部内部类,那么局部内部类的所有限制都对其生效。
匿名内部类是唯一一种无构造方法类。
大部分匿名内部类是用于接口回调用的。
匿名内部类在编译的时候由系统自动起名Out$1.class。
如果一个对象编译时的类型是接口,那么其运行的类型为实现这个接口的类。
因匿名内部类无构造方法,所以其使用范围非常的有限。
当需要多个对象时使用局部内部类,因此局部内部类的应用相对比较多。匿名内部类中不能定义构造方法。
匿名内部类的写法:
interface A{
void ia();
}
class B{
public A bc(){
return new A(){ //匿名类实现了A接口
void ia(){……}
};
}
}
使用匿名内部类:
B b=new B();
A a=b.bc();
a.ia();
注意:当类与接口(或者是接口与接口)发生方法命名冲突的时候,此时必须使用内部类来实现。
用接口不能完全地实现多继承,用接口配合内部类才能实现真正的多继承。
对于两个类,拥有相同的方法:
class People
{
run();
}
interface Machine{
run();
}
此时有一个robot类:
class Robot extends People implement Machine.
名为run()的方法有2个,不可直接实现。
interface Machine{
void run();
}
class Person{
void run(){System.out.println("run");}
}
class Robot extends People{
class Heart implements Machine{
public void run(){
System.out.println("发动机运行");
}
}
public Machine getHeart(){
return new Heart();
}
public void run(){
System.out.println("机器人跑");
}
}
public class Test{
public static void main(String[] args){
Robot r=new Robot();
r.run();
r.getHeart().run();
}
}
练习:把前面石头剪刀布的游戏改写为:采用匿名内部类来实现接口,并获得对象去调用match方法
四、集合
集合(集合类的对象)是用来管理其他若干对象的。
集合中保存的是对象的引用,数组是最基本的集合
集合框架
1,接口
集合中用到的类,接口在java.util包中,在使用时注意将其引入import。
Collection 用来管理多个对象,集合中的每个元素都是对象。
1)List 一个List的实现类的对象在管理多个对象时会按顺序组织对象(即按照将对象放入的顺序存储)
List实现类的对象是有顺序的,List实现类对象中的内容是可重复的。(注意,顺序和排序的区别)
2)Set 一个Set的实现类表示一个数学概念上的集合,Set的实现类的对象中的元素是无顺序的,也就是不会按照输入顺序来存放,Set的实现类对象中的元素是不重复的。
3)SortedSet,他是Set的子接口,他的实现类会对集合中的元素进行排序。但是要指定排序规则,他会按排序规则进行排序。
Map,Map中没有对象,而是键值对,由Key,value组成的键值对
Key是没有顺序,不可重复的。
value是可以相同的,一个Key和一个value一一对应。
Map 接口(以下介绍其子接口)
SortedMap,这个接口的实现类同样可以实现,不过是对键值对中的Key进行排序,这个接口的实现类也是要指定排序规则的。
1> ArrayList是接近于功能的集合类,ArryList的实质就是一个会自动增长的数组,ArrayList是用封装的数组来实现的List接口的。
Collection的实现类对象的遍历方式是用迭代来实现的。
在使用迭代器时先要获得一个迭代器的对象,Iterator(迭代器接口)这是一个接口,迭代器是在集合类中实现的,也就是说,他是一个内部类(匿名内部类)实现的。
Iterator接口中定义的常用方法方法hasNext(),next()。
hasNext(),这个方法会使用一个游标,并通过判断游标指向的位置是否存放有对象。
next()方法也是Iterator接口中定义好的方法,这个方法会使游标指向下一个元素的位置,游标会跳过第一个元素,并返回其中的内容。
Collections 这是一个工具类,也是java.util包中的,这个类中的sort(list接口的实现类的对象)方法,其参数是一个集合类的对象,这个方法使用来对集合类的对象进行排序的。以后,我将以集合这个名字来称呼集合类的对象。,对于字符串对象内容的集合来说会按字典顺序排序(升序),对于数字内容的集合排序也会按照升序排序。
排序可分为两部分内容,一个是排序的规则,也就是按照什么来进行排序,并且排成什么样的顺序。
第二个就是排序的算法,他决定了排序的效率。
在对自定义的集合内容排序时,需要先定义那个类型的排序规则。
Comparable接口,这个接口中只定义了一个compareTo(Object o),方法的返回类型是整型,如果当前对象大于参数对象就返回正数,当前对象等于参数对象是就返回,当前对象小于参数对象时就返回负值,这样写就是升序排列,反之则是进行降序排列,在实现这个接口中的方法时,返回值定义方式,只有这两种。
根据指定类型的排序规则实现了Comparable接口,那么就可以对存有这个类型的集合进行整体排序。Comparable接口,也叫做可比较接口。这个接口在java.lang包下。只要实现了这个接口,就是可排序的。
接下来介绍另外一种对自定义类型对象的集合整体排序的方法,也就是实现比较器接口(Comparator),这个接口中定义了一个compare(Object o1,Object o2)方法来比较两个对象,这个方法的返回值定义和上面介绍的那个方法是一样。
注意:在API,帮助文档中以上两个方法的参数类型是T,这代表的模板类型,也就是集合中存放的内容的类型,在JDK1.4中其参数就是Object类型,模板类型的详细内容会在最后的JDK5.0新特性中讲到。
Comparator接口可以在匿名内部类中实现,Collections 中的sort(集合了的对象,比较器)方法,可以对自定义类型内容的集合进行整体排序。
2> LinkedList,它是List接口的实现类,其底层是用双向循环链表来实现的。
注意:ArrayList的查询效率比较高,增删动作的效率比较差,适用于查询比较频繁,增删动作较少的元素管理的集合。
LinkedList的查询效率低,但是增删效率很高。适用于增删动作的比较频繁,查询次数较少的元素管理集合。
ArrayList,LinkedList都是线程不安全的。
实现堆栈 1,数组(ArrayList,增删效率比较低,不适合)
2,LinkedList(实现堆栈的好方法)
3,java.util.Stack类,Stack是Vector的子类,Vector类是一个线程安全的(是一个重量级的类),并继承了Vector的方法,Verctor类(这个类也是List接口的实现类)和ArrayList的功能近乎相同。(不推荐使用Stack类来实现堆栈)。