java基础.docx
《java基础.docx》由会员分享，可在线阅读，更多相关《java基础.docx（24页珍藏版）》请在冰豆网上搜索。
java基础
1、按执行方式对程序设计语言进行分类：
（1）、编译执行的语言：
（如C语言、Pascal语言）
编译执行是在编写完程序后，通过特定的工具软件将源代码经过目标代码转换成机器代码，即可执行程序，然后直接交操作系统执行，也就是说程序是作为一个整体来运行的。
（2）、解释执行的语言：
（如java语言、basic语言）
解释执行是在程序读入一句执行一句，而不需要整体编译链接，这样的语言与操作系统的相关性相对较小，但运行效率低，而且需要一定的软件环境来做源代码的解释器。
2、按思维模式对程序设计语言进行分类：
（1）、面向过程的程序设计语言：
（如C语言）
面向过程就是以解决的问题为思考的出发点和核心，并使用计算机逻辑描述需要解决的问题和解决的方法。
（2）、面向对象的程序设计语言：
（如java语言）
面向对象的基本思想就是以一种更接近人类一般思维的方式去看待世界，把世界上的任何一个个体都看成是一个对象，每个对象都有自己的特点，并以自己的方式做事，不同对象之间存在着通讯和交互，以此构成世界的运转。
3、类与对象：
对象是真实世界中的实体，对象与实体是一一对应的，也就是说现实世界中每一个实体都是一个对象，它是一种具体的概念。
类是具备某些共同特征的实体的集合，它是一种抽象的概念，它是对所具有相同特征实体的抽象，是具有相同属性相同行为的对象集合。
类是对象的抽象，而对象是类的实例。
4、属性与方法：
描述对象静态状态的，就是对象的属性，可以称之为变量；描述对象的动作，就是对象的方法，可以称之为函数。
5、封装：
只要有足够的方法，就没必要直接操作对象的属性，只要调用这些方法就可以实现要完成的任务，这种现象称为封装，也就是指隐藏对象的属性和实现细节，仅仅对外提供该对象的功能以及如何调用这种功能。
6、编写java源程序并执行：
（1）、从网上下载JDK（java编译执行环境），并安装JDK，JRE为java执行环境。
（2）、开始->控制面板->系统->“高级”选项卡->环境变量->在“系统变量”列表框找到Path变量->增加Path变量值为JDK的bin目录和lib目录，各目录用英文的分号分隔->这样做的目的是让windows下的任何目录都可以使用JDK的工具。
（3）、使用无格式的文本编辑器编写java源程序，如记事本、UltraEdit等，然后以java为后缀名保存源程序，注意的是java区分大小写且保存的文件名必须与源程序的主类名一致。
（4）、进入命令提示符：
开始->运行->cmd->用cd命令进入到保存的java源程序的目录。
（5）、javacjavaName.java编译名为javaName的源程序。
（6）、编译完成后，javajavaName执行编译好的程序。
7、main方法：
main方法作为程序的入口，由系统自动调用，必须没有返回值，即用void来描述。
一个java源程序中可以有一个或多个类，但只能有一个主类，主类就是含有main方法的类。
8、java标识符的命名规则：
Java程序中自定义的类名、方法名、参数都是标识符。
Java中的标识符由字母（区分大小写）、数字、下划线、$自由组合而成，但不能以数字开头，标识符长度不限。
9、常量：
（在程序中不变的量）
（1）、数字常量：
数字常量就是由阿拉伯数字组成的数字，如：
finalfloatINTEREST=0.02;
解释：
final是修饰词，表示INTEREST就是一个常量，float表示INTEREST是单精度浮点数。
（2）、字符常量：
Java中的字符常量通常用单引号括起来，如：
'a'，'E'，'g'，'%'，'#'等。
字符常量的值便是该字符的Unicode编码值。
若用到'，需使用转义序列'\''。
（3）、字符串常量：
Java中字符串是以对象的形式出现，字符串必须用双引号括起来。
在java.lang中的类String的实例就是字符串常量，如：
Stringx="Iamaprogram!
";
（4）、转义序列：
单引号、反斜杠不能直接用单引号引起来表示字符常量，需要用到转义序列（在字符前加反斜杠\），如：
\n//表示回车换行
\'//表示单引号
10、Java变量的基本数据类型：
（变量不初始化，在高版本的JDK中可能出错）
（1）、整型：
byte、int、short、long
使用整型变量最应注意的是数值的溢出。
整型可以写成十六进制、八进制、十进制，如0x34（十六进制表示），071（八进制表示），71（十进制表示）
（2）、浮点型：
float（单精度浮点型）、double（双精度浮点型）
浮点型的表示方法：
一般表示，如123.46；科学计数法表示，如1.2346E2。
数字后加f或F表示float型，占32bit，如：
1.2346E2f；数字后加d或D表示double型，占64bit，如：
1.2346E2d。
数字后未加任何字母，默认为double。
（3）、字符型（char）：
char型变量有两种方式赋值，一种用单引号括起来的单个字符赋值，如chari='a'；一种用Unicode的编码值赋值，如charj=97。
（4）、布尔型（boolean）：
boolean型变量只有两个值：
true或false。
注意：
不能用整型变量给字符变量赋值，若要赋值需要用强制转换，字符变量可以赋给整型变量。
11、数据类型的转换：
（1）、隐式转换：
赋值时，如果将较短类型数据赋给较长数据类型，较短类型会被转换成较长类型；计算时，如果一个较短类型与较长类型进行计算，较短类型会被转换成较长数据类型。
（2）、强制转换：
在转换的数据前加入括弧并在括弧内写上要转换成的类型，如：
（int）j。
在强制转换时，尤其要注意数据的溢出问题。
12、数组：
（java不支持变长数组，下标从0开始）
数组是相同类型的元素按一定顺序排列而成的一种数据结构，数组元素可以是java中的任何数据类型，如：
对象。
数组名代表的是数组第一个元素存储的内存地址，而不是它的实际内容。
（1）、数组的定义：
数组元素的数据类型数组名[];如：
charblock[];
数组元素的数据类型[]数组名;如：
char[]block;
（2）、为定义的数组开辟内存空间：
数组名=new数组元素的数据类型[元素个数];如：
block=newint[2][3];
（3）、将数组的定义和空间的开辟写在一起：
inta[][]=newint[10][3];
（4）、数组是一个对象，它有一个成员变量：
length，如：
inta[][]=newint[10][3];
a.length;//数组的行数：
10
a[0].length;//第一行的列数：
3
（5）、数组的初始化：
（数组未初始化时为默认值）
inta[][]={{1,2},{1,2,3}…}
或者
inta[][]=newint[5][10];
for（inti=0;i<5;i++）
for（intj=0;j<10;j++）
a[i][j]=0;
数组未初始化的默认值：
关键字
大小（bit）
十进制下取值范围
默认值
boolean
8
true或false
false
byte
8
-128~127
0
char
16
\u0000~\uffff
\u0000
short
16
-32768~32767
0
int
32
-2147483648~2147483647
0
long
64
-9.2×1018~9.2×1018
0
float
32
±1.4013E-45~3.4028E+38
0.0F
double
64
±2.2252E-208~±1.7977E+308
0.0D
数组中的元素为对象或简单数据类型：
classHoneybee{}//定义一个类
publicclassArraySize{
publicstaticvoidmain（Stringargs[]）{
Honeybee[]a;//声明保存Honeybee对象的数组为a
Honeybeeb[]=newHoneybee[5];//为保存Honeybee对象的数组b开辟空间
for（inti=0;ic[i]=newHoneybee（）;//初始化数组c，该数组保存Honeybee的对象
Honeybee[]d={newHoneybee（）,newHoneybee（）,newHoneybee（）};
//声明并初始化保存Honeybee对象的数组d
//System.out.println（"a.length="+a.length）;//这条语句出错，因为a只声明而没开辟空间
System.out.println（"b.length="+b.length）;//打印数组b的个数为5
for（inti=0;iSystem.out.println（"b["+i+"]="+b[i]）;//数组b只是创建了空间，所以值为null
System.out.println（"d.length="+d.length）;
a=d;//数组a指向数组d
System.out.println（"a.length="+a.length）;//数组a的长度为3
a=newHoneybee[]{newHoneybee（）,newHoneybee（）};
//初始化保存Honeybee对象的数组a
System.out.println（"a.length="+a.length）;//此时，数组a的长度为2
System.out.println（"-------------------"）;
int[]e;//声明数组e，数组中的元素为int型
intf[]=newint[5];//声明数组f并为其创建空间
int[]g=newint[4];
for（inti=0;ig[i]=i*i;//初始化数组g
int[]h={11,47,93};//声明数组h并为其初始化
System.out.println（"f.length="+f.length）;//数组f的长度为5
for（inti=0;iSystem.out.println（"f["+i+"]="+f[i]）;//数组f为初始化，所以为默认值0
System.out.println（"g.length="+g.length）;
System.out.println（"h.length="+h.length）;//数组h的长度为3
e=h;//e也指向数组h
System.out.println（"e.length="+e.length）;//数组e的长度为3
e=newint[]{1,2};
System.out.println（"e.length="+e.length）;//数组e的长度变为2
}
}
对象数组的传递（传递的是地址）：
publicclassIceCream{
staticString[]flav={"Chocolate","Strawberry",
"VanillaFudgeSwirl","MintChip","MochaAlmondFudge","RumRaisin",
"PralineCream","MudPie"};//创建String对象数组并初始化，代表各个香味
//下面的方法用来从上面的数组中产生一个随机排列的随机香味数组，产生的数组长度由形
//参n决定。
staticString[]flavorSet（intn）{
n=Math.abs（n）%（flav.length+1）;
//对数组的长度进行处理，使其不会大于flav数组的长度
String[]results=newString[n];//该String对象数组用于存储产生的随机香味序列
int[]picks=newint[n];//这个数组用于存储已提取过的下标值。
for（inti=0;ipicks[i]=-1;//让下标值先为-1
//以下部分用来实现香味名随机排列，它随机从数组中提取元素，然后判断这次抽取的下标
//是否重复，若重复，则重新选取，不重复则将该下标的香味存入results数组中。
for（inti=0;iretry:
while（true）{
intt=（int）（Math.random（）*flav.length）;
//产生一个随机下标值，这里flav.length长度为8，所以随机值范围为0~7。
（int）强制转换会
//将浮点型小数点后的数去掉（不四舍五入），random函数返回大于等于0小于1的double值
for（intj=0;jif（picks[j]==t）//若产生的随机下标值存在，则重新产生
continueretry;
picks[i]=t;//将已产生的随机小标值存入picks数组
results[i]=flav[t];//随机数组中存入产生的随机下标值的香味名
break;//跳出while循环，提取下一个随机香味名
}
}
returnresults;//将String对象数组返回
}
publicstaticvoidmain（String[]args）{
for（inti=0;i<20;i++）//产生多个随机香味数组
{
System.out.println（"flavorSet"+i+"）="）;
String[]fl=flavorSet（flav.length）;//从香味数组中产生一个随机香味数组
for（intj=0;jSystem.out.println（"\t"+fl[j]）;//打印当前产生的随机香味数组
}
}
}
13、java运算符
（1）、单目运算符++或--：
a++或a--指表达式运算完成后，再给a加1或减1；++a或--a指先给a加1或减1，再进行表达式运算。
（2）、双目运算符%（取余）只对整型运算。
（3）、关系运算符（==、!
=、<=等）比较两个表达式的大小，结果为boolean型。
不能在两个浮点数之间做等于（==）比较，因为浮点数用二进制表达之后不是精确值
（4）、逻辑运算符&与&&和|与||的区别：
&和|在进行运算时，符号两边的表达式都进行计算之后才得出值；&&和||在运算时，若运算符左边的值能决定整个表达式的值，则运算符右边的内容不再计算。
（5）、位运算符（~、>>、>>>等）以二进制位（bit）为单位进行运算，操作数和结果都是整型。
>>算术右移空出的位补符号位，>>>逻辑右移空出的位补0。
若对char、byte、short进行移位操作，那么在移位之前，它们会转换成int，若对long进行移位，得到的结果也是long。
（6）、instanceof运算符用来测试对象是否是特定类或它子类的一个对象，若是，则返回为true，否则返回为false。
例子：
publicclasstest{
publicstaticvoidmain（String[]args）{
Stringstr="test";
booleanr=strinstanceofString;
System.out.println（r）;
}
}
14、if语句：
if语句结构如下：
if（条件表达式1）
语句组1；
elseif（条件表达式2）
语句组2；
………
elseif（条件表达式n）
语句组n；
else
语句组n+1；
解释：
程序执行到if语句时，先判断条件表达式1，若为真，则执行语句组1，然后跳过所有if、elseif、else语句执行后面的部分；若条件表达式1为假，则判断elseif的条件表达式2，若为真，则执行语句组2，然后跳过所有elseif、else语句执行后面的部分；若条件表达式2为假，则判断后面elseif语句的条件表达式，依次类推；最后若所有的if、elseif都为假，则执行else语句组n+1。
15、switch语句：
switch语句结构如下：
switch（条件表达式）{
case判断值1：
语句组1；
case判断值2：
语句组2；
……
case判断值n：
语句组n；
default：
语句组n+1；
}
解释：
执行switch语句时，先计算条件表达式的值（该值必须是整型或字符型），然后将条件表达式的值与后面case语句后的判断值（该判断值必须与条件表达式的值同类型）逐个比较，若相等则执行该case语句后的所有语句组（包括default语句），除非遇到break语句才跳出switch结构。
default语句表示所有判断值都不匹配时才执行。
16、for循环：
for循环结构如下：
for（表达式1；表达式2；表达式3）
循环体；
解释：
执行for循环时，先执行表达式1，它的作用是初始化循环变量和其他变量，如果有多个语句就用逗号隔开；然后程序计算表达式2的值，表达式2的值必须是布尔型，若该值为真，则执行循环体（循环体可以是大括号括起来的多条语句），再执行表达式3（表达式3一般用来改变表达式2中的循环变量），之后返回到表达式2再次判断，如此反复直到表达式2的值为假才跳出for循环。
for（；；）表示无限循环。
17、while和do…while循环：
（1）、while循环结构如下：
while（条件表达式）
循环体；
解释：
执行while循环时，先判断条件表达式，它的值必须是布尔型，若为真，则执行循环体（多条语句用大括号括起来），然后再判断条件表达式直到为假时才跳出while循环。
while（true）
循环体；//这个while循环会无限循环。
（2）、do…while循环结构如下：
do
循环体；
while（条件表达式）；
解释：
执行do…while循环时，先无条件执行一次循环体，然后计算条件表达式，它的值必须是布尔型，若为真，则再次执行循环体，如此反复直到条件表达式的值为假才跳出循环。
18、break语句：
break语句用于跳出switch语句、for循环、while循环和do…while循环。
不带标签的break语句跳出当前循环，带标签的break语句跳出标签指示的循环结构。
带标签的break语句是在该break语句所在的循环结构以外寻找标签。
19、continue语句：
不带标签的continue语句终止当前循环结构的本次循环而直接开始下一次循环，带标签的continue语句把程序直接转到标签所指示的那个循环结构的下一次循环。
for循环中的continue语句会忽略循环体中后面的语句，直接跳到表达式3。
20、变量的作用范围：
一个变量从其被定义的位置开始，在同一个程序块中保持可见，一旦程序的执行离开这个范围，这个变量就失效了。
所谓程序块一般情况下指由一对花括号（{}）括起来的程序段。
21、方法参数的传递：
形参若是简单类型（int、char、float等）的变量，传递的便是该变量的副本；形参若是数组或对象，传递的便是该数组或对象的地址。
22、对象的创建：
（1）、定义对象：
（声明对象名是某个类的实例）
类名对象名[,对象名…]；
例子：
CarmyCar1,myCar2,myCar3;
（2）、创建对象（类的实例化）：
（在内存中为对象开辟空间）
对象名=new类的构造函数；
例子：
myCar1=newCar（）;
另一种创建对象的方式，例如：
publicclassAboutObject{
publicstaticvoidmain（String[]args）{
newAboutObject（）.test（）;//创建无名的内存空间，形成AboutObject类的对象，然后运行它的
//test（）方法，由于这个对象是无名的，所以以后就不能再次调用了。
}
publicvoidtest（）{
System.out.println（“hello！
”）;
}
}
（3）、对象的定义和创建放到一句中：
类名对象名1=new构造函数，对象名2=new构造函数…；
例子：
CarmyCar1=newCar（）,myCar2=newCar（）,myCar3=newCar（）;
（4）、附加说明：
对象名其实是该对象在内存中地址的标识，如果将一个对象赋予另一个对象，只是把地址赋予另一个对象，相当于给这个对象取了一个别名而已。
只有创建了对象后，对象名才指向实际的内存地址。
23、静态构造器：
静态构造器是在类加载内存时系统自动调用的，它只能对类进行初始化，它操作的一定是类的静态属性，且只执行一次。
例如：
static{
objectInitalNumber=1000;//objectInitalNumber是类的静态属性（被static修饰的属性）
}
24、对象的有效范围和废物回收：
java提供了对象无用时自动清除的功能。
在java里，收集和释放内存是一个叫自动废品回收站的线程负责。
25、java的命令行参数：
java程序是利用main（）方法的参数来从命令行中接收参数的，而main（）方法是通过Stringargs[]这个字符串数组来接收命令行参数的，即在命令行中输入的内容，系统把它当成字符串。
例如：
javacmdLine10233456，10、23等便是命令行参数，cmdLine是自己编写的一个java文件的文件名，10、23等被当作字符串，args[0]存的是字符串10。
26、构造函数：
（用于对象的初始化）
（1）、构造函数的名字必须与类名完全相同
（2）、构造函数是给对象进行初始化，所以没有返回值（无return语句），无需用void指明。
（3）、如果没有定义构造函数，系统将自动生成一个无形参的构造函数（默认构造函数），该构造函数将对象的属性赋予默认值。
如果定义了构造函数，系统将不再自动生成无形参的构造函数，可以自己写一个无形参的构造函数（方法体可以为空）。
（4）、构造函数可以重载（相同的方法名，不同的形参，如类型、个数、顺序不同）但不能覆盖（相同的方法名，相同的形参或没有形参）。
重载和覆盖统称为多态。
（5）、子类只继承父类的默认构造函数（无形参构造函数），如果父类没有默认构造函数，那么子类不能从父类继承到任何构造函数；如果父类没有定义默认构造函数，那么子类也不能定义自己的无参数构造函数。
（6）、子类的构造函数的形参表只能使用父类构造函数中用过的形参表，或者是对它的扩展。
（7）、构造函数不能是抽象的，即不能被abstract修饰。
27、子类与父类的关系：
（1）、子类只能继承父类的非私有属性和方法。
（2）、子类实例可以被当做父类的一个对象使用，而父类实例不能被当作子类的一个对象使用。
（3）、如果一个父类对象通过赋值指向的地址是子类对象所在地址，这个对象仍是父类对象，但可以用对象间赋值时的强制转换转换成子类对象，如：
子类对象=（子类名）已被赋予子类地址的父类对象。
（4）、java中
升级会员 