JAVA基本程序设计.docx
《JAVA基本程序设计.docx》由会员分享，可在线阅读，更多相关《JAVA基本程序设计.docx（20页珍藏版）》请在冰点文库上搜索。
JAVA基本程序设计
1、课程名称：
JAVA基本程序设计
数据类型、基本控制、数组、方法
2、知识点
2.1、上次课程的主要知识点
1、 JDK的安装与配置
2、 path及classpath的作用
2.2、本次预计讲解的知识点
1、 数据类型划分
2、 数据类型的相关说明
3、 程序控制语句
4、 方法的定义及方法的重载
5、 数组的定义及使用
6、 使用方法传递数组
3、具体内容
3.1、标识符
JAVA中的标识符：
字母、数字、下划线、$组成，其中不能以数字开头。
3.2、JAVA数据类型
在JAVA中数据类型分为两大类：
基本数据类型、引用数据类型。
•基本数据类型：
|-数值型：
|-整数：
byte、short、int、long
|-小数：
float、double
|-字符型：
char
|-布尔型：
boolean
•引用数据类型：
传递的是内存地址的使用权
|-数组
|-类
|-接口
对于各个数据类型都有其固定的取值范围。
如果超过了一个数字的取值范围，则会出现溢出的情况。
例如：
以下代码：
在int类型的最大基础之上进行加一或减一的操作。
•int的最大值使用以下一种方式取得：
Integer.MAX_VALUE
•int的最小值使用：
Integer.MIN_VALUE
publicclassDemo01{
publicstaticvoidmain（Stringabc[]）{
inti=Integer.MAX_VALUE;
intj=Integer.MIN_VALUE;
System.out.println（"int的最大值：
"+i）;
System.out.println（i+1）;
System.out.println（"int的最小值：
"+j）;
System.out.println（j-1）;
}
};
数字和字符之间可以进行相互的转换：
char：
强制 •int
•charint：
自动
例如：
以下代码使用了字符和数字间的相互转换
publicclassDemo02{
publicstaticvoidmain（Stringabc[]）{
inti=0;
charc='a';
i=c;
System.out.println（i）;
i++;
c=（char）i;
System.out.println（c）;
}
};
转义字符：
•\n：
表示换行
•\t：
表示制表符
•\\：
表示一个“、”
•\'：
表示“'”；
•\"：
表示“"”
另外需要说明的是，在操作数字的时候，一个普通的数字默认值就是“0”。
在操作的是一个小数的时候，默认值是double类型的。
所以如果要使用float接收的话，则一定要转换成float类型。
例如：
初始化一个float类型的数据
publicclassDemo03{
publicstaticvoidmain（Stringabc[]）{
floatf=89.3f;
inti=10;
System.out.println（f*i）;
}
};
数据类型之间的转换原则：
长度小的长度大的转换。
另外，还需要注意一点的是，如果现在是两个整数相除：
例如：
两个int类型相除：
publicclassDemo04{
publicstaticvoidmain（Stringabc[]）{
inti=10;
intj=4;
System.out.println（（float）i/j）;
}
};
对于boolean类型的数据来说，只有两种取值：
true、false，不可以使用0或非0的数字表示。
默认值就是“false”。
在转换中需要注意的是，在JAVA本身提供了一种表示字符串的类型：
String。
例如：
String的用法
publicclassDemo05{
publicstaticvoidmain（Stringargs[]）{
Stringstr="abc";
System.out.println（str）;
inti=10;
intj=20;
//在数值运算上，“+”表示计算，而在字符串上表示连接
//所有的类型如果与字符串相加，则最终结果都成为字符串
System.out.println（str+i+j）;
}
};
3.3、JAVA关键字
在JAVA中的所有关键字里，有两个未被使用到的关键字：
•goto：
无条件跳转
•const：
常量
3.4、JAVA判断逻辑
判断逻辑符号：
==、<=、>=、!
=
关系符号：
&&、&、||、|、!
在以上的判断中存在短路与与短路或的概念：
1、 短路与（&&）：
如果第一个条件不满足了，则后面的所有条件都不再进行验证
•而“&”：
表示的是所有条件都要进行判断
例如：
验证短路与
publicclassDemo08{
publicstaticvoidmain（Stringargs[]）{
inti=10;
intj=20;
if（i>10&&j/0==0）{
System.out.println（"满足"）;
}else{
System.out.println（"不满足"）;
}
}
};
2、 短路或：
如果第一个条件为真，则后面的所有条件都不用再判断了
•“|”：
表示所有条件都要判断
例如：
验证短路或
publicclassDemo09{
publicstaticvoidmain（Stringargs[]）{
inti=10;
intj=20;
if（i==10||j/0==0）{
System.out.println（"满足"）;
}else{
System.out.println（"不满足"）;
}
}
};
3.5、JAVA判断语句
判断语句：
•if….
•if…else
•if…elseif…elseif….Else
在整个JAVA中，所有的条件判断语句都是判断boolean类型的。
例如：
以下判断一个boolean类型的变量
publicclassDemo06{
publicstaticvoidmain（Stringargs[]）{
booleanflag=true;
if（flag）{
System.out.println（"欢迎光临！
"）;
}else{
System.out.println（"拜拜，再见！
"）;
}
}
};
多条件判断语句：
•在之前的if语句之中，判断可以跟上一个boolean值或者跟上若干个表达式，但是switch中只能上数字或字符。
•SWITCH中有多个case，每个case之中最后必须加上“break”，否则会在第一个满足的case之后的所有内容都执行。
例如：
验证switch
publicclassDemo07{
publicstaticvoidmain（Stringargs[]）{
inti=2;
switch（i）{
case1:
{
System.out.println（"1"）;
break;
}
case2:
{
System.out.println（"2"）;
break;
}
case3:
{
System.out.println（"3"）;
break;
}
default:
{
System.out.println（"nothing"）;
break;
}
}
}
};
3.6、循环及控制
循环语句分类：
•while：
先判断再执行，一般在不确定循环次数的情况下使用
•do…while：
先执行一次之后再进行判断，保证循环至少执行一次
•for：
已经明确的知道了循环的次数，才使用for循环
循环控制：
•break：
退出整个循环
•continue：
退出一次循环
•以上的两种一般都结合判断语句一起使用
在JAVA程序中，可以通过指定CONTINUE，到达循环的处理点。
例如：
验证使用CONITNUE跳转
publicclassDemo10{
publicstaticvoidmain（Stringargs[]）{
aa:
for（inti=0;i<10;i++）{
for（intj=0;j<10;j++）{
if（i*j>30）{
continueaa;
}
System.out.print（j+"\t"）;
}
System.out.println（""）;
}
}
};
以上的语法，一般情况下是不会出现的，只做了解即可。
3.7、方法及方法的重载（重点）
3.7.1、方法的基本概念
方法：
方法就是一段可重复调用的代码段。
方法要定义在类中。
方法的定义格式：
publicstatic返回值类型|void方法名称（参数列表）{
[return返回值];
}
注意：
此格式只适用于由主方法直接调用的方法上。
方法的命名要求：
第一个单词的首字母小写，之后每个单词的首字母大写。
例如：
定义一个方法，此方法打印“HelloWorld!
!
”。
•方法没有返回值则使用void定义
publicclassDemo11{
publicstaticvoidmain（Stringargs[]）{
print（）;
print（）;
print（）;
}
publicstaticvoidprint（）{
System.out.println（"HelloWorld!
!
!
"）;
}
};
例如：
定义一个方法，此方法可以返回两个数字相加的结果
publicclassDemo12{
publicstaticvoidmain（Stringargs[]）{
intk=add（10,20）;
System.out.println（k）;
System.out.println（add（20,30））;
}
//此时，方法中的i、j、t都是临时变量
//方法执行完之后就立刻销毁掉
publicstaticintadd（inti,intj）{
intt=i+j;
returnt;
}
};
例如：
要求定义一个方法，此方法的功能是可以根据传入的行数，打印三角形。
1、 先完成打印三角形的功能
publicclassDemo13{
publicstaticvoidmain（Stringarsg[]）{
//打印10行
for（inti=0;i<10;i++）{
//先打印出空格，依次减少
for（intj=0;j<10-i;j++）{
System.out.print（""）;
}
//再打印“*”，依次递增
for（intj=0;j System.out.print（"*"）;
}
System.out.println（""）;
}
}
};
2、 将以上的功能形成方法，并通过主方法调用
publicclassDemo14{
publicstaticvoidmain（Stringarsg[]）{
printStar（20）;
}
publicstaticvoidprintStar（intline）{
//打印line行
for（inti=0;i //先打印出空格，依次减少
for（intj=0;j System.out.print（""）;
}
//再打印“*”，依次递增
for（intj=0;j System.out.print（"*"）;
}
System.out.println（""）;
}
}
};
3.7.2、方法的重载
例如：
现在要做以下的几个方法
•要求可以完成两个数相加：
int、float
•要求可以完成三个数相加：
int
•按之前的方式，使用如下代码完成：
publicclassDemo16{
publicstaticvoidmain（Stringarsg[]）{
System.out.println（add1（10,20））;
System.out.println（add3（10.3f,20.6f））;
System.out.println（add2（10,20,30））;
}
publicstaticintadd1（inti,intj）{
returni+j;
}
publicstaticintadd2（inti,intj,intk）{
returni+j+k;
}
publicstaticfloatadd3（floatf,floatx）{
returnf+x;
}
};
以上确实已经完成了所要求的功能了，但是现在有了三种加法，则编写了add1、add2...，如果有50中加法呢？
则要一直编写add50类，这样代码很麻烦，所以在JAVA中为了解决这样的难堪，增加了方法重载的概念。
方法重载：
•方法名称相同，参数的类型或个数不同，在调用的时候根据传入参数的类型或个数的不同，完成的功能也不同，所以，以上代码修改为以下形式：
publicclassDemo17{
publicstaticvoidmain（Stringarsg[]）{
System.out.println（add（10,20））;
System.out.println（add（10.3f,20.6f））;
System.out.println（add（10,20,30））;
}
publicstaticintadd（inti,intj）{
returni+j;
}
publicstaticintadd（inti,intj,intk）{
returni+j+k;
}
publicstaticfloatadd（floatf,floatx）{
returnf+x;
}
};
注意：
方法的重载只局限在参数的类型或个数不同。
如果现在有以下代码：
publicclassDemo18{
publicstaticvoidmain（Stringarsg[]）{
System.out.println（add（10,20））;
System.out.println（add（20,30））;
}
publicstaticintadd（inti,intj）{
returni+j;
}
publicstaticfloatadd（inti,intj）{
return（float）i+（float）j+0.1f;
}
};
方法的重载与返回值类型是否相同没有任何的关系，只看参数的类型或个数。
3.8、数组
3.8.1、数组的基本概念
数组：
是一组变量。
例如：
现在假设要定义100个整型变量，如果按照之前的方式i1，i2，....i100。
所以使用数组就可以解决以上的问题，但是在JAVA中数组是属于引用类型的传递。
如果是引用数据类型，则肯定要有堆-栈的引用指向。
数组的定义格式：
1、 声明的同时开辟空间
数据类型数组名称[]=new数据类型[数组长度];
2、 分两步走，第一步想声明数组，之后再开辟数组空间：
数据类型数组名称[]=null;
数组名称=new数据类型[长度];
注意：
数组开辟空间之后里面的所有内容都是默认值。
例如；以下开辟了一个数组，同时把数组进行输出
publicclassDemo19{
publicstaticvoidmain（Stringargs[]）{
//声明一个整型数组
ints[]=newint[10];
}
};
开辟完之后，所有的数组是通过下标访问的，即：
i[0]~i[9]，一共表示10个元素。
利用循环，把数组中的内容全部输出：
publicclassDemo19{
publicstaticvoidmain（Stringargs[]）{
//声明一个整型数组
ints[]=newint[10];
for（inti=0;i<10;i++）{
System.out.print（s[i]+"\t"）;
}
}
};
例如：
以以下的程序为例讲解引用传递的概念。
publicclassDemo20{
publicstaticvoidmain（Stringargs[]）{
//声明一个整型数组
ints[]=newint[10];
//数组中的每一个内容都是奇数
for（inti=0;i<10;i++）{
s[i]=2*i+1;
}
for（inti=0;i<10;i++）{
System.out.print（s[i]+"\t"）;
}
}
};
分析过程：
1、 程序的内存现在分为两个空间：
栈、堆
•如果一个栈没有指向一个堆，则此内容无法使用。
2、 所有数组的名称在栈内存空间保存
3、 使用new数据类型[长度]表示在对应的堆内存开辟空间
4、 数组名称=new数据类型[长度]，表示的是把此内存空间的使用权交给了栈中的一个变量。
5、 通过栈空间中保存的名字去找到对应的堆内存空间
6、 有栈–堆的关系就称为引用数据类型
例如：
认识引用传递
publicclassDemo21{
publicstaticvoidmain（Stringargs[]）{
//声明一个整型数组
ints[]=newint[10];
//为此数组再指定一个名字
intx[]=null;
//为s所表示的空间给一个别名
x=s;
//数组中的每一个内容都是奇数
for（inti=0;i<10;i++）{
x[i]=2*i+1;
}
for（inti=0;i<10;i++）{
System.out.print（s[i]+"\t"）;
}
}
};
以上的数组在使用的时候都是先经过了声明之后再开辟空间（也可能是一起完成的），那么在程序语言中把此种的数组声明方式，称为动态初始化。
数组的静态初始化——直接指定好默认值
数组静态初始化的方式比较简单，语法如下所示：
数据类型数组名称[]={值,值}; 此代码是不能分为两行的。
在JAVA的数组中，提供了一种取得数组长度的操作，格式：
数组名称.length。
例如：
以下代码使用了静态初始化
publicclassDemo22{
publicstaticvoidmain（Stringargs[]）{
intx[]={23,23,134123,14,124,125,124,1212,213,1245,1235,233};
for（inti=0;i System.out.print（x[i]+"\t"）;
}
}
};
注意：
在使用数组的时候，一定要防止下标越界问题，例如：
以下代码：
publicclassDemo23{
publicstaticvoidmain（Stringargs[]）{
intx[]={1,2,3,4,5};
System.out.print（x[9]）;
}
};
则程序运行时会出现以下的错误提示：
Exceptioninthread"main"java.lang.ArrayIndexOutOfBoundsException:
9
atDemo23.main（Demo23.java:
4）
3.8.2、在方法中传递数组
方法中可以接收数组，既然传递过来的是一个数组，则接收的时候也应该按照一个数组的方式进行接收。
例如：
以下的程序演示了，如何使用方法去接收一个数组
publicclassDemo24{
publicstaticvoidmain（Stringargs[]）{
intx[]={1,2,3,4,5};
print（x）;
}
publicstaticvoidprint（inttemp[]）{
for（inti=0;i System.out.print（temp[i]+"\t"）;
}
}
};
既然方法中可以接收一个数组，那么就一定可以返回一个数组。
例如：
以下的方法返回了一个数组
publicclassDemo25{
publicstaticvoidmain（Stringargs[]）{
intx[]=init（）;
print（x）;
}
publicstaticvoidprint（inttemp[]）{
for（inti=0;i System.out.print（temp[i]+"\t"）;
}
}
publicstaticint[]init（）{
intw[]={2,32,23,234,1,1,23,234,4};
ret
升级会员 