JAVA学习笔记基础知识.docx
《JAVA学习笔记基础知识.docx》由会员分享，可在线阅读，更多相关《JAVA学习笔记基础知识.docx（22页珍藏版）》请在冰点文库上搜索。
JAVA学习笔记基础知识
JDK:
可以开发编译与运行JAVA程序的工具。
JRE:
可以运行JAVA程序的工具。
JVM:
java虚拟机，是在一台计算机上由硬件或软件模拟的计算机。
它的功能是读取并处理编译过的字节码文件（class文件）
环境变量：
path:
JDK中bin目录
classpath:
.
java_home:
JDK的路径
home_path:
JDK的路径
开始—>运行àcmdàjava–version
JavaSEàOracleàJavaEE
Java版本：
JavaSE:
J2SE
JavaEE:
J2EE
JavaME:
J2ME
JAVA文件类型：
.java文件：
源文件，保存JAVA源代码，文本文件。
.class文件：
类文件，保存字节码，二进制文件。
使用javac命令将java文件编译为class文件：
javac文件名.java（DOS文件名不区分大小写）
使用java命令运行class文件：
java类名（类名区分大小写）
1.在一个JAVA文件中可以有多个类
2.在一个JAVA文件中只能有一个公有（public）的类
3.公有的类的名字必须与文件名一样（包括大小写）
4.JAVA代码区分大小写
5.main（）是程序的入口
6.通常情况下main（）应该放在公有的类中
7.每句代码后面用分号表示结束
8.不允许在代码中直接书写中文的标点
注释：
1.单行注释:
//
2.多行注释:
/*注释内容*/
3.文档注释
第三章
数据类型：
有两种。
基本数据类型（简单数据类型），引用数据类型。
基本数据类型：
有8种
一．数字类型：
整型，浮点型
1.整型:
表示十进制，八进制（0开头），十六进制（用0x或0X头），在JAVA中没有无符号的数字
a）byte：
字节类型，1个字节-27—27-1
b）short：
短整型，2个字节-215—215-1
c）int：
整型，4个字节在JAVA中整数默认为int，-231—231-1
d）long：
长整型，8个字节,-263—263-1,在数字后加l或L
2.浮点型：
a）float：
单精度，在数字后面加F或f。
4个字节
b）double：
双精度，在JAVA中一个浮点型的数字默认为double类型。
8个字节
3.字符类型：
char,字符类型的值要放在一对单引号中，单引号中必须只有一个字符（一个字母，数字，‘\u0000’）。
在JAVA中所有的字符都占两个字节。
4.boolean类型：
值true（真）或false（假）。
boolean类型的值不能与其它类型进行转换。
变量：
强类型的语言。
1.格式：
数据类型变量名;
2.JAVA中标识符命名的规则：
a）标识符由字母，下划线，数字，美元符（$）组成。
b）不能用数字开头。
c）不能使用关键字（在JAVA中关键字都为小写）。
注意：
当变量没有赋值时不能使用。
常量：
只能赋值一次的变量。
使用final关键字。
运算符：
1.算术运算符：
+，-，*，/，%（取余数），++（自增），--（自减）。
JAVA中混合运算的结果的类型，根据运算元素的精度与长度决定。
2.关系运算符：
>,>=,<,<=,==（判断是否相等）,!
=（不等于），结果一定是boolean类型。
3.赋值运算符：
=,将右边值（结果）赋给左边的变量。
4.字符串连接符：
+
5.逻辑运算符：
逻辑与（&），逻辑或（|）,短路与（&&，当第一个表达式为false时，不执行第二个表达式），短路或（||，当第一个表达式为true时，不执行第二个表达式），逻辑非（！
）
与运算
表达式1
表达式2
结果
T
T
T
T
F
F
F
T
F
F
F
F
或运算
表达式1
表达式2
结果
T
T
T
T
F
T
F
T
T
F
F
F
6.扩展运算符：
+=,-=,*=,/=,%=,可以将结果的类型自动转换为接收的类型
7.三目运算符（三元运算符）：
x?
y:
z。
当x为true时，返回y的值，当x为false时，返回z的值。
基本数据类型的类型转换：
1.小的可以直接赋给大的。
2.大的必须强转才能赋给小的。
3.boolean不能转换为其它类型。
4.byte,short,char进行算术时结果会自动转换为int
流程控制：
顺序结构，选择结构，循环结构
一．选择结构
if语句
格式：
if（条件）{
代码;
}
if（条件）{
代码;
}else{
代码;
}
if（条件）{
代码;
}elseif（条件）{
代码;
}elseif（条件）{
代码;
}else{
代码;
}
1.if语句中的条件的结果必须为boolean类型的值
2.if语句的大括号可以省略，但省略后if的作用范围只在if后面的一行代码。
3.一个if语句中可以出现0个或1个else
4.else语句必须出现在if语句的最后
5.一个if语句中可以出现0个或多个elseif
6.当匹配分支后，其它分支将不再执行。
switch语句：
switch语句只能判断是否相等。
switch（变量）{
case值:
代码;
[break;]
case值:
代码;
[break;]
……
default:
代码;
[break;]
}
1.switch语句中变量的类型必须为int,byte,short,char,枚举（JDK1.5）,String（JDK1.7）
2.case后面的值不能重复
3.case后面只能放常量或字面值
4.当switch匹配一个分支后，将从这个分支开始执行后面所有的分支直接switch语句的结束，或遇到第一个break为止。
5.switch语句会先执行所有的case语句，当所有的case语句都没匹配到时，执行default
6.default语句不一定出现在switch语句的最后
switch中没有break时是什么情况
循环结构：
while循环：
当循环次数不确定时使用while循环
while（条件）{//条件为布尔类型
循环体;
}
先判断，再循环
Math.random（）：
随机数方法，返回一个大于或等于0但一定小于1的double类型的值
do…while循环：
do{
循环体;
}while（条件）
先循环，再判断
for循环：
当确定循环次数时使用for循环。
for循环中三部分都可以省略。
for（循环变量初始化;循环条件;循环变量自增/自减）{
循环体;
}
break:
必须放在switch语句或循环语句中。
放在循环中的作用：
结束所在循环。
带标签的break：
结束标签后面的循环。
continue:
只能出现在循环语句中。
结束本次循环，使用循环直接进入下一次循环。
带标签的continue：
使标签后面的循环结束本次循环，直接进入下一次循环。
数组：
多个相同数据类型的集合。
在JAVA中所有的数组都是引用数据类型，但数组中每个元素可以为基本数据类型
一维数组：
声明数组：
不能写数组的长度
数据类型[]数组名;
数据类型数组名[];
int[10]a;//错误。
创建数组：
必须指定数组的长度。
当确定了数组的长度后，数组的长度便不能修改。
数组的长度可以为0，但不能为负数。
int[]array={1,2,3,4,5,6,7,8,9};java习惯
intarray1[]=newint[10];c习惯
int[]array2=newint[]{1,2,3,4,5};
i:
100
array:
引用
array[0]:
10
array[1]:
22
array[2]:
31
访问数组的元素：
通过下标可以访问数组的元素。
在JAVA中数组的下标从0开始
数组名[下标]，数组中最大的下标为数组的长度减1
数组与循环
foreach循环：
遍历集合。
JDK1.5以后出现。
for（数据类型变量:
集合名）{
代码;
}
命令行参数：
java类名命令行参数，命令行参数以空格作为分隔符。
由main（）中的String[]接收
二维数组：
声明数组：
数据类型[][]数组名;
数据类型数组名[][];
数据类型[]数组名[];
创建数组：
int[][]array={{1,3,5},{2,4,6},{7,8,9}};
intarray1[][]=newint[3][3];//在创建多维数组时，高维不能省略，低维可以省略如：
intarray1[][]=newint[3][3];
array:
引用
array[0]
array[1]
array[2]
array[0][0]:
1
array[0][1]:
3
array[0][2]:
5
array[1][0]:
1
array[1][1]:
3
array[1][2]:
5
array[2][0]:
1
array[2][1]:
3
array[2][2]:
5
第四章
类与对象
1.成员变量（全局变量，字段，属性，域）：
描述类的特征。
在类中声明的变量。
在类中都可用。
成员变量有默认值（byte,short,int默认值为0.long默认值为0L,double默认值为：
0.0,float默认为0.0F,boolean默认为false,char默认为’\u0000’,引用数据类型默认为null）。
2.局部变量：
方法中声明的变量，只在方法中可用。
局部变量没有默认值.
3.new关键字在堆中开辟空间，创建类的对象（实例）。
p:
引用
name:
刘小凯
age:
18
sex:
salary:
p1:
引用
name:
梁志达
age:
18
sex:
salary:
4.在一个类中想调用另一个类的成员（成员变量与成员方法），必须声明并创建这个类的对象，通过类的对象调用类的成员。
格式为:
对象名.成员。
5.成员方法（成员函数）：
描述类的行为（动作）。
6.方法声明的基本格式：
访问权限返回类型方法名（[参数]）{
方法体;
}
当方法没有返回类型时，用void表示，可以使用return但不能返回数据
return的功能:
1.返回数据;2.结束方法
方法的重载：
一个类有多个名字相同但参数不同（个数不同，类型不同，顺序不同）的方法。
子类能重载父类的方法
构造方法（构造函数，构造器）：
1.方法名与类名相同。
2.构造方法一定没有返回值，并且不能写void
3.类一定有构造方法。
4.当没有在类中显式的写构造方法时，JVM会自动为类添加一个默认的构造方法。
5.默认构造方法：
没有参数，没有方法体
public方法名（）{}
6.构造方法无法任意调用。
只有new时才能调用类的构造方法。
new构造方法（）.
7.构造方法的功能：
为类的成员变量初始化。
8.当在类中显式的写了构造方法，JVM就不会为类添加默认的构造方法。
this关键字:
在类中调用自身的成员。
static关键字：
用static修饰的成员可以使用类的对象调用，也可以使用类名（接口名）调用。
1.修饰成员变量：
静态变量。
静态变量对于类的对象而言是共用一份的。
p:
引用
name:
age:
p1:
引用
name:
age:
BB
2.修饰成员方法：
静态方法。
静态方法只能直接调用静态的成员（成员变量，成员方法）。
不能使用this与super关键字。
final修饰的成员变量如何初始化：
1.在声明final类型的成员变量时，直接为这个变量初始化。
2.如果没有在声明时为final的成员变量初始化，就需要在这个类的所有的构造方法中为这些final的成员变量初始化（保证类的对象在构造完成前，这些final的成员变量需要被初始化）.
包：
本质就是文件夹。
包主要的作用解决类的重名问题。
1.当类出现在一个包中时，类的第一行必须是package语句，说明类存在于哪个包下。
2.package语句必须出现在类的首行（注释除外）
3.类可以引用同包下的类。
4.当类可使用其它包中的类时，要使用import语句导包。
5.在java.lang包中的内容可以直接使用不用导包。
20120804
类的继承：
单继承：
一个类只能有一个父类（直接的父类）。
名字，性别，职业，耐力，力量
走，跑，跳，攻击
使用extends关键字，使一个类继承另一个类。
父类：
超类，根类，基类
子类：
派生类
访问权限：
public\protected\默认\private,普通的类（顶层类）只能用public与默认修饰，修饰类的成员，但不能修改局部变量。
类内部
同包下的类
不同包下的子类
不同包下的其它类
private
Y
N
N
N
默认（包权限）
Y
Y
N
N
protected
Y
Y
Y
N
public
Y
Y
Y
Y
p:
引用
name:
AA
age:
50
s:
school:
大连
name:
BB
age:
20
第五章
方法的重载：
一个类有多个名字相同但参数不同（个数不同，类型不同，顺序不同）的方法。
方法的重写（方法的覆盖）：
1.子类根据需要重写父类中的方法。
2.重写的方法要与被重写的方法具有相同的方法名，参数列表，返回类型。
3.重写的方法的访问权限要大于或等于被重写方法的访问权限。
4.static修饰的方法不能产生重写。
5.重写的方法不能抛出比被重写的方法范围更大的异常。
（小于或等于可以）
classFoo{
StringdoStuff（intx）{return"hello";}
}
AStringdoStuff（Strings）{return"Hello";}重载
BintdoStuff（Strings）{return42;}重载
CStringdoStuff（intx）{return"hello";}重写
super关键字：
在子类中引用父类的成员。
子类可以继承父类中private的成员，但不能使用。
子类不能继承父类的构造方法。
继承中的构造方法：
1.子类在构造自己的过程中必须调用父类的构造方法。
2.子类在自己构造方法的第一行使用super（[参数]）调用父类的构造方法。
3.如果没有显式的写super（[参数]），JVM会自动在子类构造方法的第一行添加super（）调用父类无参的构造方法。
4.当父类中没有无参的构造方法，而子类又没有显式的调用父类有参的构造方法，则编译失败。
可变参数：
只能用在方法的形参中。
格式：
数据类型…变量名,本质是一个一维数组。
在声明方法时不能在可变参数的后面添加其它的参数。
当方法的形参为基本数据类型时，形参的值改变实参的值不变。
当方法的形参为引用数据类型时，形参的值改变实参可能改变。
20120806
instanceof运算符：
判断左边的对象是否为右边类的对象或右边类的子类的对象。
如果左边的对象与右边的类没有继承关系，编译失败。
引用数据类型的类型转换：
1.子类可以直接赋给父类。
2.父类必须强转才能赋给子类。
3.当父类的变量指向的不是子类的对象时，代码运行时会发生运行时异常
4.当两个类没有继承关系时不能进行类型转换,否则编译失败
多态与动态绑定：
1.父类声明，子类创建。
2.多态时调用的方法是子类的方法（如果子类重写了父类的方法）。
3.多态时调用的成员变量是父类的成员变量。
抽象：
abstract
1.修饰类：
抽象类。
抽象类不能实例化（不能new）。
只能使用抽象类的子类。
2.修饰成员方法：
抽象方法。
抽象方法只有方法的声明没有方法的实现。
子类必须重写父类中所有的抽象方法（如果子类是抽象类可以不重写）。
抽象方法所在的类必须是抽象类。
3.修饰接口:
抽象方法不是只能放在抽象类中，接口中也可以
abstract不能与哪些关键字一起使用：
private,static,final
final
1.修饰变量：
只能赋值一次
2.修饰方法：
子类不能重写父类final的方法。
3.修饰类：
类不能被继承。
第七章
接口的功能：
使JAVA实现多继承。
interface关键字创建接口。
接口不是类（不能new）只能是用接口的实现类（不能实例化接口的对象）
1.接口中包含常量与抽象方法。
2.接口中的常量默认为publicstaticfinal，也必须为publicstaticfinal.
3.接口中的方法默认为publicabstract,也必须为publicabstract
4.类可以实现（implements）接口,一个类可以实现多个接口
5.当类实现接口，类必须重写接口中所有的抽象方法（如果类是抽象类可以不重写）
6.接口可以继承其它接口，接口可以继承多个接口。
20120807
//声明一个内部类的对象
OutClass.InterClassin;
OutClasso=newOutClass（）;
//创建实例内部类的对象
in=o.newInterClass（）;
普通内部类不能包含static静态类。
内部类：
一个类中嵌套一个类，内部类可以使用所有的访问权限修饰，内部类可以使用static修饰
1.实例内部类（普通内部类）：
实例内部类可以直接使用外部类所有的成员，实例内部类不能包含static的成员。
2.静态内部类：
用static修饰的内部类。
静态内部类中可以有静态与非静态的成员。
静态内部类只能直接使用外部类中静态的成员。
3.局部内部类：
在方法中创建的类。
不能使用访问权限修饰，可以访问局部变量，但这些局部变量必须是final的
第八章
异常处理：
Throwable类
Error类
Exception类
RuntimeException类及其子类
非运行时异常
Throwable类：
JAVA所有错误与异常的父类。
Error类：
在编程时不用（不应该）捕获与处理的错误。
Exception类：
在编程时需要捕获与处理的异常。
RuntimeException类及其子类：
在编程时可以不捕获的异常，但运行时程序可能会发生错误。
非运行时异常（编译错误）：
在编程时必须捕获与处理的异常，否则代码无法编译。
捕获并处理异常
try{
可能会发生异常的代码
}catch（异常的类型）{
处理异常的代码
}finally{
无条件执行的代码
}
1.try块不能单独使用，必须与catch块或finally块一起使用。
2.当try块中发生异常时，从发生异常的代码开始之后try块中的代码将不再执行。
3.一个try语句中可以出现0个或多个catch块
4.可以在catch块中使用Exception捕获并处理所有的异常。
5.Exception只能出现在最后一个catch块中。
6.一个try语句中只能出现0个或1个finally块
7.finally块中的代码一定会执行。
自定义的异常：
类继承Exception或Exception的子类
手动抛出异常：
throw关键字。
在方法的运行过程中手动的抛出一个异常。
必须出现在方法体中。
声明异常：
throws关键字，只能出现在方法的声明中，是通知方法的调用者此方法在运行时可能会发生一些异常（笔试）
当父类的构造方法抛出异常时，子类的构造方法也必须抛出同样的异常。
当调用的方法可能抛出非运行时异常时，在调用方法的同时必须处理这些异常
20120808
常用类：
java.lang.String类：
在JAVA中表示不可变的字符序列。
如果字符串要频繁进行修改时不要使用String类。
==比较的是：
引用（地址）。
常用的方法：
String类的方法不会改变自己的内容。
charAt（intindex）:
获得字符串指定位置的字符。
length（）:
获得字符串的长度。
indexOf（Strings）:
在字符串中查询字符串s首次出现的位置，没找到返回-1
indexOf（Strings,intindex）:
从字符串的第index位开始查找字符串s首次出现的位置，没找到返回-1.
equals（）:
判断字符串的内容是否相等（区分大小写）。
equalsIgnoreCase（）:
判断字符串的内容是否相等（不区分大小写）。
replace（charc1,charc2）:
将字符串出出现的所有的c1用c2替换掉
StringBuffer（s.replace（start,end,”字符串”））；
substring（intbegin）:
从字符串的第begin位开始截取字符串一直截取到字符串的最后。
substring（intbegin,intend）:
从字符串的第begin位开始截取字符串一直截取到第end位。
trim（）:
去掉字符串左右的空格。
valueOf（XXXi）;将i转换为String类型的值。
基本数据类型转换成引用数据类型
StringBuffer与StringBuilder:
:
可变的字符序列。
如果字符串需要频繁修改时应该使用StringBuffer或StringBuilder.
常用的方法：
append（XXXs）:
将指定的内容s追加到字符串中。
insert（intindex,XXXs）:
在字符串第index位之前插入内容s
delete（intbegin,intend）:
从第begin位开始删除字符串一直到第end位之前
reverse（）:
将字符串倒序排列。
java.util.Date类:
日期
java.util.Calendar类:
日历
java.text.DateFormat类:
格式化日期，将日期转换成指定格式的字符串。
20120809
java.lang.Object类：
是JAVA中所有类的父类。
equals（）:
判断内容是否相等。
这个方法最早出现在Object类中，但Object类的equals（）比较的不是内容而是引用是否相同。
包装类（封装类）：
共8个，Byte，Short，Integer，Long，Float，Double，Character，Boolean
所有的包装类都是final
final
修饰变量：
只能赋值一次
修饰方法：
子类不能重写父类final的方法。
修饰类：
类不能被继承。
装箱：
将基本数据类型转换为包装类。
拆箱：
将包装类转换为基本数据类型。
从JDK1.5以后JAVA可以自动的装箱与拆箱
集合框架：
Collection接口
Map接口
Set接口
List接口
Map接口的实现类
Set（集）：
不保存元素加入的顺序，不能有重复值。
List（列表）：
保存元素加入的顺序，可以有重复值。
Map：
保存一对值（键值对，Key-Value）,键不能重复，值可以重复。
ArrayList:
是线性表，按位置（索引）查询元素时效率高，但添加与删除元素效率低。
LinkedList:
是链表，添加与删除元素效率高，但按位置查找元素时效率低。
Vector:
功能与ArrayList一样，但Vector是线程安全的，ArrayList是线程不安全的。
Hashta
升级会员 