JAVA学习笔记

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任意对象或子类对象可以调用该方法。