java高级应用.docx
《java高级应用.docx》由会员分享，可在线阅读，更多相关《java高级应用.docx（29页珍藏版）》请在冰点文库上搜索。
java高级应用
几个笔试题：
第一题：
输出结果是？
1for（chari=9;i>=0;i--）{
2System.out.println（i）;
3}
第二题：
1System.out.println（（'A'<'a'?
9.9:
9））;
第三题：
1bytenum=23;
2System.out.println（~num）;
第四题：
1inti=0;
2inta=i+++i++;
3
4i=0;
5intb=i+++++i;
6System.out.println（"a="+a）;
7System.out.println（"b="+b）;
第五题：
下面这条语句产生几个对象？
1Strings=newString（"1"+"2"）；
结果：
2个对象
JAVA高级应用
（一）
一、JDK核心类库API
二、异常
三、集合
四、泛型
五、反射
---------------------------------------------------------------------
一、JDK核心类库API
知识点：
1java.lang.Object类
2Objec类中常用方法
3java.lang.String类
4StringBuffer类和StringBuider类
5java中日期表示方法
6包装类及其方法
7自动封箱与自动解箱
8大数据类：
BigInteger和BigDecimal
-----------------------------------------------------------------------------------------1、Object类
Object类是所有Java类的最终祖先，如果一个类在声明时没有包含extends关键字，那么这个类直接继承Object类。
所有java类都继承了Object类的方法。
Object类有一个默认的构造方法，在构造子类实例时，都会先调用这个默认的构造方法。
publicObject（）;//方法体为空
任意类均可当做Object类来看。
2、Object类共11个方法
其中，重要的方法有：
Objectclone（）；
Booleanequals（Objectobj）;
voidfinalize（）;
StringtoString（）;
1、protectedObjectclone（）
（1）protected表示在子类中可以调用。
什么意思？
1、是指在子类的方法中可调，即需要在子类中写一个方法，再调用，同时需要处理异常。
2、在继承关系的子类中，子类的本类对象，不能用其他类的对象。
（2）标记接口（Cloneable）：
没有任何方法的接口，标记一下有什么功能和特征。
new一个本类对象，可用本类对象调用，而不能用其他类对象调，若真要这样做，可用标记接口，但要覆盖Object类的clone（）方法，将其改为public。
即：
一个类要想可以被clone：
需要做两步：
第一步：
实现Cloneable接口
第二步：
覆盖父类的clone（）方法，并且将方法变为public的
（3）浅拷贝：
只拷贝当前对象空间本身，但是当前对象指向的对象没有拷贝（clone（））
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象，换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
Teacher对象
Studen对象
引用（teacher）
Age
拷贝Student对象
拷贝Studen对象
引用（teacher）
Age
（4）深拷贝：
不仅拷贝当前对象，还要拷贝当前对象指向的其他对象（重新写clone（）；使用对象序列号）
被复制的对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。
那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。
换言之，深复制把要复制的对象所引用的对象都复制了一遍。
完全拷贝：
Teacher对象
Studen对象
引用（teacher）
Age
拷贝得到的
Teacher对象
拷贝Studen对象
引用（teacher）
Age
2、equals（）
比较两个对象是否相等。
大多数情况下要覆盖该方法，只有当被比较两个引用变量指向同一个对象时，equals（）方法才返回True。
比较两个对象相等：
比较规则由业务定，但要遵守下面五大原则：
⏹反身性：
x.equals（x）返回真；
⏹对称性：
x.equals（y）返回真，当且仅当y.equals（x）返回真；
⏹传递性：
x.equals（y）返回真,y.equals（z）返回真,则x.equals（z）返回真；
⏹持久性：
对于x.equals（y）反复多次被调用时，返回的结果都是一样的。
前提是：
比较的两个元素没有发生改变
⏹非空性：
一个非空值和一个空值比较返回假，x.equals（null）返回假。
3、finalize（）
垃圾收集器认为该对象为垃圾时，会调用该对象的finalize（）方法
finalize（）方法一般情况完成的工作：
释放资源的代码（数据库的连接，打开了一个文件）
构造方法：
对象的创建
finalize（）方法：
对象的销毁
finalize（）方法不一定会100%被调用，什么时候做，做不做都是未知数。
Jvm关闭，垃圾收集器还没有启动收集垃圾的时候finalize（）方法不会被执行。
finalize（）方法被垃圾收集器自动调用，而垃圾收集器的执行实际是程序员不可控的，所以没有办法保证finalize（）方法一定在某个时刻执行。
4、toString（）：
返回一个对象的字符串描述
+号运算符如果有一边是字符串，不管另外一边是不是字符串（如果是个对象，会自动调用该对象的toString（）方法），都会做字符串拼接，返回一个字符串。
如果某类没有覆盖toString方法，直接输出该类的对象，输出的该对象的哈希码的十六进制形式字符串（day10.Student@C17164）。
如果没有覆盖hashCode方法，则是该对象在内存的地址值。
--------------------------------------------------------------------------------------------
三、String类和StringBuffer类
1字符串类的两种生成方式
（1）Strings=“hello”;
在对象池拿对象。
先检查对象池中有没有，没有在堆中创建，并把新对象给对象池，并且也把新对象给S。
（2）Strings=newString（“hello”）;
生成新对象，普通对象实例化方式。
（3）Strings2=“hello”,对象池中有值相同的对象，把该对象赋给s2即可。
字符串的对象池：
养对象的。
把一些字符串对象放到池子里养着，用的时候拿，不用了放回去。
其他的对象也可以用，提高效率，。
String对象和普通对象（Student）是有差别的，String有对象池
栈
hello
堆
持久层
字符串对象池
数组空间，每个元素是指向某个对象的引用
S
对象池是JVM管理的，我们没有办法干预其操作
JVM启动的时候会创建9个对象池：
八个基本类型的包装类对象池
2对象池的意义
避免频繁的创建销毁对象，使得相同内容的对象可以复用
3Strings=newString（“hello”）;创建了2个对象，内存空间发生了什么变化？
newString的时候要传一个参数”hello”，参数是字符串常量，这时候会在堆中创建对象，把引用放到对象池中，将创建的此对象作为参数构造s。
s和”hello”两个对象的内容是一样的
4字符串的值是不可改变的
任何时候改变字符串的值都会导致生成一个新的字符串对象，原来的字符串对象的值没有改变
因为字符串的值不可改变我们才可以使用字符串对象池
如果在程序中要频繁的修改字符串的值，就不推荐使用String类，而是使用类似于String类的StringBuffer和StringBuilder
5StringBuffer和StringBuilder是值可以改变的，这种改变不会创建新对象
StringBuffer是线程安全的，可以在多线程的环境进行访问。
每个去访问数据的方法都加锁了
StringBuilder是线程不安全的，不可以在多线程的环境下访问。
它的方法都没有加锁。
线程安全：
-------------------------------------------------------------------------------------------------------
四、JAVA中日期表示方法：
Date类和Calendar类
Date类：
最短命的类，没活过多久就给否定了。
构造方法：
获取机器当前的系统时间
已过时的构造方法不推荐使用，会有更好的方法。
不取消的目的是为了和以前的版本兼容。
此类在1.0版本推出没有多久，在1.1版本中该类的很多方法就已过时了。
最短命的类。
得到一个毫秒数，时区的区别，在时间历法中的映射
五Calendar抽象类，它的直接子类是GregorianCalendar（公立日历的实现）
1）绝对的时间值（毫秒数）--映射成--某个历法下的年月日时分秒毫秒
2）要想实现中国的农历就要写一个类，去实现Calendar类，完成映射。
add（int field,int amount）；field时间单位，amount要加的数值
时区的换算，日历系统的换算
应该用哪个，看需求
-------------------------------------------------------------------------------------------------------
六、包装类
一切皆对象
保留八种基本类型的目的：
效率
基本类型和对象无法转换，它们之间形成了一个屏障，为了打破这个屏障定义了包装类。
包装类是Object类型的，包装的数据是基本类型的。
java语言从形式上可以把所有的数据用对象表示
（一）包装类的作用：
1包装类为基本类型的数据提供了一种对象化的表达，建立起了基本类型和对象类型（引用类型）之间的桥梁
2包装类还提供了一组静态方法来完成基本类型，包装类类型和String类型之间的转化和解析操作
（二）包装类中的方法
1将radix进制的s字符串转换为有符号的十进制整数（使用第二个参数指定的基数，将字符串参数解析为有符号的整数。
）
-------------------------------------------------------------------
（三）自动封箱和自动解封
基本类型的值和包装类之间的相互转换
Integeri=5;
inta=i;
i+3;
语法是由编译器决定的，编译器在背后做了自动封箱和自动解封
自动封箱：
将Integeri=5;转换成Integeri=Integer.valueOf（5）;
自动解封：
将inta=i;转换成inta=i.intValue（）;
（四）Integer和String相似
对象池
值不可变
String
构造对象的两种方法：
Strings=newString（“hello”）;
Strings=“hello”;
经常修改字符串的值用
StringBuffer和StringBuilder
Integer
构造对象的两种方法：
Integeri=newInteger（5）;
Integeri=5;
经常修改Integer对象的值用
int
-128~127范围内的两个Integer对象是相等的。
Integer对象的对象池只保存-128~127之间的整数。
----------------------------------------------------------------------------------------------------
八、BigInteger：
整数和BigDecimal：
实数
1）BigInteger：
内部存储的实际上是个字符串，在其上定义了一套整数运算的方法。
超出了long类型表示的整数时用大数据类型
大数据类型的存储规则是：
十进制字符串
在字符串的存储结构上定义了一组运算方法
2）BigDecimal：
代表不可变的，任意精度的有符号十进制数，
实数不能参与位运算
二、异常
1、异常处理的目的
保证我们的程序更健壮！
2、异常类
（1）运行时异常：
未检查异常（不受检查异常）：
程序员没有仔细检查代码。
空指针异常，数组下标越界异常……。
编译器不检查上面的异常
（2）已检查异常（受检查异常）：
程序员已经很细心的检查代码，但是还会出现的异常。
例如，FileNotFoundException，ClassNotFoundException。
不是程序本身造成的异常，而是外部的客观环境造成的。
编译器会检查程序代码中可能出现的这类异常并强制要求程序员在代码中处理这类异常（或者抛给上层程序处理）。
3常见的RuntimeException：
Øjava.lang.ArithmeticException
Øjava.lang.NullPointerException
Øjava.lang.ArrayIndexoutofBoundsException
Øjava.lang.SecurityException
Øjava.lang.NegativeArraySizeException
Øjava.lang.ClassCastException
4、运行Java异常处理机制
（1）try----catch语句：
try：
有可能会出异常的代码。
Catch（可以有多个catch捕获多种不同的异常）：
异常处理的代码。
（2）finally语句（可选的）：
任何情况下都必须执行的代码、资源释放的代码。
（3）throws子句：
声明可能会出现的异常
根据异常声明，方法调用者了解到被调用方法可能抛出异常，从而采取相应的措施：
捕获并处理异常，或者声明继续抛出该异常。
（4）throw语句：
抛出异常
注：
【1】由throw语句抛出的对象必须是java.lang.Throwable类或者其子类的实例。
【2】throws和throw只有一个字母之差，却有着不同的用途，不要混淆哦！
【5】异常处理语句的语法法则
【6】异常流程的运行过程
【7】try中抛出异常，但是没有被catch捕获、所有已检查异常（B）都要被捕获、未检查异常（A）不被捕获（抛出A捕B）。
【8】有异常没人处理，jvm将会关闭此线程（单线程程序该程序终止；多线程程序，发生异常的线程终止，该程序的其他线程还会执行，程序并没有终止）。
【9】异常是线程级别的
5捕获多种异常时：
捕获顺序
（1）如果两种异常有继承关系，子范围的在前，父异常在后
子：
FileNotFoundException
父：
IOException
顺序不对的话，子异常的异常处理代码永远执行不到
（2）程序流程进入try中，finally中的代码肯定执行（两种情况除外：
一System.exit（0）；二执行完try后断电）
先做finally在return
6、Java虚拟机的方法调用栈
当Java虚拟机追溯到调用栈的底部的方法时，如果还没有找到处理该异常的代码块，则按一下步骤处理：
（1）调用异常对象的printStackTrace（）方法，打印来自方法调用栈的异常信息。
（2）如果该线程不是主线程，那么终止这个线程，其他线程继续正常运行。
如果是主线程（方法调用栈的底部为main（）方法），那么终止整个应用程序。
7、用户自定义异常
明确定义的异常类是已检查异常还是未检查异常。
（1）未检查异常类：
1publicclassABCExceptionextendsRuntimeException{
2//没有特殊需求可以不用写代码
3//但可以写构造方法
4//无参构造方法
5//有参构造方法
6}
（2）已检查异常类：
继承一个非未检查异常
补充：
1、异常是怎样产生，抛出，捕获的？
Jvm
main（）
m1（）
m2（）
m3（）{
访问文件抛出异常
}
方法调用
异常抛出
方法因某个原因导致异常，方法一般不会处理。
抛出异常的方法没有能力处理，报告给上一级。
异常的方法栈：
产生的异常方法调用的过程是异常栈轨迹（调试异常的重要信息），
（上图）栈轨迹
总结：
我抛出异常说明我能力范围内已经没有办法解决问题
2、throws和throw的区别：
（1）出现的位置不同。
Throws出现方法定义的第一行，在方法的形参之后；throw出现在方法体中
（2）后面跟的内容不同。
Throws跟若干个异常类型名；throw跟一个异常对象
（3）含义不同。
Throws该方法体中不处理某些类型的异常而是抛给上级方法去处理；Throw抛出某种异常类型的对象，报告一种异常
3、异常在怎样一个层次上处理比较合适：
谁负责谁处理，谁知情谁处理，谁导致的谁处理
4、从更高层次看异常：
异常是方法间的消息传递（原有的消息传递方法：
返回值和形参）
---------------------------------------------------------------------------------------
JAVA集合
JDK类库提供了Java集合，所有Java集合类都位于java.util包中。
java集合主要分为以下3种：
1）Set（集）：
无序、不重复。
它的有些实现类能对集合中的对象按特定方式排序。
2）List（列表）：
有序。
可以重复。
类似于数组。
3）Map（映射）：
集合中每个元素包含一对键对象和值对象。
没有重复的键对象，值对象可以重复。
它的有些实现类能对集合中的键对象排序。
一、Collection和Iterator接口
方法
描述
booleanadd（Objecto）
向集合中加入一个对象的引用
voidclear（）
删除集合中的所有对象，即不再持有这些对象的引用
booleancontains（Objecto）
判断在集合中使用持有特定对象的引用
booleanitreator（）
返回一个Iterator对象，可用它来遍历集合中的元素
Booleanremove（Objecto）
从集合中删除一个对象的引用
intsize（）
返回集合中元素的数据
Object[]toArray（）
返回一个数组，该数组包含集合中的所有元素
BooleanisEmpty（）
判断集合是否为空
注：
Set接口和List接口都继承了Collection接口，而Map接口没有继承Collection接口，因此，不能对Map对象调用以上方法。
（1）Collection接口的iterator（）和toArray（）方法都用于获得集合中的所有元素，前者返回一个Iterator对象，后者返回一个包含集合中所有元素的数组。
（2）Iterator接口隐藏底层集合的数据结构，向用户提供了遍历各种类型的集合的统一接口。
Iterator接口中声明了如下方法：
hasNext（）：
判断集合中的元素是否遍历完毕，如没有，就返回true。
next（）：
返回下一个元素。
remove（）：
从集合中删除上一个由next（）方法返回的元素。
二、Set（集）：
Set接口主要有HashSet和TreeSet实现类。
1）HashSet类按照哈希算法来存取集合中的对象，存取速度快。
HashSet类还有一个子类LinkedHashSet类，它不仅实现了哈希算法，而且实现了链表数据结构，链表能提高插入和删除元素的性能
2）TreeSet类实现了SortedSet接口，具有排序功能。
1、Set的一般用法
Set集合中存放的是对象的引用，并且没有重复的对象。
例如：
1Setset=newHashSet（）;
2Strings1=newString（"hello"）;
3Strings2=s1;
4Strings3=newString（"nihao"）;
5set.add（s1）;
6set.add（s2）;
7set.add（s3）;
8System.out.println（set.size（））;
以上程序的打印结果为2，实际上只向Set集合中加了2个对象。
那么当一个新对象加入到Set对象时，Set的add（）方法是如何判断这个对象是否已经存在于集合中的呢？
下面的代码演示了add（）方法的判断流程，newStr表示待插入的新对象。
1booleanisExists=false;
2Iteratorit=set.iterator（）;
3while（it.hasNext（））{
4StringoldStr=it.next（）;
5if（newStr.equals（oldStr））{
6isExists=true;
7break;
8}
9}
从上可知，Set采用了equals（）方法比较两个对象是否相等，而不是采用“==”比较运算符。
例如：
下列代码只增加了一个对象。
1Setset=newHashSet（）;
2Strings1=newString（"hello"）;
3Strings2=newString（"hello"）;
4set.add（s1）;
5set.add（s2）;
6System.out.println（set.size（））;//打印集合中的对象数目为：
1
2、HashSet类
HashSet类按照哈希算法来存取集合中的对象，具有很好的存取和查找性能。
当向集合加入一个对象时，HashSet会先调用对象的hashCode（）方法来获取哈希码，然后再根据这个哈希码进一步来计算出这个对象在集合中的存放的位置。
在Object类中，定义了hashCode（）和equals（）方法。
如obj1.equals（obj2）为true，则表明obj1和obj2实际上引用同一个对象，那么obj1和obj2的哈希码也肯定相同。
为了保证HashSet能正常工作，要求当2个对象用equals（）方法比较结果为true时，他们的哈希码也一定相同。
也就是说，如果
升级会员 