java基础（二）

第二部分

Javac编译选项？

G产生调试信息

g:none不产生调试信息

verbose输出编译器消息，可以知道程序编译时用到了哪些Java类

Noware编译时不产生警告信息

encoding指出原文件的编码方式

D指定类文件产生的目录

classPath指出用户class文件的路径

sourcePath指出用户源文件路径

介绍JAVA中的Collection FrameWork(包括如何写自己的数据结构)?

Collection FrameWork如下：

核心接口有：

CollectionSetSorted Set

ListMapSorted Map

Set接口：不允许重复的元素。它对add、equals、hashCode方法增加了限制

SortedSet接口：扩展了Set接口，此接口的元素按升序排序。

List接口：一些集合具有顺序，即在一个项目后添加另一个项目。列表可以有重复元素。提供了ListIterator，允许向前或向后移动元素。

Map接口：将键映射到值得对象。Map不能包含重复键，但可以包含重复值。每个键最多都只能映射到一个值。

核心设计类：

Map 设计Set 设计List 设计

HashMapHashSetArrayList

HashtableLinkedHashSetVector

TreeMapTreeSetLinkedLisk

LinkedHasMap

散列表是最快的数据存储结构，它是一个数组。数据存储在数组中散列函数指定的特定下标。散列函数是一组输入数据和一组整数之间的映射。

集合类和接口层次

Collections是一个类，带有用于处理集合的静态实用方法

Collection是一个接口，带有多数集合常用的方法声明，包括add、remove、contains、size、iterator

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）

Map提供key到value的映射

集合框架的优点：

提供一组可用的集合接口，可以方便地扩展或改写集合；

接口和算法的可重用性提高了软件的可重用性；

提供了有效的数据结构和算法，减少了编程工作。

Java中异常处理机制，事件机制？

事件代表了组件之间的交互。是一种在源对象和监听对象之间，某种状态发生变化的传递机制。

通过事件处理机制，可以让一些组件作为事件源，发出可被组件环境或其它组件接收的事件。这样，不同的组件就可以组合在一起，组件之间通过事件传递进行通信，构成一个应用。

在java中实现事件机制的事件模型由三个部分构成：一个事件对象用于描述事件源的状态变化；一个事件源将会产生事件，提供注册的事件监听器的方法，把事件发送到监听器；事件监听器接收事件通知，实现该事件的监听器接口。

异常实际上是程序中错误导致中断了正常的指令流的一种事件.

Java异常处理用于在方法中能检查出错误但不能处理错误的情况，在这样的方法中将抛出一个异常。如果一个异常与某个catch程序块中的参数匹配，那么就执行该catch块中的代码。指出try catch finally的工作顺序。

运行时异常与一般异常有何异同？

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

什么是断言机制？

断言从JDK1.4版开始引入，它让开发期间测试假设，而没有付出为异常编写异常处理程序方面的代价，一旦程序完成开发，并全部部署，假设将从不会发生。

主要作用：因为在开发时对自己的假设非常肯定，所以不想花费时间来编写异常处理代码。断言让在开发期间测试你的假设。

private void method（int num）{

assert(num>=0）;//这里假定参数num是正数，如果不是真的将抛出一个AssertionError错误

useNum(num+x);

}

断言有两种形式：简单和非常简单。

非常简单：

private void doStuff（）{

assert(y>x);

//其他代码

}

简单：

将通过表达式的值向错误跟踪栈中添加更多信息，提供了更多调式帮助信息。

private void doStuff（）{

assert(y>x):”y is ”+y+” x is”+x;

//其他代码

}

运行时启用断言：

java –ea com.geeksanonymous.TestClass

运行时禁用断言：

java –da com.geeksanonymous.TestClass

JAVA中的多态与继承？

对象是定义了边界的、与要解决的问题有关的概念或事物。它们用于帮助理解现实世界。

类是拥有相同特性、共同的行为和共同的关系的一组对象。

封装是让开发者有选择地隐藏类中的特性和方法的过程

继承是允许通过重用现有类来构建新类的特性。]

多态性使用同一函数在不同的类上具有不同的行为。Java中的多态性是通过方法的动态绑定实现的。

抽象类与接口？

抽象类与接口都用于抽象，但是抽象类(JAVA中)可以有自己的部分实现，而接口则完全是一个标识(同时有多重继承的功能)。

abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized? 都不能

接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?

接口可以继承接口。抽象类可以实现(implements)接口，抽象类可继承实体类，但前提是实体类必须有明确的构造函数。

Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?

可以继承其他类或完成其他接口，在swing编程中常用此方式。

常见排序法

public class Sort{

public static int count=0;

public boolean LT(int num1,int num2){

return num1<num2;

}

public void output(int[] array){

System.out.print("第"+count+"次排序：");

for(int i=0;i<array.length;i++)

System.out.print(array[i]+" ");

System.out.println();

}

//冒泡排序法

public void BubbleSort(int[] array){

boolean swap=true;

int index=0;

int i=0;

while(i<array.length-1){

int temp=array[i];

for(int j=i;j<array.length;j++){

if(!LT(array[i],array[j])){

int temp2=array[i];

array[i]=array[j];

array[j]=temp2;

swap=true;

index=j;

}else{

swap=false;

}

}

i++;

if(swap){

array[i]=array[index];

array[index]=temp;

i++;

}

output(array);

}

}

//直接插入排序法

public void InsertSort(int[] array){

for(int i=1;i<array.length;++i){

if (LT(array[i],array[i-1])){

int temp=array[i];

array[i]=array[i-1];

array[i-1]=temp;

for(int j=i-1;j>0;--j){

if(LT(array[j],array[j-1])){

array[j]=array[j-1];

array[j-1]=temp;

}else{

break;

}

}

output(array);

}

}

}

//快速排序法

private int Partition(int array[],int low,int high){

int temp=array[low];

int pivotkey=array[low];

while(low<high){

while(low<high&&array[high]>pivotkey)--high;

array[low]=array[high];

while(low<high&&array[low]<=pivotkey)++low;

array[high]=array[low];

}

array[low]=temp;

output(array);

return low;

}

public void QSort(int array[],int low,int high){

if(low<high){

int pivotloc=Partition(array,low,high);

QSort(array,low,pivotloc-1);

QSort(array,pivotloc+1,high);

}

}

void QuickSort(int array[]){

QSort(array,0,array.length-1);

}

public static void main(String args[]){

int array[]={49,38,65,97,76,13,27,49};

Sort sort=new Sort();

System.out.println("===================================");

sort.output(array);

System.out.println("优化冒泡排序法");

sort.BubbleSort(array);

System.out.println();

System.out.println("===================================");

array=new int[]{49,38,65,97,76,13,27,49};

sort.output(array);

System.out.println("直接插入排序法");

sort.InsertSort(array);

System.out.println();

System.out.println("===================================");

array=new int[]{49,38,65,97,76,13,27,49};

sort.output(array);

System.out.println("快速排序法");

sort.QuickSort(array);

}

}

　

解析XML文件的几种方式和区别

XML解析器使用的两种基本API

文档对象模型DOM，一种基于树结构的API。它定义了一组java接口，用于创建、访问和操纵XML文档的内部结构。它是基于对象。整个XML文档被作为对象体系结构排列进行解析和存储，应用程序可以随机访问这些对象。

DOM主要用于：在结构上修改XML文档时；在内存中与其他应用程序共享文档时。

SAX提供一种用于解析XML文档的事件驱动模型，使用SAX接口的XML处理器并不创建数据结构，而是扫描输入的XML文档，并生成元素开始、元素结束等事件，在发生事件时，解析器会通知应用程序。

SAX优点：在解析大型文档时，不必将整个文件加载到内存中，因此占有的内存比DOM少。在只需要一个信息子集时，SAX忽略不需要的数据，而DOM无法做到这点。

SAX的缺点是：必须按到达顺序处理数据，不能对文档进行随即访问。SAX是只读的，它是设计来读取XML文档而不是写入的。文档只能遍历一次。

使用DOM API查找XML文档中的元素和属性

import org.w3c.dom.*;

import javax.xml.parsers.*;

import java.io.*;

import java.net.URL;

public class BookDetails{

public BookDetails(String filename){

Document doc=null;

try{

DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();

dbf.setNamespaceAware(true);

DocumentBuilder db=dbf.newDocumentBuilder();

doc=db.parse(new File(filename));

String nm="http://www.123books.com/booktitles";

String local="a";

String ob="http://www.onlinebooks.com";/

System.out.println(nm+"名字空间中的元素");

NodeList nl=doc.getElementsByTagNameNS(nm,"*");

for(int i=0;i<nl.getLength();i++){

Node n=nl.item(i);

System.out.println(n.getNodeName());

}

System.out.println("\n 名称为 "+local+" 的元素");

nl=doc.getElementsByTagNameNS("*",local);

for(int i=0;i<nl.getLength();i++){

Node n=nl.item(i);

System.out.println(n.getNodeName());

}

System.out.println("\n名字空间 "+ob+" 中的属性");

nl=doc.getElementsByTagName("*");

for(int i=0;i<nl.getLength();i++){

if(nl.item(i) instanceof Element){

Text t=(Text)nl.item(i).getFirstChild();

Element e=(Element)nl.item(i);

Attr a=e.getAttributeNodeNS(ob,"class");

if(a!=null){

String val=a.getNodeValue();

System.out.println("<"+val+">"+t.getNodeValue()+"</"+val+">");

}

}

}

}catch(Exception e){

e.printStackTrace();

}

}

public static void main(String args[]){

BookDetails nsd=null;

if(args.length>=1){

nsd=new BookDetails(args[0]);

}else{

System.out.println("Books.xml");

}

}

}

使用SAX API解析XML文档

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

public class SAXParserHandler extends DefaultHanlder{

public void startDocument() throws SAXException{

System.out.println("起始文档");

}

public void endDocument() throws SAXException{

System.out.println("结束文档");

}

//在遇到字符数据时激发

public void characters(char[] ch,int start,int lenght) throws SAXException){

String charString=new String(ch,start,lenght);

System.out.println("字符："+charString);

}

public void startElement(String namespaceURI,String localName,String qName,

Attributes atts)throws SAXException{

System.out.println("起始元素"+qName);

for(int i=0;i<atts.getLength();i++){

System.out.println("属性值："+atts.getvalue(i));

}

}

public void endElement(String namespaceURI,String localName,String qName)

throws SAXException{

System.out.println("结束元素"+qName);

}

public static void main(String args[]) throws Exception{

SAXParserFactory factory=SAXParserFactory.newInstance();

SAXParser parser=factory.newSAXParser();

parser.parse("book.xml",new SAXParserHanlder());

}

}

使用DOM API写XML文档

import org.w3c.dom.*;

import javax.xml.parsers.*;

import javax.xml.transform.*;

import javax.xml.transform.dom.*;

import javax.xml.transform.stream.*;

import java.io.*;

public class Student{

public static void main(String args[]){

Document doc;

Element students;

Element stud;

Element fName;

Element sName;

try{

DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();

DocumentBuilder db=dbf.newDocumentBuilder();

doc=db.newDocument();

stud=doc.createElement("Student");

fName=doc.createElement("FirstName");;

fName.appendChild(doc.createTextNode("John"));

stud.appendChild(fName);

sName=doc.createElement("Surname");

sName.appendChild(doc.createTextNode("David"));

stud.appendChild(sName);

students=doc.createElement("Students");

students.setAttribute("Department","Mathematics");

students.appendChild(stud);

doc.appendChild(students);

TransformerFactory tf=TransformerFactory.newInstance();

Transformer transformer=tf.newTransformer();

transformer.transform(new DOMSource(doc),new StreamResult(System.out));

}catch(Exception e){

e.printStackTrace();

}

}

}