13518219792
通过RSS把数据整合到一起。确实提供了很多方便。
公司主营业务：成都网站制作、成都网站设计、移动网站开发等业务。帮助企业客户真正实现互联网宣传，提高企业的竞争能力。成都创新互联是一支青春激扬、勤奋敬业、活力青春激扬、勤奋敬业、活力澎湃、和谐高效的团队。公司秉承以“开放、自由、严谨、自律”为核心的企业文化，感谢他们对我们的高要求，感谢他们从不同领域给我们带来的挑战，让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。成都创新互联推出德令哈免费做网站回馈大家。
不知道是不是自己太没有觉悟，没有用sourceforge上面的源码，自己用dom写了一个rss的读取器，代码列在下面吧。
package rssweb;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.CharacterData;
/**
*
Title: RSS页面显示bean
*
*
Description: 通过调用该bean，实现在jsp中解析rss并在页面中显示
*
*
Copyright: Copyright (c) 2005
*
*
Company: ui studio
*
* @author uijiang
* @version 1.0
*/
public class ShowRSS {
//PreTitle存储RSS channel项目下的title名
public String PreTitle;
//itemList存储RSS的item项目下的title名
public String[] itemList;
//linkList存储RSS的的item项目下的link名
public String[] linkList;
//pubDateList存储RSS的的item项目下的pubDate名
public String[] pubDateList;
//descriptionList存储RSS的的item项目下的description名
public String[] descriptionList;
//itemCount记录读取出来的项目数
public int itemCount;
//不带参数的构造函数，不对各成员初始化，返回null
public ShowRSS() {
}
//将RSS地址以destination传入，实现读取操作，并为各成员变量赋值。
public ShowRSS(String destination) {
try {
//DOM初始化
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.
newInstance();
DocumentBuilder documentBuilder = dbFactory.newDocumentBuilder();
Document document = documentBuilder.parse(destination);
//得出item数量
NodeList nodelistCount = document.getElementsByTagName("item");
itemCount = nodelistCount.getLength();
//初始化各成员数组
itemList = new String[itemCount];
linkList = new String[itemCount];
pubDateList = new String[itemCount];
descriptionList = new String[itemCount];
//赋值计数
int _count = 0;
//获取title并为各成员变量赋值
NodeList nodelistTitle = document.getElementsByTagName("title");
for (int i = 0; i nodelistTitle.getLength(); i++) {
Node node = nodelistTitle.item(i);
if (node.getParentNode().getNodeName().trim() == "channel") {
PreTitle = ((CharacterData) node.getFirstChild()).getData();
}
if (node.getParentNode().getNodeName().trim() == "item") {
itemList[_count++] = ((CharacterData) node.getFirstChild()).
getData();
}
}
//赋值计数
_count = 0;
//获取link并为各成员变量赋值
NodeList nodelistLink = document.getElementsByTagName("link");
for (int i = 0; i nodelistLink.getLength(); i++) {
Node node = nodelistLink.item(i);
if (node.getParentNode().getNodeName().trim() == "item") {
linkList[_count++] = ((CharacterData) node.getFirstChild()).
getData();
}
}
//赋值计数
_count = 0;
//获取pubDataList并为各成员变量赋值
NodeList nodelistpubDate = document.getElementsByTagName("pubDate");
for (int i = 0; i nodelistpubDate.getLength(); i++) {
Node node = nodelistpubDate.item(i);
if (node.getParentNode().getNodeName().trim() == "item") {
pubDateList[_count++] = ((CharacterData) node.getFirstChild()).
getData();
}
}
//赋值计数
_count = 0;
//获取pubDataList并为各成员变量赋值
NodeList nodelistDescription = document.getElementsByTagName(
"description");
for (int i = 0; i nodelistDescription.getLength(); i++) {
Node node = nodelistDescription.item(i);
if (node.getParentNode().getNodeName().trim() == "item") {
descriptionList[_count++] = ((CharacterData) node.
getFirstChild()).
getData();
}
}
} catch (Exception e) {
}
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Test {
private String[] arr1;
private String[] arr2;
public Test(){
//数组长度可以随意改，但必须保证两个数组长度一样
arr1 = new String[3];
arr2 = new String[3];
initArray();
}
private void initArray(){
Scanner scanner = new Scanner(System.in);
for(int i=0;iarr1.length;i++){
arr1[i] = scanner.next();
}
for(int i=0;iarr2.length;i++){
arr2[i] = scanner.next();
}
}
/**
* 获取组合后的数组表单
* @return
*/
private ListString[] getcombineList(){
ListString[] list = new ArrayListString[]();
combineArray(list, arr1, arr2);
combineArray(list, arr2, arr1);
return list;
}
/**
* 遍历数组str1，并将其复制到新的数组，再将str2中索引值与str1中索引值
* 相同的元素放入新的数组，然后将新的数组放入list中
* @param list
* @param str1
* @param str2
*/
private void combineArray(ListString[] list,String[] str1, String[] str2){
for(int i=0; istr1.length; i++){
String[] str = new String[str1.length];
for(int j=0; jstr2.length; j++){
str[j] = str2[j];
if(i == j)
str[j] = str1[j];
}
System.out.println(getArrayMessage(str));
list.add(str);
}
}
/**
* 将数组每一个元素组合成字符串
* @param str 字符串数组
* @return 组合字符串
*/
private String getArrayMessage(String[] str){
StringBuffer buffer = new StringBuffer();
for(int i=0; istr.length; i++){
if(i == str.length-1)
buffer.append(str[i]);
else
buffer.append(str[i]).append(",");
}
return buffer.toString();
}
public static void main(String[] argv){
Test test = new Test();
test.getcombineList();
}
}
//依赖最常见的是参数关系，如：
public class B{
/***B中的一个方法**/
public void testMethod(A a){
//此时B和A是依赖关系
}
}
//聚合关系通常表现为部分与整体的关系，如：
public class B{
/***B中的一个属性**/
A a;
}
//泛化关系通常表现为继承关系，如：
public class B extends A{
}
Java程序设计基础的笔记
『更新时间：2005-3-6 17:21:05』『推荐』『报错』『咨询』『编辑：Jack Chen』『来源：』
Java程序设计基础的笔记
第1课 没有啥好学的，记住下面两点
1、语言的分类 (要懂得举例)：
1）面向对象程序设计语言:Java,C++,smalltalk
2）过程式程序设计语言:C,Pasal
2、语言的分类
1)解释执行语言:如Java，Basic
2)编译执行语言:如C,C++
第2课
1)Java的特点：
简单性、面向对象、分布式()
健壮性(提供自动垃圾回收机制进行内存管理、提供面向对象的异常处理机制、提供严格的类型检查)
平台无关性、解释执行、安全性(不支持指针)、多线程、动态性（是其面向对象设计方法的扩展）。
2)JAVA的平台技术
Java虚拟机、字节码、即用时装入、JIT(Just in Time)及时编译技术
3)Java源文件必须以扩展名.java保存
编译源文件：javac hello.java 执行程序：java hello
第3课 面向对象和开发环境建立
1)面向对象：是一种运用对象、类、继承、封装、聚合、消息传递，多态性等概念来构造系统的一种软件开发方法；追求软件对客观世界的直接模拟；
2)面向对象和客观世界的关系
3)对象：软件系统的基本构成单位；代表问题域中的客观事物的抽象表示，在面向对象中，对象是基本的运行实体，包括属性和行为，将属性和行动封装成一个独立的实体；
4)类：对象之上的抽象，类与类的实例之间关系是抽象与抽象之间的关系，类是创建对象的模板；
5)属性和方法：
属性是描述对象的状态；即表示客观事物的静态特性（数据）；
方法是描述对象的动作；即表示客观事物的动态特性（对数据的操作集合）
6)消息：对象之间利用消息进行通信，具体体现在一个对象调用另一个对象的方法；
7)面向对象语言的三大特点：封装性、继承性、多态性
封装性：指将属性和方法封装在一起，形成一个能动的实体（对象）；
继承性：在不同层次上运用抽象原则，获得类和派生类，源生类可以继承基类的属性和方法。
好处在于：体现层次关系，减少代码数据冗余、增加可重用性；
多态性：向不同的对象发送同一消息，根据对象类的不同而完成不同的行为；
多态是通过继承机制来实现的。
第4节课 建立开发环境(很简单的)
1、配置开发环境
1)安装操作系统：win2000/XP/NT
2)安装JDK1.3或是JDK1.4
3)打开环境变量设置窗口
[开始][设置][控制面板][系统][高级][环境变量]或是[系统变量]
4)配置Path环境变量：值应为c:\Jdk1.3.1\bin --编译路径
5)配置ClassPath环境变量：---类路径
值应为.;c:\jdk1.3.1\lib\tools.jar;c:\jdk1.3.1\lib\dt.jar
6)打开一个命令窗口
7)测试安装是否成功
第5节课 Java语言基础
1)Java的输入输出：字符界面输出、图形界面输出 --本文是前者；
2)记住输入输出的编程语句：
首先要引用import java.io.*;
System.out.println(输出内容);
System.in.read(); 读取一个字符；(字符必须进行初始化，char c=\0)
3)注释方式：三种
// 单行注释：从“//”开始一直到行尾均为注释
/* 一行或多行的注释 */
/** 文档注释 */
第6节课 类型、常量、变量
1)标识符：变量、常量、类、方法的名称都是标识符。
它的组成是有四种：字母、数字，_和$，标识符的开头字符不能以数字开头。
2）Java中标识符需要注意的地方：
保留字或关键字不能作为标识符；
标识符区别大小写；
数字不能开头；
标识符不能含有其他字符；
3)关键字、保留字：请见书上的17页；有印象就可以了。编程时稍注意一点就可以。
4)Java数据类型：基本数据类型和复合数据类型；
基本数据类型：共有8种，分为4小类;分别为逻辑型(boolean)、字符型(char)、整型
(byte,short,int,long)和浮点型(float,double)
复合数据类型：类、数组、接口
5)Java基本数据类型
每一种类型都是有默认值的（整型=0,浮点型=0.0 布尔类型=false,字符类型=\u0000）
size是平台独立的（不运行在硬件上，而是虚拟机上）,各种类型的长度大小：
byte=8;short=16;int=32;long=64;float=32;double=64;char=16;boolean=8
6)变量：指在程序运行过程中可以改变的量，由类型、变量名、变量值三要素组成；
常量：一旦赋了初值，就不能再改变的量，定义常量要使用关键字final.
7)整型常量：十进制整数、八进制整数(以0开头)、十六进制整数(以0x开头)
字符常量：用一对单引号括起来的一个字符。
转义字符：反斜线后面跟上一个字符,\n 换行 \r 回车 \b退格\t 水平制表TAB \0 空
字符串常量：用一对双引号括起来的一个字符序列。
注意：字符串常量和字符常量的区别：
A表示形式不同；B在内存中存储空间不同；C操作不同；D存放两者的变量不同；
8)数组的特点：A、是同类元素的有序集合;B、其元素可用下标访问;C、连续存放;
所有数据类型都可以作为数组的元素，Java的基本工具包(java.util)中有许多类能实现多种类型的数组。
9)数组的定义方法：
A、int[] 数组名 或 int 数组名[] 分配空间时则是在程序中：数组名=new int[10];
B、int[] 数组名=new int[10];
第七章 运算符、流程控制
1)算术运算符：用来定义整型和浮点型数据的算术运算，分为单目，双目和赋值运算符；
单目：
双目：+、-、*、/,%只对整型运算有效
2)关系运算符：、、= = == !=
注意：区分=(赋值)和==(判断)的差别
不能在两个浮点数之间进行==的比较
=、==、!=都能对object reference进行操作
String类支持+和+=
3)逻辑运算符:与、||或、!非
4)位运算符（以二进制位进行运算，操作数和结果都是整型数据）：
~ 位反、｜位域、 位与、^ 位异或、 右移、 左移、 右移，左边空出位填零
5)三目运算符 int x=1,y=2,z=3;int i=x0?y:z; //i的取值是3
6)运算符注意事项：A、运算符的优先级；B、运算符的结合性;具体见P27;
第八节课 流程控制
建议看书本，内容不多
具体结构摘抄如下：
1)if语句：
if {}
或if {} else {}
或if {} else if {} else if {}... else if {} else {};
2)Switch语句：
Swith(条件表达式) {
case 判断值1:语句组1
case 判断值2:语句组2
...
case 判断值n:语句组n
default :语句组n+1;
}
3)for (表达式1;表达式2;表达式3)
循环体；
4)while (条件表达式) 循环体;
5)do ...循环体... while (条件表达式);
6)break; //不带标签;
break label //带标签;
7)continue; //不带标签;
continue label; //带标签;
第9节课 类和对象
1)什么是面向对象？
面向对象是一种新的程序设计范畴，一种新的编程方法；她运用对象、类、继承、封装、聚合、消息传递，多态性等概念来构造软件系统。她追求对客观世界的真实模拟、体现，提高了程序的重用性。
2)什么是对象？
对象是面向对象软件系统中的基本构成单位，代表问题域中的客观事物的抽象表示。
在面向对象中，对象是基本的运行实体，包括属性和行为。将属性和行为封装成一个独立的实体。
3)什么是类？
类是对象之上的抽象，类与对象（类的实例）之间的关系是抽象与具体的关系，类是创建对象的模板；
4)类的一般定义形式
修钸符 class 类名[extends 父类名][implements 接口1,接口2,...] {
修钸符 类型 成员变量1;
修钸符 类型 成员变量2;
修钸符 类型 成员方法1(参数列表){
类型 局部变量
方法体
}
...
}
5)对象如何创建
定义一个对象的引用String s1;
创建一个对象实例：使用关键字new; 例如String s1= new String(字符串内容);
6)对象实例 VS 对象引用
.通过引用操纵对象 .引用不等于对象
.引用保存在堆栈里，对象保存到堆里面
.对于句柄,一种安全的方法就是创建一个引用时就进行初始化
第10课
1)构造函数:通过一个new创建一个类的实例，通过调用构造函数来完成初始化操作；
它的特点：构造函数名字和类完全相同。
构造函数没有返回值，不需要用void
构造函数可以重载。
2)函数重载：使得一个函数名可以对应不同的实现；
实现它的要求：函数参数的类型、函数参数个数、函数参数的顺序不同
仅仅返回值不同是不能实现函数重载的。
在编译时根据函数调用的形式选择适当的重载函数
3)每个类都至少有一个构造方法，如果程序员没有为类定义构造方法，系统会自动为该类生成一个默认的构造方法
默认构造方法的参数列表及方法体均为空。
4)对象的清除
Java引入了新的内存管理机制，由Java虚拟机担当垃圾收集器的工作，你可以任意创建对象而不用担心如何清除它们，垃圾收集器会自动清除它们的。
使用new操作符创建对象后，Java虚拟机自动为该对象分配内存并保持跟踪。Java虚拟机能判断出对象是否还被引用，对不再被引用的对象释放其占用的内存。这种定期寻找不再使用的对象并自动释放对象占用内存的过程称为垃圾收集。
第11课 关键字
1）static关键字：指其属性和方法不需要类的实例化，可以用类直接调用。适用于属性和方法。
类方法可能通过一个类进行调用，而不需要进行实例化出一个对象。
double root=Math.sqrt(453.0);即静态属性和方法可以用类名直接调用，如System.out.println();
2)final关键字：它是最终修shi符，适用于属性、方法、类。
对于基本数据类型、final将值变成一个常数；
对于对象引用时，final将引用变成一个常数，即进行声明时，必须将引用初始化到一个具体的对象，而且永远不能将引用变成指向另一个对象。然而对象本身是可以修改的。
对于数组，类似对象引用，不能重新指向，但数组中的对象并不是常量。
它的作用：A、是防止一个方法的行为在继承期间被覆盖或重写。
B、不希望这个类有子类，所以一个final类中的所有方法都默认为final.
C、
3)数组的定义和初始化 int x[]={5,2,0}
float fArray[]= new float[10];
第12课 构架函数P71
1)什么是访问控制？
在java中，类，属性，方法，接口等都需要访问控制修饰符，它明确指定类，属性，方法，接口的作用域和可见性。即它们可以被程序的哪些部份访问的调用。
2)为什么要使用访问控制符？
它可以使程序结构清晰，严谨。类的使用更加安全，体现封装的概念。
3)访问控制级别：包、类访问控制、成员访问控制
包:
在Java中，将完成相同功能的一组类(.class)组成一个集合，放在一个包中。
通过包，将各种类按照层次组织在一起，使程序的功能结构十分明确，清晰。
如何定义包？
package myFirstPackage
注意：package必须放在一个java文件的最开始。
如何使用一个包中的类？
import java.awt.*
import java.awt.Button
注意：import语句放在package语句之后，任何class定义之前。
包的层次
一个包可由若干个类和子包构成。
当带有包的时候，正确的编译运行程序方式为:java -d .HelloWorld.java
当不带有包的时候，正确的编译运行程序方式为:java HelloWorld.java
第14课(继上节课) 类访问控制符
1)类的访问控制符包含：
.public表示它可能其他所有的类访问和引用，通过它的实例来访问对象的可见属性和方法
.友好的(默认的)表示该类只能被同一个包中的类访问和引用，而不可以被其他包中的类访问和使用。
注：Java中规定，一个.java文件中必须有一个且只有一个public类，因而文件中的其他类只能是友好级别。含有main()方法的类一定是public类
2)成员访问控制符
.public：公有成员，可以被任何类访问，应慎用。
.private：私有成员，只能被访类的方法访问。它提供最高级别的访问。
.protected:保护成员，它能被同一个包中的其他类和任何包中的子类访问。
.友好的(默认的):同一个包那的类都可以访问它；
3)Java应用程序结构
一个可运行的java程序可以包含:多个包、多个.java源文件
一个.java源文件可以包含多个类；
若一个.java源文件包含n个类（class），则编译后生成n个.class文件。
第15课 继承性
1)什么是继承?
通过在不同层次上进行抽象，得到子类（基类）和父类（派生类），子类可以继承父类的非私有属性和方法，即继承基类的特征和能力。
注意：Java不支持多重继承(即不允许一个类有多个直接父类);
2)继承的好处：
继承体现出类的层次关系
减少代码冗余，增加软件复用性
降低软件开发时间，提高软件维护效率
3)继承的一般定义形式
class subclass extends baseclass {....}
第16课
子类的方法不能访问父类的私有成员。
1)子类如何初始化从父类继承而来的属性
a、在派生类的构造函数中没有指明基类的构造函数时，JAVA会自动在第一行加入对基类构造函数的默认调用
super()语句;
b、当基类的构造函数需要参数时，则一定要在派生类的构造函数第一条语句明确调用基类代参数的构造函数
super(agrs)。
c、当基类的构造函数不需要参数时，则在派生类的构造函数中可以不明确的调用super();
2)super和this关键字
super:如果要在子类中调用父类的方法或者访问父类的属性时，则应该是super.methodname();
第17课 多态性
1)什么是多态性？
向不同对象发送同一消息，不同类型的对象产生不同的行为，多态是通过继承机制实现的。
2)什么是重载？
函数名相同，但是函数的参数类型、参数个数、参数顺序不同。
第18课 抽象类
抽象类和抽象方法
1)定义格式：
abstract class instrument{
abstract public void play();
}
注意：1、在一个方法之前加上abstract关键字，且方法体的代码为空，则这个方法就成为抽象方法了。
2、抽象类不能实例化；
3、如果一个类包含一个抽象方法，则这个类必须被声明为抽象类。
2)接口定义
modifier interface interface_name
{varbletype variblename1 ....
returntype method1(params);
}
注意：接口的访问类型同类的访问类型。可以用public或者缺省为包级别的。
接口可以有数据成员，但接口中的数据成员隐藏含是public、static、final。
接口的方法定义是public、abstract，不能是private protected
3)接口使用
1.一个类如果要实现一个接口，就必须实现接口中的所有方法；
2.一个类如果只是实现接口中的部份方法，则一定要标明这个类是抽象类。
3.一般能用接口的就不用抽象类，只有当需要方法定义或成员变量时才用抽象类。
5.接口可以继承，使用关键字extends。
6.一个类如果实现一个继承其他接口的接口，则这个类必须实现这个接口和它的基类接口的所有方法；
7.在Java中，子类和父类只能是单重继承关系，如果要实现多重继承，则需要用到接口。
第19课 Exception
1)对于编程人员，错误分成编译错误和运行错误。
2)什么是Exception?
指在程序运行过程中出现的一些意料之外的错误。
Exception机制：就是用来在发生异常时，告诉程序如何控制自身的运%
聚合(Aggregation) 关系是关联关系的一种，是强的关联关系。聚合是整体和个体之间的关系。例如，汽车类与引擎类、轮胎类，以及其它的零件类之间的关系便整体和个体的关系。与关联关系一样，聚合关系也是通过实例变量实现的。但是关联关系所涉及的两个类是处在同一层次上的，而在聚合关系中，两个类是处在不平等层次上的，一个代表整体，另一个代表部分。
组合(Composition) 关系是关联关系的一种，是比聚合关系强的关系。它要求普通的聚合关系中代表整体的对象负责代表部分对象的生命周期，组合关系是不能共享的。代表整体的对象需要负责保持部分对象和存活，在一些情况下将负责代表部分的对象湮灭掉。代表整体的对象可以将代表部分的对象传递给另一个对象，由后者负责此对象的生命周期。换言之，代表部分的对象在每一个时刻只能与一个对象发生组合关系，由后者排他地负责生命周期。部分和整体的生命周期一样。
class Driver {
//使用成员变量形式实现关联
Car mycar;
public void drive(){
mycar.run();
}
...
//使用方法参数形式实现关联
public void drive(Car car){
car.run();
}
}
聚合关系是是一种比较强的关联关系，java中一般使用成员变量形式实现。对象之间存在着整体与部分的关系。例如上例中
class Driver {
//使用成员变量形式实现聚合关系
Car mycar;
public void drive(){
mycar.run();
}
}
假如给上面代码赋予如下语义：车是一辆私家车，是司机财产的一部分。则相同的代码即表示聚合关系了。聚合关系一般使用setter方法给成员变量赋值。
假如赋予如下语义：车是司机的必须有的财产，要想成为一个司机必须要先有辆车，车要是没了，司机也不想活了。而且司机要是不干司机了，这个车就砸了，别人谁也别想用。那就表示组合关系了。一般来说，为了表示组合关系，常常会使用构造方法来达到初始化的目的，例如上例中，加上一个以Car为参数的构造方法
public Driver(Car car){
mycar = car;
}
所以，关联、聚合、组合只能配合语义，结合上下文才能够判断出来，而只给出一段代码让我们判断是关联，聚合，还是组合关系，则是无法判断的。
