1. Java 虚拟机发现类a;
1) 找到a.class则continue;
2) 否则 寻a.java 编译为a.class;
3) 当a.java被更新,a.java也会自动重新编译为新版本a.class.
(类似于自行执行 linux make功能)
2. Java定义方法与C++的区别:
1) C++一般在类的外部定义方法;
2) Void E::ra(double a)
3) {
4) ...
5) }
6) Calss E
7) {…
8) Int a()
9) {return a;}/定义在C++类内部方法自动成为内联方法。
10) }
JAVA必须在类内部定义方法,但并不代表该方法为内联方法;内联与否取决于JVM.
//C++内联方法与外部方法的区别?
3. 封装:降低耦合。(只域内可修改)(类内部修改、访问);同时给类间通信带来麻烦;为了不破坏封装性:返回可变参数时,返回克隆得出对象副本(存放在另外的位置)。return(Date)a.clone();(返回可变数据域的引用)。
4. 私有方法:无法被外部类访问;公有方法:外部类可以访问;
5. Final实例域;对象构建后不会再被修改,即没有setName方法;
6. 引用拷贝,实际为值传递.
7. 重载:
Swap(); Swap(int a,intb); 重载解析即特异性方法匹配。Method signature(方法名以及参数类型)。
8.构造器调用另一个构造器:
Public Employee(double s)
//This隐式参数。
{
This(“Employee #”+nextid,s);
nextid++;
}
当new Employee(X)时,外层调用内层构造器,this关键字使得公共构造器代码只被编写一次。而C++构造器不得相互调用。必须抽取公共初始化代码编写独立初始化方法。
8. C++有显示的析构函数,回收分配给对象的存储空间。Java自动垃圾回收。Fanalize()方法在垃圾回收器清除对象前被调用。(具体何时尚不清楚,因此不用于回收短缺资源)。
9. 某个资源在使用完后需要立刻释放,则人工管理(dispose或close).
10. System.runFinalizersOnExit(true)确保java关闭前调用(不安全)。代之以Runtime.addShutdownHook添加的“关闭钩”。
11. 要使用两个Datel类,用完整包名区分。 ~.Util.date();~.sql.date();
12. 静态对象、静态冗长常量导入、静态类型导入。
13. 设计类:私有,初始化,基本数据类型不可过多,并非所有域需要独立域访问器和域更改器,标准格式定义类(实例方法,静态方法,实例域,静态域),分解职责过多的类,类名和方法名体现类的职责。
14. Java all extends is public ,没有C++的私有继承和保护继承。Extends表示,正在构造的新类派生 于一个已存在的类。
15. doublebaseSalary=super.methods();(子类访问父类)。C++使用超类名+::操作符的方式father class::methods()。Super在构造器中的应用:Super(n,s);表示调用基类含有相应参数构造器的简写。该语句必须为子类构造器的第一条语句。无显示情况下默认使用无餐构造器。若没有显示调用,且不含无参构造器,则报错。
16. super与this.(超类方法和超类构造器,隐式参数和该类其他构造器)。
17. 一个对象可以引用多种实际类型(多态)。运行时自动选择调用适当方法(动态绑定)。
Dynamic bindingis the default way to deal with; final接触虚拟特性。
18. java不支持多继承,多继承功能的实现方式需要借助接口。
19. 对象变量的多态性:一个子类的对象可以赋给超类对象。
20. Final类阻止继承,即阻止定义该超类的子类。
类中final方法阻止子类覆盖。Final类中的所有方法自动生成为final方法,但域不随着类被声明为final而成为final类型。(必须经过final定义域为构造对象后,才具有不可改变的其值特性)。
21. C++:虚基类,可以定义一个不允许被派生的类。
22. 将一个子类的引用赋给一个超类变量,编译允许;但将一个超类的引用赋给一个子类变量,必须经过类型转换,才能通过运行检察。(1.只能在继承层次内进行类型转换2.在将超类转换成子类之前,应该使用instanceof进行检查)。
23. 抽象类(本质:不可被实例化(不创建对象)),抽象方法(占位,具体实现在子类中)(含有抽象方法的类必须被声明为抽象类);但抽象类也可以包含非抽象方法或者不含有抽象方法。将大家都有的域或者方法(不论抽象与否)放置在抽象超类中。
可以通过定义一个抽象类的对象变量来引用抽象子类的对象。例如:Person p=new Student(“Bob”,15);
C++:尾部用=0标记的抽象方法,称为纯虚函数。--à抽象类;没有提供用于表示抽象类的特殊关键字。
Class animal
{
Public:
Virtualstring getdes()=0;
…
};
抽象类和抽象方法
abstract class dog
private String kinds;
{
Public dog(string n)
{
kinds=n;
}
Public abstract String getdes();
Public getkinds()
{
Return kinds;
}
}
子类实现抽象类的方法(抽象类形象化(扩展为具体子类));//子类可以为抽象的,也可以为非抽象的。
Class student extends person
{
Private String voice;
Public blackdogs(String n,String p)
{
Super(n);
Voice=p;
}
Public String getdes()
{
Return “a dog can sing.”;
}
}
24.4个访问控制
Default 修饰符(无)(包)、私(本类内)、公(all class)、 保(本包内和包外所有子类);
25.Object 所有类的超类。C++没有根类,但每个指针都可以转换为void.
26.clone()创建某对象副本。
27.泛型数组列表:ArrayList<a> aa=new ArrayList<aa>();创建a对象的动态数组列表aa。
aa.add(new a(对象参数));替代老版本的Vector类;可以传递初始容量:ArrayList<a> aa=newArrayList<aa>(100);动态数组列表和静态数组的区别(潜力(不确定性)与空间(定义则分配))。与C++Vector区别:java没有运算符重载。必须调用显示方法而不是[]运算符。C++向量是值拷贝,(a=b);a和b是两个向量,(构造b,从a-à元素拷贝,java中:让a和b引用同一个数组列表).aa.add()添加未存在(顺序);aa.set()替换已存在;
赋值a.set(i,10);获取数组中列表元素a b=aa.get(i);for(a e:aa){doothers}
28.Arraylist<aa>=newArraylist<aa>(100);
While(int i<100)
{
x=…;
aa.add(x);
}
aa[] a=new aa[list.size()];
list.toArray(a);
29.插入和删除:链表。
30.对象打包(Integer,Long,Fioat,Double,Short,Byte,Charcter,Void,Boolean)前六个类派生于公共超类Number;Arraylist<Integer>list=new Arraylist<Integer>();jdk5.0版本以后,aa.add(3)自动变换为aa.add(newInteger(3));
31.反射:反射库(工具集),动态操纵java代码。
反射类检查类的结构;
e.getClass().newInstance();创建与类具有相同类型的实例。
反射分析类;
Java.lang.reflect 包含的类 getModifiers()方法,用不同的位开关描述public,static等修饰符的使用。 | Field(描述域) | getType,返回所属类型对象 | 类支持的public域 | getDeclare(_fields,_Methods,_Constructors)方法返回类声明的全部域,方法,构造器组成的数组,包括私有和受保护成员,但不包括超类的成员。 |
Method(描述方法) | 含有报告参数类型的方法,可以报告返回类型。 | 方法 |
| |
Constructor(描述构造器) |
| 构造器数组,包括超类公有成员。 |
|
32.继承设计注意点:
1)公共域,操作放置在超类。
2)不使用protected域。
3)继承(dog与各种颜色狗的关系)。
4)继承的方法都有意义。
5)覆盖子类方法时,不改变预期行为。
6)使用多态而非类型信息。
7)避免过多使用反射。
33.接口是一组对类的需求描述,这些类要遵从接口描述的统一格式进行定义。
接口只是描述类的功能,而不实现,具体是由继承接口的类来实现(1:n);
34.实现接口:
1)将类声明为实现给定的接口;
2)对接口中的所有方法进行定义;(除非实现接口的类的是抽象类)。
Implements 关键字: A,B;
35.接口特性:
1)不是类,不可用new实例化。
2)接口变量必须引用实现了接口的类变量。(可以用instance检查一个对象是否实现了某个特定的借口)。
3)If(anObject instanceof Comparable){…//}。
4)接口可以扩展。
5)接口中不能包含实例域或静态方法,但可以包含常量。
Public intface moveable{void move(doublex,double y)}
Publicinterface dog extends moveable{ double fly(); double speed=1800;}(接口方法应标记为public,域自动标记为public static final);一般省略该关键字。
36.接口与抽象类:
抽象类:每个类只能扩展于一个类。
每个类可以实现多个接口。
37.对象克隆:浅拷贝(default)(没有克隆包含在对象中的内部对象,比如Date类的对象是可变的,此时需要重新定义clone方法,实现克隆子对象的深拷贝);(即使浅拷贝满足要求,也需要实现Cloneable接口,将clone由protected重定义为public,并调用super.clone().)
Class dog inplements Cloneable
{
Public dog clone() 抛出不支持克隆异常
{
return super.clone();
}
} //浅
class time implements cloneable
{
Public Object clone() 抛出不支持克隆异常
time cloned=(time)super.clone();
cloned.mytime=(Date) mytime.clone();
return cloned;
}
捕获异常方式?
Public time clone(){
Try{
Return super.Clone();
}
Catch(CloneNotSupportedException e){returnnull;}
}
38.Java对应C++函数指针——Method对象。(使用困难,效率低)故考虑接口对应指针。
39.内部类:定义在另一个类中的类。
Inner class方法可以访问该类定义所在的作用域中的数据,包括私有数据。
内部类对同一个包中的其他类来说,是隐藏的。(只有内部类可以是私有类,而常规类只能具有包的可见性,或公有的可见性)。
定义回调函数且不想编写大量代码时,使用匿名内部类比较快捷。
回调:指定某事件发生时执行某个动作。
40.C++嵌套类:嵌套是类间关系,非对象之间。A 对象不包含B或C的子对象。
子对象即对象成员 class B{privateA a;};,
Class A{
Public:
Class B
{ };
Private: //C类位于A类的私有部分,即使数据域公有,但C类对其他代码不可见。
Class c{ //Java的static 内部类没有(内部类对象的隐式引用实例化该内部对象的外围类对象)的附加指针。B b外围A a;可以访问外围类对象的全部状态。
};
};
外围类构造方法构造内部类对象。
41.内部可以访问他自身的数据域+创建它的外围对象的数据域。
Inner class对象指向创建它的外围类对象。—— here class
即inner class含有对外围class对象的引用(类似outer指针)。
42.If(outer.this.op);{
}//内部类对象的外围类引用被设置为创建内部类对象方法中的this引用。
.ActionListener listener=this.new Time();在外围构造内部对象时更加明确。
Outerclass.innercalss listener=jabberer.new Time();//在外围类的作用域之外引用内部类。
43.解释 Outclass&Innerclass.calss。
44.和两个常规类 传递对象指针的区别:
Class A{
Public void start() {
ActionLIstener listener=new Time(this);
Timer t=new Timer(n,listener)
t.satrt();
}
}
Class Time implements ActionListener
{
Private A aA;
Public Time(A a){
aA=a;
}
}
//内部类:
class clock
{
privateint n;
privateString s;
public clock(int n,String s){
this.n=n;
this.s=s;
}
public String gets(){
returns;
}
public void start(){
ActionListenerlistener=this.new Time(); //明确在外围构造内部对象;
Timert=new Timer(n,listener);
t.start();
}
private class Time implementsActionListener{
@Override
publicvoid actionPerformed(ActionEvent e) {
Date now=new Date();
System.out.println("time"+now);
}
}
So,常规类(1to other)传递this指针,不能拥有访问外围类私有数据的权限。内部类访问特权。
45.局部内部类:内部类在外围方法中创建其对象出现时,可直接在外围方法内定义局部类。
Public void start(){
Class A implements ActionListener
{
Public void actionPerformed(ActionEvent e)
{
Date now=new Date();
System.out.println(“time”+now);
}
}
ActionListener listener=new A();
Timer t=new Timer(1000,listener);
t.start();
}。
局部类不可用访问说明符声明,作用域限定于声明该局部类的块中。对块之外隐藏。可以访问外围类的域以及声明为final的局部变量。
46.匿名内部类:在外围方法只创建内部类的一个对象,不必命名。
Public void start(int n,final Strig s)
{
ActionListener listener=new ActionListener()
{
Public void actionPerformed(ActionEventevent)
{
Datenow=new Date();
System.out.println(“time”+now);
}
}; //创建一个实现ActionListener接口的类的新对象,{ }内为实现方法。
Timer T=new Timer(1000,listener);
t.start();
}
NewSuperType(构造参数)
{
Innerclass
};
内部类实现superType接口;或者扩展superType类;
//匿名内部类没有类名和构造器,将构造参数传给超类构造器。
//内部类实现接口时,不能有任何构造参数。还要提供括号。
Animal dog=new Animal(“jiwawa”);|| Animaldog=new Animal(“jiwawa”) {methods;data};
(实际上逻辑上应该为Animal dog=newclass extends Animal(“zangao”){…….};)//代表一句结束。
46.静态内部类
内部类声明为static,取消产生的引用。//只是为了隐藏,不需要引用外围类对象。
内部类对象在静态方法中构造时,必须使用静态内部类。
声明在接口中的内部类自动成为static和public。
47.代理:(proxy)在运行时创建一个实现了一组给定接口的新类,用于在编译时无法确定实现哪个接口时才有必要使用。
48.Applet 生命周期:init()初始化;
Start();于调用init()后自动执行;//重新激活线程;
Stop();在用户离开包含applet的页面时自动调用;//撤销线程;
Destroy();正常关闭浏览器才调用。(ps覆盖destory方法可以关闭applet在系统中占用的资源)。
49.存档java类的文件为JAR文件。
50.java异常层次结构:
异常继承于Throwable;
派生于RuntimeExpection包含:
1) 错误类型转换
2) 数组越界
3) 访问空指针
非派生于RuntimeExpection包含:
1) 根据给定字符串查找Class对象,但该串表示的class不存在。
2) 在文件尾部读取数据;
3) 打开错误格式URL。
继承于ioException:DirectoryNotFoundException; EndOfStreamException; FileNotFOundException; FileLoadException; PathTooLongException;
派生于RuntimeExpection类或Error类的所有异常称为“未检查异常;”其他为“已检查异常”。
51.C++两个基本异常类:runtime_error和logic_error类相当于Java中的RuntimeException,表示逻辑错误;runtime_error类由于不可预测的原因所引发的异常的基类,相当于非RuntimeException的异常。
52.抛出异常的情况:
1)调用一个抛出已检查异常的方法。(FileInputStream构造器);
2)程序运行中出现错误,并利用throw语句抛出一个已检查异常。
3)程序出现错误。
4)java虚拟机和运行库内部异常。
一个方法必须声明所有可能抛出的已检查异常,否则编译器提示错误信息;未检查异常(不可控、避免发生)。
子类方法抛出已检查异常范围不超过父类声明的异常范围。
C++throws在运行时执行。C++函数抛出的异常不在throw列表中unexpected函数,终止程序。没有throws说明的函数也可以抛出任何异常,java未经说明的方法不抛出任何已检查异常。Java只能抛出Throwable子类的对象,C++可以抛出任何类型的值。
53.已存在异常类:
1)找到一个合适的异常类;
2)创建这个类的一个对象;
3)将对象抛出; throw new EOFExpection();||EOFExpection() e=newEOFExpection();throw e;
54.定义异常类抛出自定义异常类型。
55.捕获异常:
If try{
//任意一句代码出抛出 catch中的指定的异常类,跳过try其余,执行catch子句中的处理器、、代码.
}
catch { //handle }; try块中可捕获多个异常,e.getMessage();得到详细信;(…).getName();
得到异常对象实际类型。
若抛出catch子句未声明的异常,那么该方法立刻退出。
捕获可以处理异常进行处理,传递不知如何处理的异常。
56.改变、包装已检查异常为运行时异常:catch子句中抛出异常
原始异常导出新异常:
Try
{
数据库连接
}
Catch(SQLExpectione)
{
Throwablese=new ServleException(“DB erroe”);
Se.setCause(e);
Throwse;
}
//抛出子异常se,不丢失e:即se包装e;
57.finally子句:
断开连接、释放资源;
Finally
{
g.dispose();
}
独立使用try/catch和try/finally语句块;
InputStream in=new FileInputSream(f);
Try{
Try{
//might 异常 return 1;
}
Finally{
In.close();
return 0; //finally子句使得方法返回0;在内层try语句的返回前,执行finally子//句的return;
}
}
Catch(IOException e)
{
e.printSTackTrace();
}
}
58.堆栈跟踪:getStackTrace()方法获得StackTraceElement对象的数组,在程序中分析这个对象。只跟踪抛出异常的语句,不追踪错误根源。
59.使用异常:
1)只有在异常情况下使用异常机制
2)不过分细化异常
3)利用异常层次结构(寻找更适当的子类、创建具体异常类)。
4)不压制异常(及时关闭不在throw表中的异常)。
5)检测错误细致,具体。
6)适当传递异常,让高层次方法通告用户发生了错误,或者放弃不成功的命令。(“早抛,晚捕”)。
60.java.io.InputStream;
Java.io.OutputStream;(输入输出流关联磁盘文件)。 C FILE*“C:\\A\\a.txt”;
File f=new file(“C:\\A\\a.txt”);
FileInputStream fin=newFileInputStream(f);//字节层次;只能从fin对象读取字节和字节数组。
61.数据流:使用DataOutput接口提供的方法。随机存取文件流能够在文件的任何位置查找或者写入数据。(随机存取磁盘文件)。RandomAccessFile(“文件路径”,”r”);mode r/rw;
62.文本流:InputStreamReader和OutputSreamWriter;(字符流编码转到字节流);
InputStreamReader in=newInputStreamReader(System.in);还可选定编码方案。
63.文本输出:PrintWriter需要与一个目标writer相结合。
PrintWriter out=new PrintWriter(new FIleWriter(“employee.txt”));
不能向PrintWriter内写入原始字节。PrintWriter用于输出文本。
64.文本输入:BufferedReader in=new BufferedReader(new FileReader(“1.txt”));
BufferedReader in2=new BufferedReader(newInputStream(System.in));
文本读取数字:Strings=in.readLine(); double X=Double.parseDouble(s);
Zip文件流:(顺序读取Zip文件)
ZipInputStream zin=new ZipInputStream(newFileInputStream(“1.zip”));
ZipENntry entry;
While((entry)=zin.getNextEntry()!=null)
{
ZipEntry z=new ZipEntry(“1.zip”);
ZipOutputStream o=new Zip….(fout);
//读取 zin; //处理文件条目和子条目;
Zin.closeEntry;
}
Zin.close();
Jar文件读取使用JarIn...和Out…
65.StringBuilder(单线程)根据需求增长或缩短char[];(StringBuffer效率稍低,但允许多线程增删字符)。
66.对象流:ObjectOutputStream out=new ObjectOutputStream(new FIleOutPutStream(“1.dat”));
67.正则表达式:指定字符串模式。
正则表达式[Jj]ava.+ 首J,j下来ava,后任。
-范围含边界,^补,\.转义.,\\为、;
^匹配行首,$行尾; xy和 x|y或;
X+,x*,x?(1+,0+,01);
不足匹配,贪心匹配;(模式的多义性导致);
组定义子表达式。[+-]?[0-9]+|0[Xx][0-9A-Fa-f]+
68.泛型:代码可以被不同类型对象重用。(形式上类似C++模板,(但java没有专用template关键字));泛型类:具有一个或多个类型变量的类。 Public class Pair<T,U> {…} T类型变量指定方法的返回类型以及域和局部变量的类型。 //private T first; 实例化:pair<String>(String,String);
泛型方法:A.<String>gets(names);
不能声明参数化类型的数组pair<Strig>[]table=newpair<String>(10);//x false;数组类型错误
禁止在静态域和方法引用类型变量。
69.泛型继承 pair<A> 和pair<B> 不和A,B本来的继承关系挂钩。
70.通配符类型:
pair<?extends A> 类型参数为任意继承A的子类。
超类型限定: pair<?superB> 方法
Void set(? Super B)
{
?super B get()
}
B任意对象或子类对象可以调用该方法。