java基础Word文档格式.docx
- 文档编号:19132743
- 上传时间:2023-01-04
- 格式:DOCX
- 页数:24
- 大小:30.32KB
java基础Word文档格式.docx
《java基础Word文档格式.docx》由会员分享,可在线阅读,更多相关《java基础Word文档格式.docx(24页珍藏版)》请在冰豆网上搜索。
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='
;
一种用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,如:
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
-128~127
char
16
\u0000~\uffff
\u0000
short
-32768~32767
int
32
-2147483648~2147483647
long
64
-9.2×
1018~9.2×
1018
float
±
1.4013E-45~3.4028E+38
0.0F
double
2.2252E-208~±
1.7977E+308
0.0D
数组中的元素为对象或简单数据类型:
classHoneybee{}//定义一个类
publicclassArraySize{
publicstaticvoidmain(Stringargs[]){
Honeybee[]a;
//声明保存Honeybee对象的数组为a
Honeybeeb[]=newHoneybee[5];
//为保存Honeybee对象的数组b开辟空间
c.length;
c[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
b.length;
b["
+i+"
]="
+b[i]);
//数组b只是创建了空间,所以值为null
d.length="
+d.length);
a=d;
//数组a指向数组d
//数组a的长度为3
a=newHoneybee[]{newHoneybee(),newHoneybee()};
//初始化保存Honeybee对象的数组a
//此时,数组a的长度为2
-------------------"
);
int[]e;
//声明数组e,数组中的元素为int型
intf[]=newint[5];
//声明数组f并为其创建空间
int[]g=newint[4];
g.length;
g[i]=i*i;
//初始化数组g
int[]h={11,47,93};
//声明数组h并为其初始化
f.length="
+f.length);
//数组f的长度为5
f.length;
f["
+f[i]);
//数组f为初始化,所以为默认值0
g.length="
+g.length);
h.length="
+h.length);
//数组h的长度为3
e=h;
//e也指向数组h
e.length="
+e.length);
//数组e的长度为3
e=newint[]{1,2};
//数组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];
//这个数组用于存储已提取过的下标值。
picks.length;
picks[i]=-1;
//让下标值先为-1
//以下部分用来实现香味名随机排列,它随机从数组中提取元素,然后判断这次抽取的下标
//是否重复,若重复,则重新选取,不重复则将该下标的香味存入results数组中。
i++){//数组picks的值为已提取的下标值
retry:
while(true){
intt=(int)(Math.random()*flav.length);
//产生一个随机下标值,这里flav.length长度为8,所以随机值范围为0~7。
(int)强制转换会
//将浮点型小数点后的数去掉(不四舍五入),random函数返回大于等于0小于1的double值
for(intj=0;
i;
if(picks[j]==t)//若产生的随机下标值存在,则重新产生
continueretry;
picks[i]=t;
//将已产生的随机小标值存入picks数组
results[i]=flav[t];
//随机数组中存入产生的随机下标值的香味名
break;
//跳出while循环,提取下一个随机香味名
returnresults;
//将String对象数组返回
publicstaticvoidmain(String[]args){
20;
i++)//产生多个随机香味数组
{
System.out.println("
flavorSet"
)="
String[]fl=flavorSet(flav.length);
//从香味数组中产生一个随机香味数组
fl.length;
System.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:
case判断值2:
……
case判断值n:
default:
执行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{
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中
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- java 基础