java复习笔记期末考试复习 本文关键词：复习，期末考试，笔记，java
java复习笔记期末考试复习 本文简介：1.-JavaSEJavaEEJavaME指什么？JavaSE=JavaStandardEditionJavaEE=JavaEnterpriseEditionJavaME=JavaMobileEditionSE主要用于桌面程序,控制台开发(JFC)EE企业级开发(JSP,EJB)ME嵌入式开发(手机
java复习笔记期末考试复习 本文内容：
1.-Java
SE
Java
EE
Java
ME指什么？
Java
SE=Java
Standard
Edition
Java
EE=Java
Enterprise
Edition
Java
ME=Java
Mobile
Edition
SE主要用于桌面程序,控制台开发(JFC)
EE企业级开发(JSP,EJB)
ME嵌入式开发(手机,小家电)
2.java优点？
Java语言在安全性、平台无关性、支持多线程、内存
管理等许多方面具有卓越的优点。
3.基本数据类型的种类和长度
一个字节等于8位
4.强制转换
在Java中由于继承和向上转型，子类可以非常自然地转换成父类，但是父类转换成子类则需要强制转换。因为子类拥有比父类更多的属性、更强的功能，所以父类转换为子类需要强制。那么，是不是只要是父类转换为子类就会成功呢？其实不然，他们之间的强制类型转换是有条件的。
当我们用一个类型的构造器构造出一个对象时，这个对象的类型就已经确定的，也就说它的本质是不会再发生变化了。在Java中我们可以通过继承、向上转型的关系使用父类类型来引用它，这个时候我们是使用功能较弱的类型引用功能较强的对象，这是可行的。但是将功能较弱的类型强制转功能较强的对象时，就不一定可以行了。
基本数据类型之间的强制类型转换：
java规范强烈的不建议布尔型和整型或者浮点型的进行转化，很容易出错
5.关于static
static方法属于整个类，它不能操纵和处理属于某个对象的成
员变量，只能处理属于整个类的成员变量，即static方法只能
处理本类中的static变量或调用static方法。
6.调用权限
public是公共方法，在你的这个项目里面你所有的类都能访问这个方法，不加的话就是默认的default
这个是只能在你当前包里才能调用这个方法
1.
private:
Java语言中对访问权限限制的最窄的修饰符，一般称之为“私有的”。被其修饰的属性以及方法只能被该类的对象
访问，其子类不能访问，更不能允许跨包访问。
2.
default：即不加任何访问修饰符，通常称为“默认访问权限“或者“包访问权限”。该模式下，只允许在同一个包中进行访问。
3.
protected:
介于public
和
private
之间的一种访问修饰符，一般称之为“保护访问权限”。被其修饰的属性以及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。
4.
public：
Java语言中访问限制最宽的修饰符，一般称之为“公共的”。被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包访问
7.数据初始化
不管程序有没有显示的初始化，Java
虚拟机都会先自动给它初始化为默认值。
对于数组：
1、整数类型（byte、short、int、long）的基本类型变量的默认值为0。
2、单精度浮点型（float）的基本类型变量的默认值为0.0f。
3、双精度浮点型（double）的基本类型变量的默认值为0.0d。
4、字符型（char）的基本类型变量的默认为
“/u0000”。
5、布尔性的基本类型变量的默认值为
false。
6、引用类型的变量是默认值为
null。
7、数组引用类型的变量的默认值为
null。当数组变量的实例后，如果没有没有显示的为每个元素赋值，Java
就会把该数组的所有元素初始化为其相应类型的默认值。
注意：对于单个数据，如果不进行初始化不能对其进行操作，编译时报错
8.数组遍历的三种方法
1.for循环
2.for-each语句遍历，for(datatype
x:
arrayname)
3.迭代器Iterator遍历List
list
=
new
ArrayList();
Iterator
iterator
=
list.iterator();
while
(iterator.hasNext())
{
int
i
=
Integer.parseInt(iterator.next().toString());
System.out.println(i);
}
9.方法重载和重写
方法重载：所谓方法重载是指在一个类中，多个方法的方法名相同，但是参数列表不同。参数列表不同指的是参数个数、参数类型或者参数的顺序不同。
1.在使用重载时只能通过不同的参数列表，必须具有不同的参数列表。例如，不同的参类型，不同的参数个数，不同的参数顺序。
2.不能通过访问权限、返回类型、抛出的异常进行重载。
3.方法的异常类型和数目不会对重载造成影响。
4.可以有不同的返回类型，只要参数列表不同就可以了。
5.可以有不同的访问修饰符。
方法重写：当子类需要修改父类的一些方法进行扩展，增大功能，程序设计者常常把这样的一种操作方法称为重写，也叫称为覆写或覆盖。所谓方法的重写是指子类中的方法与父类中继承的方法有完全相同的返回值类型、方法名、参数个数以及参数类型。注意，重写方法时，可以增大父类中的方法权限，但是不能缩小父类的方法权限。当父类方法为private子类不能将其重写。
super关键字可以从子类访问父类中的内容，如果要访问被重写过的方法，使用“super.方法名(参数列表)”的形式调用。
10.异常处理
（1）Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。在Java
API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。Error和Exception的区别：Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。
（2）层次结构
（3）处理方法
Try-catch方法
try
块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
catch
块：用于处理try捕获到的异常。
finally
块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。
编写多重catch语句块注意顺序问题：先小后大，即先子类后父类。
throws方法声明抛出异常，只是抛出异常，并没有去处理它
（4）自定义异常
·
创建自定义异常类。
·
在方法中通过throw关键字抛出异常对象。
·
如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
·
在出现异常方法的调用者中捕获并处理异常。
class
MyException
extends
Exception
{
private
int
detail;
MyException(int
a){
detail
=
a;
}
public
String
toString(){
return
“MyException
[“+
detail
+
“]“;
}
}
public
class
TestMyException{
static
void
compute(int
a)
throws
MyException{
System.out.println(“Called
compute(“+
a
+
“)“);
if(a
>
10){
throw
new
MyException(a);
}
System.out.println(“Normal
exit!“);
}
public
static
void
main(String
[]
args){
try{
compute(1);
compute(20);
}catch(MyException
me){
System.out.println(“Caught
“+
me);
}
}
}
11.类的继承
继承的限制
1.java只能显示单继承，即一个类只能有一个父类
2.不允许多重继承（多重继承指的是一个类可以同时从多于一个的父类那里继承行为和特征，Java为了保证数据安全，它只允许单继承。子类只能继承一个父类，也就是说只能存在单一继承，但是却可以实现多个接口，间接实现了多重集成）
3.继承只能继承非私有的属性和方法
4.构造方法不能被继承
构造方法
如果子类需要继承父类的含参构造函数则需要使用super命令（如果父类包含多个含参构造函数则依据参数使用super命令）
如果父类建立了构造函数且都含有参数，则子类必须使用super命令
12.Object类
Object类存储在java.lang包中，是所有java类(Object类除外)的终极父类。当然，数组也继承了Object类。然而，接口是不继承Object类的。一般来说，我们所建立的类都会有如下方法：
·
protected
Object
clone()
·
boolean
equals(Object
obj)
·
protected
void
finalize()
·
Class
getClass()
·
int
hashCode()
·
void
notify()
·
void
notifyAll()
·
String
toString()
·
void
wait()
·
void
wait(long
timeout)
·
void
wait(long
timeout,int
nanos)
这是因为所有其他java类都继承了Object类。
13.抽象类
用关键字abstract修饰的类就是抽象类，它是所有子类的公共属性(数据)和行为方法的集合，抽象类没有具体对象，是处于组织概念的层次关系而存在的类。
用关键字abstract修饰的方法就是抽象方法(没有抽象变量)，抽象方法只有方法头，后面跟一个分号(；)，没有方法体，抽象方法的方法体可在其子类中根据子类的具体情况来实现，抽象方法只存在抽象类或接口中。
14.final类
声明为final的类不能是父类，即final不再派生子类，final可以用来修饰变量和方法。
final类是处在类的最底层的类，如果没必要再派生子类，通常用final关键字来修饰，表明它是最终类，被final修饰的类通常是有固定作用，完成一定标准功能的类，例如java库中的数学类Math等。
abstract和final不能同时使用，关键字abstract不能修饰实例变量，也不能与private、static、final等同时修饰一个成员方法，并且abstract类必须在abstract类中。关键字static修饰的方法只能修饰static成员变量，同时static修饰的成员变量和方法不能this引用.。
15.接口
接口（Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合。接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
如果一个类只由抽象方法和全局常量组成，那么这种情况下不会将其定义为一个抽象类。只会定义为一个接口，所以接口严格的来讲属于一个特殊的类，而这个类里面只有抽象方法和全局常量，就连构造方法也没有。
由于接口里面存在抽象方法，所以接口对象不能直接使用关键字new进行实例化。接口的使用原则如下：
（1）接口可以多继承，如interface
C
extends
A,B{…}//使用的是extends
（2）接口必须要有子类，但此时一个子类可以使用implements关键字实现多个接口；
（3）接口的子类（如果不是抽象类），那么必须要覆写接口中的全部抽象方法；
（4）接口的对象可以利用子类对象的向上转型进行实例化。
注意：，接口中的访问权限只有一种：public，即：定义接口方法和全局常量的时候就算没有写上public，那么最终的访问权限也是public，注意不是default。若子类中没用public修饰，则访问权限变严格了，给子类分配的是更低的访问权限。所以，在定义接口的时候强烈建议在抽象方法前加上public
。
15.塑型
塑型(type-casting)又称为类型转换方式。
将对象暂时当成更一般的对象来对待，并不改变其类型只能被塑型为父类类型。
当一个类对象被塑型为其父类后，它提供的方法会减少。
方法的查找——总是在变量声明时所属的类中进行查找。
16.
多态
多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）。
多态存在的三个必要条件
一、要有继承；
二、要有重写；
三、父类引用指向子类对象。
多态性有两种:
1）编译时多态性
对于多个同名方法,如果在编译时能够确定执行同名方法中的哪一个,则称为编译时多态性.
2）运行时多态性
如果在编译时不能确定,只能在运行时才能确定执行多个同名方法中的哪一个,则称为运行时多态性
具有继承关系的多态调用
在继承链中对象方法的调用存在一个优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。
17.
虚方法调用
Java虚方法你可以理解为java里所有被overriding的方法都是virtual的,所有重写的方法都是override的。
虚方法和抽象方法并不是同一个概念。
18.I/O流
Java中的流，可以从不同的角度进行分类。
按照数：输入流和输出流。按照处理数据单位不同可以分为：字节流和字符流。按照实现功能不同可以分为：节点流和处理流。
输出流：从程序输出到文件
输入流：从文件输入到程序
字节流：一次读入或读出是8位二进制。
字符流：一次读入或读出是16位二进制。
Jdk提供的流继承了四大类：InputStream(字节输入流)，OutputStream（字节输出流），Reader（字符输入流），Writer（字符输出流）。
常用的类和方法:
FileWriter
writer
=
new
FileWriter(fileName);
writer.close();
FileWriter
writer
=
new
FileWriter(filename,true);//追加重复内容
BufferWriter
out
=
new
BufferWriter(new
FileWriter(fileName));//缓冲器流，高效
BufferReader
in
=
new
BufferReader(new
FileWriter(fileName));
DataOutputStream
out
=
new
DataOutputStream
(new
FileOutputStream((fileName)));//写
DataInputStream
out
=
new
DataInputStream
(new
FileInputStream((fileName)));//读
还可以嵌套一个BufferedInputStream,提高效率
对象序列化
写对象：ObjectOutputStream
ofs1
=new
ObjectOutputStream(new
FileOutputStream(ofs));
从文件中读对象：ObjectInputStream
ifs1=new
ObjectInputStream(new
FileInputStream(ifs));
迭代遍历：Iterator
i
=
students.values().iterator();
while(i.hasNext())
{
ofs1.writeObject(i.next());
}
19.集合
Collection是最基本的集合接口List
接口和
Set
接口的父接口，一个Collection代表一组Object，即Collection的元素（Elements）。
Set接口同样是Collection接口的一个子接口，它表示数学意义上的集合概念。Set中不包含重复的元素，即Set中不存两个这样的元素e1和e2，使得e1.equals(e2)为true。
Map：key-value
的键值对，key
不允许重复，value
可以
1、严格来说
Map
并不是一个集合，而是两个集合之间
的映射关系。
2、这两个集合没每一条数据通过映射关系，我们可以看成是一条数据。即
Entry(key,value）。Map
可以看成是由多个
Entry
组成。
3、因为
Map
集合即没有实现于
Collection
接口，也没有实现
Iterable
接口，所以不能对
Map
集合进行
for-each
遍历。
20.
多线程
两种实现方式：
新建一个继承Thread类的线程类，其中有一个重写的run方法
新建一个实现Runnable接口的类，这个类在新线程中运行。New
Thread(t).start
线程中的数据共享：
只用一个Runnable对象为参数创建多个线程，new
Thread(对象名，“线程名”).start
线程的同步控制:
锁旗标synchronized(对象){代码段}，可以放在run方法里，也可以放在共享的资源类中作为一个方法public
synchronized
[type]
[name](){}
21.泛型
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
把类重新设计，使用泛型，强制转换的错误将被编译器捕获，而不是在运行时出错导致程序崩溃
public
class
Box{
private
T
t;
//
T
stands
for
“Type“public
void
add(Tt)
{
this.t=
t;
}
public
Tget()
{
return
t;
}
}
22.参数传递
Java中只存在值传递。
如果参数类型是原始类型，那么传过来的就是这个参数的一个副本，也就是这个原始参数的值，这个跟之前所谈的传值是一样的。如果在函数中改变了副本的值不会改变原始的值。
如果参数类型是引用类型，那么传过来的就是这个引用参数的副本，这个副本存放的是参数的地址。如果在函数中没有改变这个副本的地址，而是改变了地址中的值，那么在函数内的改变会影响到传入的参数。如果在函数中改变了副本的地址，如new一个，那么副本就指向了一个新的地址，此时传入的参数还是指向原来的地址，所以不会改变参数的值。
分以下四种情况进行讨论：
如果传原始类型，且不希望改变值，那么就直接传递即可
如果传原始类型，且希望改变值，那么必须将其变成引用类型，建一个类生成两个对象使其成员变量等于原始数据，操作这两个对象即可，过程变得比较繁杂。
如果传引用类型，且不希望改变其值，则必须new一个新的对象，用该对象的引用进行操作；
如果传引用类型，且希望改变其值，直接传入对象的引用即可。
23.关于父子类构造函数
父类的构造函数不能被子类继承、重写,使用super调用父类构造器的语句必须是子类构造器的第一条语句.如果子类构造器没有显式地调用父类的构造器,则将自动调用父类的默认（没有参数）的构造器.如果父类没有不带参数的构造器,并且在子类的构造器中又没有显式地调用父类的构造器,则java编译器将报告错误
对于父类的私有化属性，在子类中只能通过调用父类的构造器对其进行赋值，不能通过父类的对象调用父类的私有化属性。这就是为什么要用super对父类私有化属性进行赋值。