第一篇：学习JAVA程序课程心得
《Java项目实战》心得
在学习JAVA面像对象语言中这是一门以网络技术、多平台操作、UML及其建模工具使用、JSP技术等为一体的，一门比较热门的编程语言。
我在本课程中不到了不少的新知识，例如数据库的多表查询、多表添加、权限等功能。在学习JAVA中我们跟着老师将理论和实践将有机的结合在一起。循序渐进的掌握JAVA的一些基础知识和实际应用。
JAVA是以做一个项目的来考核每一位同学，是以团队开发为主这样让同学进入公司时就有团队的意识。为了完整个项目是这个小组必需以一个文档为主这样可以让项目很好的进行。
JAVA是以JDBC连接数据库的这是一种新的技术。在JAVA中数据连接可创建一类这样可以每次连接数据库是调用这个类方便了程序的开发。
怎么学习Java开始的两年我学JAVA就是拿书看，练习书上的例子，但是一直没有好的效果。后来因为项目需要开始正式使用JAVA开发，我发现以前练习的东西都忘光了，所以不得不在拿起书看。也就是基本上做了无用功了。现在想来因为大部分是抄来的，不怎么动脑子，所以不清楚为什么要这样。所以我强烈建议你学习的时候给自己设定一个假想的项目目标，做一个东西出来，网页也好，application也好，这样你才会快速地学习。
对java有了一定地感觉以后，你在去看他的DOCUMENT，看他的源码，我建议你从低版本的JAVA源码看起，因为他类少，看起来容易懂。然后你就会知道自己以前编码的东西那些是很幼稚的，是可以用一两句就能搞定的。
如果你已经稍微有了些感觉，如果觉得合适也可以考虑参加一些培训，毕竟比自学要轻松些，另外还可以学到别人的一些经验，比如：清软Java培训，一些学员反应不错的，也建议你们多了解一下其它的培训机构。
如何解决问题,学习的过程中不可避免的遇到问题，这些问题有的只是一个符号错了，一个括号少了，这类的问题在他的文档，或者一般的网站上就能够找到，尤其是初学者的问题，不会是很难的问题，在你之前已经无数人问过了，不要害怕提问，但是这个问题最好是你找不到答案的时候去提。有的时候人们觉得你这个问题到处都有，是你个人太懒不去找的原因而没有解决，这样不愿意回答。
总而言之我在JAVA中学习了团队精神和一些面像对象的语言编程。
05软件 王国辉
第二篇：JAVA学习中的心得和小程序
最初接触JAVA实在大一的时候，当时想着去考计算机等级考试，那个时候就对JACA有一点兴趣。但幸运的是，我当时的公选课选的是C语言而且专业课程里面也开了C语言这门课程所以当时选择了C语言。而现在接触了JACA，才真正的发现，不同语言不同的魅力！
刚一开始学习java时，我就已经学习过C语言，不过C语言学的不是很好，所以开始看到java的时候我很反感，看着源代码，都不知道失什么意思。看书的时候一看到源代码就头疼，因为根本看不懂。那段时间根本就是一无所获，在图书馆借了一本书，关java的语法特性，与别的语言相比的优点，什么跨平台，源代码公开，什么write once run anywhere，能说得头头是道，可是一到具体的问题，想写一些具体的东西，问题就都来了，根本不知道该怎么下手。渐渐的时间过去了，一点进展都没有，而后又同学经常来宿舍跟我讲解，我很感谢他。慢慢的我也理解了一些知识。从他那里，我认识到，JAVA是一门计算机语言，是人类发明的语言，应该比人类语言更容易学习，只要你有一种必胜学习JAVA心态就可以成功。JAVA学习中，首先要做到课前、课后复习及预习，要时时保持一个清醒的头脑；多和同学沟通；互相学习；取长补短；在学习中做到帮助他人或他人帮助自己。学习java，的确要学习的东西很多，就像同学提到的。Java不像.net一家独大，Java的繁盛在于开源社区的庞大，这也带来了分支太多的问题，怎样选择一条好的学习路线，对于初学者来说，的确是一件很迷茫的事。其实不管
java东西再多，总有规律可循。对于学习java基础的经验就是多做、多思考，基础知识的学习不能不求甚解，要追本溯源，弄清问题的本质。C的入门学习过程是比较痛苦的，你要学好需要一定的努力，但是他有一个好处，相对JAVA来说比较集中，不会出现JAVA里面这么多差异。java的学习过程开始比较容易入手，更容易学习。当然现在C#也可以。java还有一个优势就是在移动设备的开发，所有的java应用版本不同，但是语法一致。java的跨平台特性使得学习他让我们可以在不同的场合下使用。而恰恰就是它的种种跨平台性让我非常感兴趣。我们的社会发展现在越来越集中化，智能化，所有的东西手机，电脑都可以解决，而终端设备之间的通讯就是促进发展的桥梁，JACA具有非常优越的跨平台性，基本的移动终端都可以利用JACA平台进行开发，学习。
当然学习的过程中不可避免的遇到问题，这些问题有的只是一个符号错了，一个括号少了，但只要仔细查找就会发现不会是很难的问题，最最重要的是要学会询问别人，有这样一个笑话：一个程序员向上帝许愿希望他有生之年可以编写出一个完美的程序结果——程序员最后长生不老！虽然只是一个笑话但是也可以反映出世上没有绝对完美的程序，所以学会询问别人是最最有效的方法。
编写一个程序，实现1-100的累加。
public class LeiJia { public static void main(String args[]){
int sum=0;
for(int i=1;i<=100;i++){
sum=sum+i;}
System.out.println(“sum=”+sum);} }
这是一个小程序对我学习有很大的启发，这个程序是利用循环FOR语句实现了从1到100的数字的累加运算，对比C语言不难发现其实很多的语法应用都是差不多的但JACA却具有更多的表现形式和不同的书写规则，但就是多种的表现形式才能够使它具有这种跨平台的多兼容性。
在我所学的语言当中，我自认为JAVA是一门比较强大的面向对象的编程语言，不仅仅因为它的跨平台性，更多的是因为它的灵活多变和实用性较强，可以说比较的经典和强悍。所以学好java语言有很大的用处，在不断地接触JAVA中我们更多学到的是不懂就问和自己应该尽自己的全力去尝试，哪怕失败，只要自己尽自己的全力，和身边同学一起探讨而不是抄袭，团结合作，发挥团队意识，最后在自己的努力下，终于运行成功，这种成就感美不可言，心情愉悦至极。
第三篇：学习JAVA心得
学习JAVA心得(2007-07-10 17:44:52)
经常看到有人问怎么学JAVA，无数的问题其实都已经是讨论很多编了，我学习JAVA5年，真正觉得有感觉是2003的时候，这么长时间以来有一些想法，写出来大家共同探讨：
1.为什么要学JAVA?
首要的原因当然是为了生活，找份好工作，现在放眼望去，知名公司只会要求两种语言－c/c++，当然包括后来的NET，和JAVA。其他一些公司可能会要其他的语言，但最终的结果是你会回到这两类上。前者的入门学习过程是比较痛苦的，你要学好需要一定的努力，但是他有一个好处，相对JAVA来说比较集中，不会出现JAVA里面这么多差异。java的学习过程开始比较容易入手，更容易学习。当然现在C#也可以。java还有一个优势就是在移动设备的开发，所有的java应用版本不同，但是语法一致。java的跨平台特性使得学习他让我们可以在不同的场合下使用。
2.怎么学习java
开始的两年我学JAVA就是拿书看，练习书上的例子，但是一直没有好的效果。后来因为项目需要开始正式使用JAVA开发，我发现以前练习的东西都忘光了，所以不得不在拿起书看。也就是基本上做了无用功了。现在想来因为大部分是抄来的，不怎么动脑子，所以不清楚为什么要这样。所以我强烈建议你学习的时候给自己设定一个假想的项目目标，做一个东西出来，网页也好，application也好，这样你才会快速地学习。
对java有了一定地感觉以后，你在去看他的DOCUMENT，看他的源码，我建议你从低版本的JAVA源码看起，因为他类少，看起来容易懂。然后你就会知道自己以前编码的东西那些是很幼稚的，是可以用一两句就能搞定的。
3.如何解决问题
学习的过程中不可避免的遇到问题，这些问题有的只是一个符号错了，一个括号少了，这类的问题在他的文档，或者一般的网站上就能够找到，尤其是初学者的问题，不会是很难的问题，在你之前已经无数人问过了，不要害怕提问，但是这个问题最好是你找不到答案的时候去提。有的时候人们觉得你这个问题到处都有，是你个人太懒不去找的原因而没有解决，这样不愿意回答。
等你走出了这个阶段，这个时候在有问题可能就是比较难一些的，这个时候在一般的网站上应该是难以找到结果的，我建议你英文够好的话直接上国外的网站，包括JAVA自己的网站。如果一般呢，可以到IBM的中文网站上去，这些地方有很多一系列问题的解决方法，那上面提供的例子不管是书写格式还是正确性都是比较好的，为你养成良好的习惯有很大的帮助。
4.其他UML等的学习
数据结构要不要学，UML要不要学，这些问题我觉得应人而异，你满足于做一般的程序员，完全可以不学，现在商业软件用到的都是成熟的技术，所有你遇到的问题，除非bug，无法解决的，在网上都能找到现成的代码，完全可以支持你完成工作。
但是如果你把编程当作一种乐趣的话，还是要学习的，用UML语言之后，你会发现编码的速度会更快，因为在这个过程中你理清了思路，通过使用工具，你可以要编码的模块分到最细，完成这部分工作以后，没一个模块的代码写起来会顺手很多，因为逻辑明确。数据结构对你写一些小的算法有帮助。而且通过比较高层次来观察整个系统，你对程序的把握会越
来越有信心。
编程是一种乐趣，只有你觉得他有乐趣的时候你才会用更多的热情去学习，现在java的书很多，我觉得国内一般人写的不要看，还是原版的或者原版翻译的比较好
第四篇：Java心得
JAVA心得
1.Only public & abstract are permitted for interface.2.Only public, abstract & final are permitted for class.3.main方法作为程序的入口,其modifier必须是 public static void
且必须有一个类型为String的数组参数, 否则不能运行.4.非static内部类中不能有static的域和方法.static的域和方法只能存在于顶级类中或者是static嵌套类中.5.interface 中定义的变量都是public static final的, 且必须赋值.6.如果试图在方法中更改final变量的值, 则编译不能通过;
7.两个int类型的数相除其结果也是int型且不会四舍五入而是直接截取整数部分.一个浮点型数字与整数相除其结果是浮点型.8.try{}块后面必须有catch(Exception){}或者finally{}
try{return a;}
finally{
}
执行顺序是return语句返回结果之前 先执行finally{}再返回结果.9.子类override父类方法是可见修饰符级别不能降低,例如父类是protected
子类可以是protected和public 但不可以是default和private.如果子类有个方法与父类同名且参数类型也相同,则必须返回值类型也相同 否则不能编译.Java允许方法名与类名相同, IDE会给出警告但可以编译和运行.
第五篇：JAVA课程总结
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
点击咨询 