第一篇：Java课程教学小结
2010年~2011年度第一学期《Java程序设计》课程总结及教
学效果分析教学改进报告
本学期本人担任了软件日语091班的《Java程序设计》课程的教学工作，通过一学期的教学，本人的总结如下：
情况分析：《Java程序设计》课程讲述的内容是Java程序设计。课程以Java为蓝本进行教学，注重操作和程序设计，是一门实用性很强的课程，我比较喜欢，因此从起初就下定决心要教好这门课程了。针对这这个学期的教学工作现在总结如下。
１、采用多媒体教学。用生动形象的教学课件帮助学生理解。一些学生比较难理解的章节内容，我都作成动态的画面，将每一步操作都动态的表示出来，学生有兴趣看，也有兴趣学习。使学生能理解难点内容，掌握重点内容，巩固学习效果。
２、案例教学法和任务驱动法的实施和应用。在教学活动中我采用订单管理系统为教学案例，开展教学。从基本概念到最后的类以及最终项目的完成，都采用这一案例进行。所有实例都可以运行，可以查找结果。在机房，学生可以边操作边运行实例，上课是由于任务驱动，学生操作的积极性很高。
３、在课堂上开展竞赛，学生参与，谁首先完成任务，谁先检查，并且每次检查都有分数记录，因此学生的积极性大大提高，教学效果好，听课认真。
４、项目引领课程，要求学生完成在线考试系统，这是一个由数据库SQL做后台，Java做前台的系统。虽然和真正的软件还是有差距的，但是通过本课程学生可以理解使用Java调用SQL的过程和编写大的数据库软件的方法。在这个案例中，我全程辅导，指导学生完成数据库、表、每个界面和各个代码的编写、讲解、录入。由于这个环节被学校抽到听课和资料检查学生格外认真，我也感到了学生对我的教学工作的支持，我非常满意。尽管他们是大二的学生，但是他们的热情和认真不逊色与其他班级。因此，通过一个学期一门课程和一个实训环节的相处我和这个班级的学生的感情很深。
５、认真作好教案和备课笔记，这是自己最为重要的教学资源，是经验和知识的积累。
在今后的教学过程中，我还要不断总结，多采用多媒体课件的方式为学生进行演示，以加强学生的感性认识，培养学生真正掌握学习计算机科学技术的思想和方法，为学生课后的进一步学习提供指导和帮助，争取达到更好的教学效果。
第二篇：java小结
//1.累加 public class 累加 {
}
//2.阶乘
public class 30的阶乘 {
} public static void main(String[] args){
} int product=1;for(int i=1;i<=30;i++){ product=*i;} public static void main(String[] args){
} int i=1;for(int counter=1;counter<=100;counter++){ } System.out.println(i);i+=counter;
//3.倒序输出
法1 用char数组思想 import java.util.Scanner;public class 逆序输出 {
public static void main(String[] args){
Scanner scan=new Scanner(System.in);// String input[]=new String[4];input=scan.nextLine();// huiche
// String result=“";char[] Array=input[4].toCharArray();for(int i=Array.length-1;i>=0;i--){
} result+=Array[i];} System.out.println(result);} //倒序输出 法2 用reverse（）方法 import javax.swing.JOptionPane;public static void main(String[] args){
}
String a = null;StringBuffer b;//输入
a=JOptionPane.showInputDialog(a);StringBuffer c1=new StringBuffer(a);b=c1.reverse();System.out.println(b);
//4.输出100 121 144...361 public class平方输入数组 {
}
//5.求最大公约数
private static int gys(int m,int n)
{
if(n==0)
return m;else public static void main(String[] args){
} int[] array=new int[10];for(int i=0;i<10;i++){ } array[i]=Math.pow((i+10),2.0);
for(int k=0;k return gcd(n,m%n); } //6.求最小公倍数 public static int gbs(int n1,int n2){ int a =(n1>n2)? n1 : n2; for(int j=a;j<=n1*n2;j++) { if(j%n1==0 && j%n2==0) { return j; } } return 0;} //7.1）十进制整数转化为二进制整数采用“除2取余，逆序排列” import java.util.Scanner;public class Main { public static void main(String[] args){ //第一行输入要几组测试数据 int N=0,a;//N为输入几组数据，a为输入的十进制数字 } String b = null;Scanner scan=new Scanner(System.in);N=scan.nextInt();Main num=new Main();for(int i=1;i<=N;i++){ } a=scan.nextInt();b=num.deimalBinary(a);int d=num.Calcute(b);if(d%2==0)System.out.println(”Even“);else System.out.println(”Odd“); /*一个方法得到二进制数，用递归 *用2去除十进制整数，可以得到一个商和余数； *再用2去除商，又会得到一个商和余数，} *如此进行，直到商为零时为止，*然后把先得到的余数作为二进制数的低位有效位，*后得到的余数作为二进制数的高位有效位，依次排列起来 */ public String deimalBinary(int a){ } public int Calcute(String b){ } char[] Array=b.toCharArray();for(int i=0;i } if(Array[i]=='1'){ } counter+=1;return counter; //7.2）十进制小数转换为二进制小数采用“乘2取整，顺序排列” /*用2乘十进制小数，可以得到积，*将积的整数部分取出，再用2乘余下的小数部分，//8.矩阵运算（加减乘）//矩阵运算 *又得到一个积，再将积的整数部分取出，*如此进行，直到积中的小数部分为零，*或者达到所要求的精度为止。 *然后把取出的整数部分按顺序排列起来，*先取的整数作为二进制小数的高位有效位，后取的整数作为低位有效位。*/ import java.util.Scanner;public class Main { public static void main(String[] args){ int N1,M1,N2,M2,K;Scanner scan=new Scanner(System.in);N1=scan.nextInt();M1=scan.nextInt();int[][] a=new int[N1][M1];for(int i=0;i for(int j=0;j N2=scan.nextInt();M2=scan.nextInt();int[][] b=new int[N2][M2];for(int i=0;i { } b[i][j]=scan.nextInt();} K=scan.nextInt();if(K==1)//加法 { int[][] c=new int[N1][M1];for(int i=0;i } { for(int j=0;j } System.out.println();} } if(K==2)//减法 { int[][] c=new int[N1][M1];for(int i=0;i } for(int j=0;j for(int j:i){ System.out.print(j+” “);} System.out.println();} } if(K==3)//乘法 { int[][] c=new int[N1][M2];for(int i=0;i } { for(int j=0;j } for(int p=0;p c[i][j]+=a[i][p]*b[p][j];for(int[] i:c)for(int j:i){ System.out.print(j+” “);} System.out.println();} } } } 9.//保留确定位数输出 import java.text.DecimalFormat;//非四舍五入 DecimalFormat myformat=new DecimalFormat(”#0.00"); myformat.format(double num);//四舍五入,例为保留2位 double f=3.1415926; BigDecimal a=new BigDecimal(f); double af=a.setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue(); DAY01 JavaSE第一天课程安排 ##### 目标：开发第一个JAVA小程序，了解掌握相关概念 ##### 内容： 1、了解计算机相关概念 2、下载安装Java开发环境 3、开发第一个Java程序 4、开发环境设置优化 5、掌握Java程序的开发运行流程 6、掌握Java相关概念 7、练习 #####----------------计算机相关概念---------------- 1、计算机 1、机器 2、软件 3、数据输入----> 数据处理----> 数据输出-----（重要不紧急） 2、软件---- A、系统软件-----操作系统---windows linux B、应用软件-----QQ、CF、计算器（数据）软件的功能： 数据输入----> 数据处理----> 数据输出 数据-----123、文件、文件夹----泛称 3、计算机操作 物理操作 软件操作 GUI/CUI GUI-----图形用户接口-----Graphics User Interface(常用)CUI-----命令行用户接口---Command User Interface(了解)A、如何启动CUI 1、开始----> 附件-----> 命令提示符 2、开始----> 搜索CMD 3、win7----> shift 右击----> 打开命令行 B、DOS命令----CUI和GUI有对应关系 按规律记忆 电脑上数据分两类： 切换盘符：盘符号: 进入文件夹： cd 文件夹名 cd 路径名（进入多级） 返回上一级:cd..返回根目录:cd 1、文件 增 -----notepad/write/edit 查 -----type 文件名---查看内容 改 -----notepad/write/edit 删 -----del 文件名称 2、文件夹---dir 增----md XXX 查----dir--查看文件夹下所有文件 改----修改名称 ren 删----rd 要求： 1、简单调用----记住一个 help 2、调用 time date 等命令 3、命令如何使用--命令 /? DOS启动程序 1、DOS下进入程序所在路径 2、敲入程序名称 3、回车 需求：任意目录下启动程序，notepad可以，QQ不可以 edit cd cd..cd help 命令 /?----------不重要紧急 4、键盘使用------------重要不紧急 快捷键: 全选： ctrl + A 撤销： ctrl + Z 复制： ctrl + C 粘贴： ctrl + V 保存： ctrl + S------剪切： ctrl + X eclipse: ctrl + D----删除一整行 5、计算机语言 6、软件开发 使用计算机语言开发程序 学习计算机语言：语法 总结：了解----- 紧急-----常见的DOS命令 ----------------下载安装Java开发环境---------- 1、Java简介 A、詹姆斯 格斯林 B、开源----开放源代码 C、ONE体系 Open Net Environment----开放的网络环境 JavaSE-----桌面应用程序开发----核心----就业机会不多 JavaEE-----企业的分布式系统开发1）----（N从右向左数的位数） 4、负数的转换----（不不） -10 0000 0000 概念：原反补 正数：源码反码补码都一样 负数：原码----标志位是1，计数位和正数一样 反码----计数位取反，1变0,0变1 补码----反码基础之上 +1 101 0111 1111 1111 1111 1111 1111 1111 1111----2^311 = 127 short-----2个字节16bit----最小值：-2^15=-32768 最大值：2^15* / % ++--（重点）DAY03 一.算数运算符： 1.+ 2.- 3.* 4./ / 3 : 3 10 / 0 : 运行时异常； 10.0 / 0 :Infinity(无穷)不是异常 5.% % 3 : 1 10 % 0 : 运行时异常 10.0 % 0 : NaN(Not A Number)不是异常-10 %-3 :-1 10 % 3 :1-10 % 3:-1 10 %-3:1 6.++: 7.--: 如果表达式中，只做++或--一件事情，那么前++/--和后++/--效果一样的； 但如果表达式中做多件事情： 前++/--:先自增/自减，然后再参与表达式的其它运算； 后++/--:先参与表达式的运算，然后在自增/自减； 二.赋值运算符 1.=：执行顺序，从右至左，并且最后返回变量； 2.+=： 3.-=： 4.*=： 5./=： 6.%=： 特点：带隐式强制转换； byte b1 = 10;b1 = b1 + 20;//编译错误 b1 += 20;//OK的-->b1 =(byte)(b1 + 20);三.关系运算符： 1.==：判断是否相等 2.!=：判断是否不等； 3.<:左操作数是否小于右操作数； 4.>:左操作数是否大于右操作数； 5.<=:左操作数是否小于或者等于右操作数； 6.>=:左操作数是否大于或者等于右操作数； 四.逻辑运算符： &&、||和&、|的区别： 1.逻辑&&和||具有短路行为，一旦确定整个表达式的结果，那么将不再执行剩余表达式； 1.&&(语意：并且):两边都为true，结果为：true； 2.||(语意：或者)：有一边为true，结果为true;3.!(语意：不是)：!true：false；!false:true 位运算符： 4.&(并且):结果同&& 5.|(或者):结果同|| DAY04 一.运算符： 1.位运算符： 1).<<(左移)： 2).>>(有符号右移): 3).>>>(无符号右移)4).&(按位与):两位都是1，结果为1； 5).|(按位或):有1位为1，结果为1； 6).^(按位异或):两位相同结果为0，否则为1； 7).~(取反):1变0，0变1 2.位运算符的考点： 1).高效的计算某数 * 2 : << 2).高效的计算某数 / 2 : >> 3).&、|同&&、||的区别： 逻辑与&&、||：具有短路行为； 4).将两个变量的值交换：三次异或； 3.三目运算符： 条件表达式 ？ 表达式1 ： 表达式2； 二.键盘录入： 步骤： 1.import java.util.Scanner;2.Scanner sc = new Scanner(System.in);3.int : int num = sc.nextInt(); double : double d = sc.nextDouble(); String : String s = sc.next();三.选择结构： 1.if语句： 1)格式1： if(条件表达式){ } 注意：如果if体内只有一条语句，可以省略大括号，但不建议； 2)格式2： if(条件表达式){ //为true，执行这里 }else{ } //为false，执行这里 3)格式3： if(条件表达式){ }else if(条件表达式2){ }else if(条件表达式3){ }else{ } 2.switch语句： 1).格式： switch(表达式）{ } case 值1: //代码 break;case 值2： //代码 break;default: //代码 break;2).注意事项： 1.“表达式”可以产生的值：byte,short,int,char,枚举(JDK5以后),String(JDK7以后)2.case语句后跟“常量表达式”，不能是“变量”；而且不能出现相同的常量值； 3.break;语句“不是必须的”。如果不写，如果一旦case相应的值成功，但内部没有break语句，那么将会无条件(不再进行case匹配)的继续向下执行其它case中的语句，直到遇到break;语句 或者到达switch语句结束。4.多个case之间，没有顺序关系； 5.default语句“不是必须的”。可以不写，它就相当于多重if语句中最后的else。6.default语句和case语句“没有顺序关系”。 DAY05 一.while循环： while(条件表达式){ } 二.do_while循环： do{ }while(条件表达式);三.for循环： for(定义循环变量表达式 ; 条件表达式 ;增量表达式){ } 说明： 1.三个表达式都不是必须的；但分号必须要写； 2.执行顺序： 1).定义循环变量表达式； 2).条件表达式;3).进入循环； 4).增量表达式； 5).条件表达式； 6).进入循环 7).增量表达式......四.三种循环的区别： 1.只有do_while循环是先无条件的进入循环体执行一次，然后再判断； while和for循环都先判断，后进入循环体； 2.一般对于有明显的遍历范围的，建议首选for循环。 对于没有明显遍历范围的，一般使用while。 对于循环体中的内容，如果需要先执行一次，再判断，那么可以使用do_while DAY06 一.方法： 1.方法的作用：代码复用； 2.方法定义的格式： 修饰符 返回值类型 方法名([形参列表]){ } 修饰符：目前只需要写：public static 返回值类型：可以是任何的Java类型(基本数据类型、引用数据类型)。 如果没有返回值，这里要写void 方法名：自定义标识符； 形参列表：可以没有，但是一定写一对小括号。 如果有，每个形参是由：数据类型 形参名 多个形参，中间用逗号隔开； 3.方法内，可以写什么？ 1).定义变量； 2).if语句，switch语句； 3).各种循环语句； 总之：除了不能定义方法，其它都可以； 4.方法的注意事项： 1).方法不调用不执行;2).方法与方法是平级关系，不能嵌套定义;3).方法定义的时候参数之间用逗号隔开;4).方法调用的时候不用在传递数据类型;5).如果方法有明确的返回值，一定要有return带回一个值;5.方法的重载： 1).在一个类中，可以定义多个同名的方法，但形参列表不能完全相同； 2).方法重载，跟返回值类型无关；跟形参名无关； 二.数组： 1.一维数组： 1).定义的格式： 1.动态初始化：数据类型[] 数组名 = new 数据类型[数组长度];2.静态初始化： 数据类型[] 数组名 = new 数据类型[]{值1，值2，值3，.....，值n}; 数据类型[] 数组名 = {值1，值2，值3.....值n};2).数组是“引用数据类型”，变量存储的是“引用(地址)”； 3).当new(实例化)一个数组对象时，其“值”的空间是在堆中分配的，对于各种数据类型，都会分配一个 默认值： 整数：0 小数：0.0 字符：'u0000' 布尔：false String：null 其它引用类型：null 4).数组的访问方式：使用：数组名[索引] DAY07 一.二维数组： 1.定义的格式： 数据类型[][] 数组名 = new 数据类型[第一维的长度][第二维的长度];左边也可以写成： 数据类型 数组名[][] 数据类型[] 数组名[] 数据类型[][] 数组名 = new 数据类型[][]{{值1，值2},{值3，值4},{值5，值6，值7}};数据类型[][] 数组名 = {{值1，值2},{值3，值4},{值5，值6，值7}};二.方法的值传递和引用传递： 1.当一个方法接收的是一个“基本数据类型”时，调用方法传递实参时，是将“值”复制到方法内； 在方法内，如修改其值，修改的只是“副本”，原值不会被改变； 2.当一个方法接收的是一个“引用数据类型”是，调用方法传递实参时，是将“引用”复制到方法内； 在方法内，是可以通过这个引用修改“堆”空间的内容，即使方法结束，修改会影响到原堆中的值； DAY08 一.类：是一组相关的“属性”和“行为”的集合； 对象：是该类事物的具体体现； 二.类和对象的关系： 1.现实： 类 对象 猫 波斯猫 折耳猫 加菲猫 --------- 狗 金毛 藏獒 沙皮 2.代码： 类 对象 Cat c1 = new Cat();c1.name = “波斯猫”;class Cat{ } String name;int age;c1.age = 2; ----Cat c2 = new Cat();c2.name = “折耳猫”;c2.age = 3;----------------------------class Dog{ } Dog d1 = new Dog();d1.name = “金毛”;String name;int age;d1.age = 2; ----Dog d2 = new Dog();d2.name = “藏獒”;d2.age = 3; 三.类的定义： 1.使用关键字：class(注意小写)2.一个java源文件中： 1).如果定义多个类，但只有一个是public的；而且源文件名必须与这个public的类名一致； 2).如果定义多个类，可以没有public类；源文件名没有一致性要求； 3).main()方法不是必须放在public类中； 3.类中可以定义什么： 1).成员变量： A.可以是基本数据类型，也可以是任何引用数据类型； B.可以显示初始化； class Student{ } String name = “张三”;int age = 20;C.可以隐式初始化； 整型：0 浮点：0.0 字符：'u0000' 布尔：false 引用类型：null 2).成员方法： A.可以有参数，可以没参数； 可以有返回值，可以没有返回值； B.方法的“形参”可以是任何Java类型(基本数据类型、引用数据类型)C.方法的“返回值”可以是任何Java类型(基本数据类型、引用数据类型)D.一个类中可以定义多个同名的方法，但形参列表不完全相同，叫：方法的重载； 3).内部类(后面讲)； 4.成员变量和局部变量的区别： 1).成员变量： A.定义在“类体”中；可以是任何数据类型； B.会被自动初始化； class Student{ } String name;void show(){ } System.out.println(“我叫：” + num); //打印：我叫：null C.当实例化对象后，被存储在“堆”中； D.当“对象”不被使用(没有任何引用)，并被垃圾回收器回收时被清理； 2).局部变量： A.定义在某个方法、或其它代码块中； B.必须显示初始化，否则不能访问其值； class Student{ void show(){ String name;System.out.println(“我叫：” + name); //编译错误。局部变量必须显示初始化才能访问其值； } } name = “张三”;//OK。可以被赋值。 C.当方法或其它代码块被执行时，基本数据类型的“值”和引用数据类型的“引用”都是存储在“栈”中； D.当方法或代码块执行完毕时，会被立即清理； 四.对象的使用： 1.创建对象使用new关键字；会在堆中分配内存空间； 格式： 类名 变量名 = new 类名();2.一个类可以创建多个对象； 3.每个“对象”的“成员变量”在“堆”中都有一份独立的空间； 每个“对象”的“成员方法”被存储在“方法区”中，多个对象只有一个“方法空间”； 4.对象的“引用(地址)”被存储在“栈”中； 五.方法的形参： 1.可以是“基本数据类型”： 1).调用时，必须传递此类型的“值”； 2).调用时，是将值复制一份到方法内部； 3).在方法内，使用形参接收此值的副本； 4).在方法内，如果更改此值，对原值没有影响； int a = 10;show(a);System.out.println(a);//10---public void show(int n){//n = 10 } n = 20;//对原来的a的值是没有影响的； 2.可以是“引用数据类型”： 1).调用时，必须传递此类型的“引用”； 2).调用时，是将“引用(地址)”复制一份到方法内部； 3).在方法内，使用形参接收此“引用”的副本； 4).在方法内，如果通过此引用更改堆中的值，对原堆中的值将会产生影响； int[] arr = {14,324,435};//arr = 0x2233 show(arr);//show(0x2233)System.out.println(arr[0]);//1000 ----public void show(int[] array){//array = 0x2233 } array[0] = 1000;六.匿名对象： 1.匿名对象：没有名字的对象：new Student();2.匿名对象的两种使用情况： 1).对象调用方法仅仅一次的时候:new Student().show();2).作为实际参数传递:printStudent(new Student());七.封装： 1.直接对外部暴露成员变量是很不安全的，这时可以将成员变量“私有化”，对外提供公有的 get和set方法； 2.封装的好处： 1)隐藏实现细节，提供公共的访问方式 2)提高了代码的复用性 3)提高安全性。 3.封装的原则： 1)将不需要对外提供的内容都隐藏起来。2)把属性隐藏，提供公共方法对其访问。 八.private关键字： 1.是一种“访问修饰符”(将在day10讲到)； Java中一共有四种访问修饰符：从宽到窄：public，protected，(默认)，private 2.用于修饰“成员变量”和“成员方法”； 3.被private修饰的成员，只能在类的内部被其它成员访问。在类外部无法访问； 九.this关键字： 1.每个类都有一个“隐式”的变量：this； 2.它是在实例化对象时，由虚拟机自动赋值的，会被自动赋值为当前对象的“引用”。 所以每个对象内的this变量的值是不同的； 3.this关键字可以调用本对象的“成员属性”、“成员方法”、“构造方法”； 4.以下情况必须显示的使用this： 1).“局部变量”覆盖“成员变量”时，可以使用this显示的访问被覆盖的“成员变量”； 否则访问的是“局部变量”； 2).在一个构造方法中调用本类的其它构造方法；this()或this(实参)； DAY09 一.构造方法： 1.当实例化一个类的对象时，JVM会自动调用本类的一个方法：构造方法； 2.定义类时，可以不定义构造方法，编译器会自动添加一个无参，什么都不做的构造方法； 3.如果类中定义了构造方法，编译器就不会添加任何构造方法了； 4.构造方法的格式要求： 1).构造方法名必须与类名一致； 2).构造方法不能定义“返回值类型”，甚至是void； 3).构造方法不能返回一个具体的值，但内部可以使用return;语句； 注意： 1).以下代码可以编译通过： class Student(){ } public void Student(){ } //普通成员方法，不是构造方法； 2).以下代码不能通过编译： class Student(){ public student(){ } //构造方法必须同类名一致，包括大小写； } 5.一个类中可以定义多个“构造方法”，但每个构造方法的形参列表不能完全相同，叫：构造方法的重载； 6.在一个构造方法中可以调用另一个构造方法，使用this关键字； 7.构造方法可以调用“成员方法”，但“成员方法”不能调用构造方法； 构造方法也可以调用其它构造方法； 二.static关键字： 1.static关键字：静态的，全局的。 2.可以修饰“成员变量”和“成员方法”。被static修饰的成员变量存储在方法区的“静态存储区”，只有 一份拷贝，被多个对象共享； 3.特点： 1).随着类的加载而加载 2).优先于对象存在3).被类的所有对象共享 4).可以通过类名调用，也可以通过对象名调用； 4.static关键字注意事项： 1).在静态方法中是没有this关键字的 2).静态方法只能访问静态的成员变量和静态的成员方法 三.静态变量和成员变量的区别： 1.所属不同 1).静态变量属于类，所以也称为为类变量 2).成员变量属于对象，所以也称为实例变量(对象变量)2.内存中位置不同 1).静态变量存储于方法区的静态区 2).成员变量存储于堆内存 3.内存出现时间不同 1).静态变量随着类的加载而加载，随着类的消失而消失 2).成员变量随着对象的创建而存在，随着对象的消失而消失 4.调用不同 1).静态变量可以通过类名调用，也可以通过对象调用 2).成员变量只能通过对象名调用 DAY10 一.代码块(理解)： 1.普通代码块(类体中)：包含：局部代码块(方法或其它代码块内)2.静态代码块：(类体中)作用： 1.初始化成员变量。执行流程： 1.普通构造代码块：每次实例化此类对象时，会被执行。它会先于“构造方法”被执行； 2.静态代码块：第一次实例化此类对象时； 3.静态代码块-->普通构造代码块-->构造方法： 二.继承(必须掌握)： 1.使用关键字:extends 2.作用：代码重用。为多态提供了前提； 3.this和super的区别： 1).this: 1).在任何类中使用； 2).存储的是本类对象的引用； 3).可以访问本对象的成员变量、成员方法、构造方法； 2).super: 1).在子类中使用； 2).存储的是父类对象的引用； 3).可以访问父类对象的成员变量、成员方法、构造方法； 4.类的初始化过程： 加载class文件 堆中开辟空间 变量的默认初始化 变量的显示初始化 构造代码块初始化 构造方法初始化 成员变量-->构造代码块-->构造方法 5.Java中继承的特点： 1).Java中只能单继承； 2).Java中可以多级继承； 6.继承的好处和弊端： 好处： 1).代码复用 2).为多态提供了前提； 弊端： 1).由于继承，子类对父类产生了依赖； 三.方法重写: 1.在子类中，定义跟父类一模一样的方法，这叫：方法重写； 2.重写的规则： 1).返回值类型、方法名、形参列表：要完全一致； 2).子类的访问修饰符可以跟父类的相同，或更宽； 3.重写的意义： 1).子类保留了父类的方法，具有了自己特有的行为； 4.重写和重载的区别： 1).重写：在子类中定义跟父类一模一样的方法； 2).重载：在一个类中，定义：方法名相同，参数列表不完全相同的方法，叫：重载。跟返回值类型无关； 四.final关键字： 1.可以修饰： 成员变量：表示其变量拥有最终的值，不能被更改，成为“常量”。修饰基本数据类型：表示其值不能被修改。修饰引用数据类型，表示地址不能被修改； 成员方法：表示最终的方法。不能被重写； 类： 表示最终类。不能被继承； 局部变量：表示其值不能改变；区分：基本类型和引用类型； 方法形参：表示其值不能改变；区分：基本类型和引用类型； DAY11 一.多态： 1.父类的引用指向子类的对象； 2.多态前提和体现 1).有继承关系 2).有方法重写 3).有父类引用指向子类对象 3.多态的转型： 1).自动转型：子类的引用转为父类的引用；Person p = new Student();2).强制转型：父类的引用转为它所指向的子类对象的引用；Student stu =(Student)p;3).在进行强制转型前，为保证安全，可以使用instanceof关键字进行判断： if(p instanceof Student){ } Student stu =(Student)p;4.多态的好处： 1).提高了程序的维护性(由继承保证)2).提高了程序的扩展性(由多态保证) 5.多态的弊端： 1).不能访问子类特有功能(可以向下转型)6.多态时的访问规则： 1).总体规则：访问的任何成员父类中必须要有，否则编译错误； 例如： class A{ } class B extends A{ } main(){ } A a = new B();System.out.println(a.n);//编译错误，父类中没有n int n = 20;int num = 10;2).成员变量：如果子、父类中都有，访问的是“父类”的； class A{ } class B extends A { } main(){ } A a = new B();//多态 System.out.println(a.num);//打印10； int num = 20;int num = 10; 普通方法：如果子、父类中都有(重写)，访问的是“子类”的； class A{ } class B extends A{ } main(){ } A a = new B();a.show(); //打印：B-->show()(访问的是子类的show());void show(){ } System.out.println(“B-->show()”);void show(){ } System.out.println(“A-->show()”); 静态方法：如果子、父类中都有(重写)，访问的是“父类”的； 二.抽象类： 1.使用abstract关键字修饰；可以修饰“类”，可以修饰“成员方法”； abstract class A{ } abstract void show();2.“抽象类”的特点： 1).不能被实例化，只能用于被继承； 2).可以包含：成员变量、构造方法、成员方法、抽象方法； 3).可以不包含抽象方法； 3.“抽象方法”的特点： 1).没有方法体；abstract void show();2).必须被子类重写。除非子类也是个抽象类； 3.子类继承抽象类使用关键字：extends，仍然是单继承； 4.一个子类继承 了一个抽象类，必须实现抽象类中所有的抽象方法； 否则子类也必须是抽象的。 例如： abstract class A{ } class B extends A{ } //编译错误。类B不是抽象的，继承类抽象类必须重写抽象类中的所有abstract void show();抽象方法。abstract class B extends A{ } //编译通过。类B没有重写父类中的抽象方法，但类B是抽象的。 5.abstract关键字不能和哪些关键字共存： 1.private:抽象方法就是用来被子类重写的，而私有方法不能被子类重写； 2.final：抽象类和抽象方法就是用来被子类继承和重写的，而fianl类和final方法不能 被继承和重写； 3.static：static修饰的方法在没有任何对象的情况下就会被分配内存空间；而抽象方法 没有方法体，无法分配空间； 三.接口： 1.使用interface关键字定义：只能修饰“类”： interface IA{ } 2.“接口”的特点： 1).不能被实例化，没有构造方法，只能用于子类“实现”； 2).可以包含： A.成员变量(常量)：隐式的定义为：public static final。 例如： interface IA{ } public int num1 = 10; //OK 上述三个关键字中任何一个都可以不写，系统会自动添加； static final int num2 = 20;//OK final int num3 = 30; //OK //OK public final num4 = 40;int num5 = 50; //OK B.抽象方法：隐式的定义为：public abstract。可以省略，系统会自动添加 例如： interface IA{ } void show1(); //OK //OK;public void show2();abstract void show3();//OK;3).接口的功能是：扩展功能； 3.子类实现接口使用关键字：implements 4.一个子类可以同时实现多个接口； interface IA{} interface IB{} class C implements IA,IB{ //OK的。} 5.子类实现接口时，必须重写接口中所有的抽象方法，而且必须是public的--因为 接口中抽象方法的定义隐式的是public的。 例如： interface IA{ } class B implements IA{ void show(){ } //编译错误。父接口的show()隐式的为public的，子类重写时void show();必须是public的； } 5.接口编译后一样会生成.class文件。 四.多态的形式： 1.父类的多态； 2.抽象类多态； 3.接口多态； 五.类与类，类与接口，接口与接口的关系： 1.类与类：继承关系，关键字：extends，只能单继承，但是可以多层继承 2.类与接口：实现关系，关键字：implements，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口 3.接口与接口：继承关系，关键字：extends，可以单继承，也可以多继承 例如： interface IA{} interface IB{} interface IC extends IA,IB{} //OK的 六.抽象类和接口的区别： 1.成员区别 1).抽象类 变量,常量;有抽象方法;抽象方法,非抽象方法 七.2).接口 常量;抽象方法 2.关系区别 1).类与类 继承，单继承 2).类与接口 实现，单实现，多实现 3).接口与接口 继承，单继承，多继承 3.设计理念区别 1).抽象类 被继承体现的是：”is a”的关系。共性功能 2).接口 被实现体现的是：”like a”的关系。扩展功能 一.类名作为形参： 1.实参可以是： 1).此类对象的引用;2).null;3).此类子类对象的引用； 二.抽象类作为形参： 1.实参可以是： 1).此类子类对象的引用； 2).null; 三.接口作为形参： 1.实参可以是： 1).此接口子类对象的引用； 2).null; 四.类名作为返回值： 1.可以返回的类型： 1).此类对象的引用； 2).null; 3).此类子类对象的引用； 2.可以用什么类型接收： 1).使用此类类型； 2).不能使用某个子类类型接收； 五.抽象类作为返回值： 1.可以返回的类型： 1).null;2).此类子类对象的引用； 2.可以用什么类型接收： 1).使用此类类型；(多态)2).不能使用某个子类类型接收； 六.接口作为返回值： 1.可以返回的类型： 1).null;2).此接口子类对象的引用； 2.可以用什么类型接收： 1).使用此接口类型；(多态)2).不能使用某个子类类型接收； DAY12 一.包： 1.定义包使用关键字：package； 1).注意事项： A.package语句必须是程序的第一条可执行的代码 B.package语句在一个java文件中只能有一个 C.如果没有package，默认表示无包名 2.导入包使用关键字：import； 1).注意事项： A.导入到最终的类； B.可以使用通配符：*，只统配包下的类，不包括子包下的其它类； C.在一个类文件中，可以有多条import语句； D.import语句必须在package语句之后，在定义类之前； 3.package,import,class有没有顺序关系？ 有：package-->import-->class 二.访问修饰符： 1.用于限定“类”和“成员”被其它包下的其它类访问的； 2.四种访问修饰符： 1).public(公有)：可以修饰类、成员。可以被任何包下的其它类访问； 2).protected(保护)：可以修饰成员。可以被同包下的其它类访问。如果在包外 只能被子类访问； 3).(默认)：可以修饰类、成员。只能被包内的其它类访问； 4).private(私有)：可以修饰成员。只能被类中的其它方法访问； 3.类及成员可用的修饰符： 1).类： 默认，public，final，abstract 我们自己定义：public居多 2).成员变量： 四种权限修饰符均可,final,static 我们自己定义：private居多 3).构造方法： 四种权限修饰符均可,其他不可 我们自己定义：public 居多 4).成员方法： 四种权限修饰符均可，fianl,static,abstract 我们自己定义：public居多 三.内部类： 1.成员内部类： 1).定义在类体中，作为类的成员； 2).可以使用同类“成员方法”相同的修饰符； 2.局部内部类： 1).定义在某个方法或代码块内部； 2).不能使用“访问修饰符”，不能使用static修饰符；可以使用final和abstract 3).注意：局部内部类访问“局部变量”，要求局部变量必须是final的(常量)；（重点） 3.匿名内部类： 1).就是内部类的简化写法。2).前提：存在一个类或者接口 这里的类可以是具体类也可以是抽象类。 3).格式： new 类名或者接口名(){重写方法;} 4).本质： 是一个继承了类或者实现了接口的子类匿名对象 DAY14 一.Object类： 1.所有引用数据类型(包括类库中的类，自定义类，数组)的超类； 2.定义在java.lang包，使用时不需要导包； 3.常用方法： public class Object{ public Object(){ 内存的操作； } public int hashCode(){ //功能：用于哈希表结构的键值 //默认实现：将此对象的地址转换为int值返回； //此方法建议子类重写； } public final Class getClass(){ //功能：获取此对象的Class对象，在day27讲解 //此方法不能被子类重写 } public String toString(){ //功能：返回此对象的字符串表现形式； //默认实现：全名限定的类名 + @ + hashCode(无意义)//此方法建议子类重写； } public boolean equals(Object obj){ //功能：将当前对象与参数对象进行比较 //默认实现：比较地址(跟==的结果是一样的)//此方法建议子类重写； } protected void finalize(){ //功能：当前对象在被垃圾回收器回收前，由垃圾回收器自动调用的方法。一般用于做些释放 //默认实现：无 //此方法根据需要由子类重写(一般我们不用)} } protected Object clone(){ } //功能：复制此对象的副本； //默认实现：本地方法 //一般子类无需重写； -- 二.java.lang.String类： 1.一个“字符串”对象； 2.一个“引用数据类型”； 3.使用方式： String s1 = “abc”;(常用、存储的是常量池中的地址)或： String s1 = new String(“abc”);(存储的是堆中的地址)(在内存中创建了两个对象：1.常量池：“abc”； class Student(extends Object){ } //默认就拥有了Object类中可以继承的方法； 2.堆：new String()) 4.特点：其“值”的内容不能改变(地址可以改变)； String str = “你好”;str = “Java”;//原值被丢弃，存储了新的地址； 5.常见面试题： String s1 = “abc”; String s2 = “abc”;System.out.println(s1 == s2);//true-------- String s1 = “Hello”;String s2 = “World”;String s3 = “HelloWorld”;String s4 = “Hello” + “World”;String s5 = s1 + s2;String s6 = “Hello” + s2;String s7 = s1 + “World”;String s8 = new String(“Hello”);System.out.println(s3 == s4);//true System.out.println(s3 == s5);//false System.out.println(s3 == s6);//false System.out.println(s3 == s7);//false System.out.println(s1 == s8);//false;6.构造方法： public String()：构造一个空字符串。效果同String str = “";public String(byte[] bytes):使用一个byte[]数组构造一个字符串； public String(byte[] bytes,int offset,int length)：使用byte[]数组的一部分构造一个字符串； public String(char[] value)：使用一个字符数组构造一个字符串； public String(char[] value,int offset,int count)：使用字符数组的一部分构造一个字符串； public String(String original)：使用一个字符串构造一个字符串； 7.常用方法：----注意：以下方法返回String的，都是生成一个新字符串，原字符串不变； 1).判断功能： boolean equals(Object obj):重写父类的方法。与参数字符串比较，如果包含一样的字符序列则返回true，否则返回false; boolean equalsIgnoreCase(String str):作用与equals()相同；但此方法不区分大小写； boolean contains(String str):判断是否包含参数字符串； boolean startsWith(String str):判断字符串是否以参数字符串开头； boolean endsWith(String str):判断字符串是否以参数字符串结尾； boolean isEmpty():判断字符串是否是”空字符串“； ---- String s1 = ”“;String s2 = new String();String s3 = new String(”“);String s4 = null;String s5 = ”“;String s6;System.out.println(s1.isEmpty());System.out.println(s2.isEmpty());System.out.println(s3.isEmpty());// System.out.println(s4.isEmpty()); System.out.println(s1.equals(s2));System.out.println(s2.equals(s3));System.out.println(s3.equals(s1));System.out.println(s1 == s2);System.out.println(s2 == s3);System.out.println(s1 == s3);System.out.println(s1 == s5); System.out.println(s4 == s6);-----2).获取功能： int length()：获取此字符串内部的字符数量。(区分数组的length属性)char charAt(int index)：获取此字符串中index位置的字符char;int indexOf(int ch)：从左向右查找，获取字符ch在字符串中第一次出现的位置。如果不包含，则返回：false int indexOf(String str)：获取字符串str在此字符串中第一次出现的位置。int indexOf(int ch,int fromIndex)：从fromIndex位置开始，查找字符ch。int indexOf(String str,int fromIndex)：从fromIndex位置开始，查找str。 String substring(int start)：从start(包含)开始，截取到此字符串的末尾；返回一个新字符串，原字符串不变； String substring(int start,int end)：从start(包含)到end(不包含)截取字符串；返回一个新字符串，原字符串不变； 3).转换功能： byte[] getBytes()：将字符串转换为一个byte[]数组。char[] toCharArray()：将字符串转换为一个char[]数组； static String valueOf(char[] chs)：静态方法，将一个char[]数组转换为一个String static String valueOf(int i)：静态方法，将一个int转换为一个String String toLowerCase()：转换为小写； String toUpperCase()：转换为大写； String concat(String str)：将参数字符串添加到本字符串的末尾。 4).替换功能： String replace(char old,char new)：使用new字符替换本字符串中的所有old字符； String replace(String old,String new)：使用new字符串替换本字符串中的所有old字符串； 5).其它功能： String trim():去掉字符串两边的空格；不包括中间的。 int compareTo(String str)：重写Comparable接口的方法。按Unicode编码表的顺序与参数字符串比较； System.out.println(”a“.compareTo(”b“));//-1 System.out.println(”a“.compareTo(”a“));//0 System.out.println(”b“.compareTo(”a“));//1 int compareToIgnoreCase(String str):不区分大小写的比较； DAY15 一.StringBuffer类： 1.String的缓冲池类。 2.String和StringBuffer的区别： 1).String:其”值“不可变； 2).StringBuffer:其”值"可变； 当我们多次进行字符串的拼接等操作时，使用String会产生大量的垃圾空间。建议使用此类； 2.构造方法： public StringBuffer()：初始容量16 public StringBuffer(int capacity)：初始容量capacity public StringBuffer(String str):使用String构造一个StringBuffer。 3.添加功能： public StringBuffer append(String str)：及各种重载的方法。将任何类型的参数添加到末尾； public StringBuffer insert(int offset,String str)：将一个String插入到offset位置。原位置上的字符依次后移； 4.删除功能： public StringBuffer deleteCharAt(int index)：删除index位置上的字符 public StringBuffer delete(int start,int end)：删除start到end-1处的所有字符； 5.替换功能： public StringBuffer replace(int start,int end,String str)：将start到end处的所有字符替换为str;6.反转功能： public StringBuffer reverse()：反转内部字符串； 7.截取功能： public String substring(int start)：截取从start到结尾，返回一个新字符串； public String substring(int start,int end)：截取从start到end-1处的所有字符； 二.StringBuffer类和StringBuilder类的区别： 1.StringBuffer是线程安全的； 2.StringBuilder是线程不安全的； 三.Arrays类： 1.对数组操作的类，没有构造方法，内部包含了大量静态的工具方法； 2.常用方法： 1).public static String toString(int[] a)：将int[]数组转换为String的表示形式； 2).public static void sort(int[] a)：升序排序int[]数组； 3).public static int binarySearch(int[] a,int key)：二分查找int[]数组中的key值； 四.包装类： 基本数据类型 byte short int long char float 包装类型 Byte Short Integer Long Character Float Double Boolean double boolean java重要知识点总结如下： 1，抽象，封装，继承，多态是面向对象程序设计中得四个特点.2，面向对象得软件开发大体分为：面向对象的分析，面向对象的设计，面向对象的实现.可概括为如下过程：分析用户需求，从问题中抽取对象模型;细化模型，设计类，包括类的属性和类间的 相互关系，同时观察是否有可以直接引用的已有类或部件;选定一种面向对象的编程语言，具体编码实现 上一阶段类的设计，并在开发过程中引入测试，完善整个解决方案.3，面向对象程序设计方法的优点是：可重用性，可扩展性，可管理性.4，类的定义：class前的修饰符分为访问控制符和非访问控制符两大类.访问控制符包括public和private.非访问控制符包括abstract(抽象)，final(最终).5，final类是最终类，是不能有子类的类.abstract和final不能同时修饰一个类，因为抽象类本身没有具体对象，需要派生出子类后在创建子类的对象.而最终类不可能有子类.6，创建对象的格式为： 类名 对象名=new 构造方法(参数);注意前面是类名后面是构造方法.注意构造方法没有返回类型，也不能写void，主要用于完成类对象的初始化工作，一般不能直接由编程 直接调用，而是用new运算符来调用.7，如果class前面由public修饰符，则默认构造方法的前面也应该有public修饰符.8，类中有static修饰的域或方法，可用类名或对象名访问，否则只能用对象名访问.9，修饰域的访问控制符可以是：public，private，protected，private protected.非访问控制符可以是： static，final，volatile(易失域) 10，类变量的最本质的特点是：他们是类的域，不属于任何一个类的具体对象实例.不是保存在某个对象实例的内存空间中，而是保存在类的内存区域的公共存储单元中.11，局部变量是在方法体内声明的，只有当方法被调用时他们才存在，因而只能在本方法内使用，不存在访问控制符，也不能声明为静态变量(static)，但可以声明为final变量.局部变量必须初始化.12，修饰方法的访问控制符可以是：public，private，protected，private protected，修饰方法的非访问控制符可以是：static，final，abstract，native(本地方法)，synchronized(同步方法)。 13，用static修饰的变量或方法都为类成员，类成员可以用类名或实例名访问，实例成员只能用实例名来访问。 14，如果一个类中含有抽象方法，则此类必须为抽象类，如果抽象类的子类不为抽象类，则子类必须实现父类的所有抽象方法。抽象方法不能用静态方法和最终方法。抽想方法只有函数头的声明，而用分号来替代方法体，没有大括号。如abstract void abstractmethod(); 15，this变量用在一个方法的内部，指向当前对象，当前对象指的是调用当前正在执行的方法的那个对象。super变量是直接指向父类的构造方法，用来引用父类种的变量和方法。(由于他们指的是对象，所以不能通过它来引用类变量和类方法) 16，如果要引用一个包中的多个类，可以用星号来代替。使用星号只能表示本层次的所有类，而不包括子层次下的类。所以经常需要用两条语句来引入两个层次的类：import java.awt.*;import java.awt.event.*; 17，访问修饰符： --类中限定为public的成员可以被所有的类访问。 --类中先定位private的成员只能被这个类本身访问。同一个类的不同对象可以访问对方的private域变量或调用对方的域方法，这是因为访问保护控制在类的级别上，而不是对象的级别上。 --类中限定为protected的成员可以被这个类本身，它的子类(包括同一个包中和不同包中的子类)，以及同一个包中的其他类访问。 --用private protected修饰的成员可以被该类本身访问，也可以被该类的所有子类访问。 --默认访问控制符规定只能被同一个包中的类访问和引用，而不能被其他包的类访问。即他的访问权限是friendly。 18，注意： ----abstract和private，static，final，native不能并列修饰同一个方法。 ----abstract类中不能有private修饰的域和方法 ----static方法不能处理非static的域。 19，重载方法的参数必须不同，或者是参数个数不同，或者是参数类型不同。重载的多个方法必须返回相同的数据类型。 20，在java中，一个类获取某一接口定义的功能并不是通过直接继承这个接口的属性和方法来实现的。因为接口中的属性都是常量，接口的方法都是没有方法体的抽象方法，没有具体定义操作。 原文[2007年03月25日 星期日 上午 03:04] Java发展到现在，按应用来分主要分为三大块：J2SE,J2ME和J2EE。这三块相互补充，应用范围不同。 J2SE就是Java2的标准版，主要用于桌面应用软件的编程； J2ME主要应用于嵌入是系统开发，如手机和PDA的编程； J2EE是Java2的企业版，主要用于分布式的网络程序的开发，如电子商务网站和ERP系统。先学习j2se 要学习j2ee就要先学习j2se，刚开始学习j2se先建议不要使用IDE，然后渐渐的过渡到使用IDE开发，毕竟用它方便嘛。学习j2se推荐两本书，《java2核心技术一二卷》，《java编程思想》，《java模式》。其中《java编程思想》要研读，精读。这一段时间是基本功学习，时间会很长，也可能很短，这要看学习者自身水平而定。 不要被IDE纠缠 在学习java和j2ee过程中，你会遇到五花八门的IDE，不要被他们迷惑，学JAVA的时候，要学语言本身的东西，不要太在意IDE的附加功能，JAVA编程在不同IDE之间的转换是很容易的，过于的在意IDE的功能反而容易耽误对语言本身的理解。目前流行的IDE有jbuilder，eclipse和eclipse的加强版WSAD。用好其中一个就可以了，推荐从eclipse入手j2ee。因为Jbuilder更适合于写j2se程序。 选择和学习服务器使用配置 当你有了j2se和IDE的经验时，可以开始j2ee的学习了，web服务器：tomcat，勿庸置疑，tomcat为学习web服务首选。而应用服务器目前主要有三个：jboss、weblogic、websphere。有很多项目开始采用jboss，并且有大量的公司开始做websphere或weblogic向jboss应用服务器的移植（节省成本），这里要说的是，学习tomcat和jboss我认为是首选，也是最容易上手的。学习服务器使用配置最好去询问有经验的人（有条件的话），因为他们或许一句话就能解决问题，你自己上网摸索可能要一两天（我就干过这种傻事），我们应该把主要时间放在学习原理和理论上，一项特定技术的使用永远代替不了一个人的知识和学问。 学习web知识 如果你是在做电子商务网站等时，你可能要充当几个角色，这是你还要学习： html，可能要用到dreamwave等IDE。 Javascript，学会简单的数据校验，数据联动显示等等 J2eeAPI学习 学习j2eeAPI和学习服务器应该是一个迭代的过程。 先学习jsp和servlet编程，这方面的书很多，我建立看oreilly公司的两本《jsp设计》和《java servlet编程》，oreilly出的书总是那本优秀，不得不佩服。 学习jdbc数据库编程，j2ee项目大多都是MIS系统，访问数据库是核心。这本应属于j2se学习中，这里拿出来强调一下。 学习jndi api，它和学习ejb可以结合起来。 学习ejb api，推荐书《精通ejb》 经过上面的这些的学习，大概可以对付一般的应用了。 有人说跟着sun公司的《j2ee tutorial》一路学下来，当然也可以。 学习ejb设计模式和看代码（最重要） 设计模式是练内功，其重要性可以这么说吧，如果你不会用设计模式的话，你将写出一堆使用了ejb的垃圾，有慢又是一堆bug，其结果不如不用ejb实现（ejb不等于j2ee） 无论学习什么语言，都应该看大量代码，你看的代码量不到一定数量，是学不好j2ee的目前有很多开源的工程可以作为教材： jive论坛 petstore sun公司 dune sun公司 等等，研读一个，并把它用到自己的工程中来。 J2ee其他学习 当你渐渐对j2ee了解到一定深度时，你要开始关注当前领域中的一些技术变化，J2ee是一块百家争鸣的领域，大家都在这里提出自己的解决方案，例如structs，hiberate，ofbiz等等，学习这些东西要你的项目和目标而定，预先补充一下未尝不可，但不用涉及太深，毕竟学习原理和理论是最最重要的事。 目前常见j2eeAPI JavaServer Pages(JSP)技术1.2 Java Servlet技术2.3 JDBC API 2.0 Java XML处理API(JAXP)1.1 Enterprise JavaBeans技术2.0 Java消息服务(JMS)1.0 Java命名目录接口(JNDI)1.2 Java事务API(JTA)1.0 JavaMail API 1.2 JavaBeans激活架构(JAF)1.0 J2EE连接器体系结构(JCA)1.0 Java认证和授权服务(JAAS)1.0 学习上面的某些API要以你的项目而定，了解所有他们总之是有好处的上面印证了大家说的一句话，java语言本身不难学，但是技术太多，所以学java很费劲。回想一下，基本上每个初学者，在刚学习java的时候可能都会问别人这么一句话，你怎么知道的哪个方法(api)在哪个包里的？呵呵，无他，唯手熟尔。 2008年10月29日 星期三 下午 9:29第三篇：JAVA课程总结
第四篇：java知识点小结
第五篇：java个人小结（范文模版）
点击咨询 