Java语言
Java语言-编程基础
1.JAVA的特点:
1、简单易用、完全面向对象;
2、与平台无关性、可扩展性强;
3、可移植性高、支持分布式编程;
4、健壮、安全可靠并性能优异;
5、支持多线程开发技术;
6、支持动态开发。
2. JVM:Java虚拟机(JVM是Java实现跨平台的基础)。
- Java的源程序(*.java)
- 编译(命令:java+文件名.java)
- Java字节码(*.class 编译时自动形成,与源程序名一致)
- 运行(命令:java+源程序的文件名)
JVM(Windows、Linux)
开发工具,Javac及基础核心类
JDK
运行环境,Java及基础核心类
3. 编写第一个Java程序:
- Java源文件扩展名为:”.java”
- 一个源文件中最好只有一个java类,但是可以包含多个类
- public修饰的类,文件名与类名必须一致(包括大小写)
- 被运行的类中需要有一个方法:
- public static void main(String[ ] args){}
- 一个源文件中最多有一个public修饰的类
例如:
1 public class Test{ 2 3 public static void main(String args[]){ 4 5 System.out.println(“这个编写的第一个java程序!!!”); 6 } 7 8 }
- 在运行程序之前先配置环境变量:
- path变量值为:JDK安装目录下\bin;
- classpath变量值为:JDK安装目录下\lib; 或 .;JDK安装目录下\lib\tools.jar
- 在dos命令窗口中输入以下命令进行运行:
- 编译命令:javac Test.java
- 运行命令:java Test
- 生成文档命令:javadoc Test.java
4.Java编程规范
A、命名规定
包 :包名应该是小写的名词。
如:package shipping.objects
类:类名应该是名词,大小写混合,每个单词的首字母大写。
如:class AccountBook
接口:接口名的大小写应该与类名一样。
如:interface Account
方法:方法名应该动词,大小写混合,首字母小写。每个方法名中,以大写字母区分单词。限制使用下划线。
如:balanceAccount( )
变量:所有的变量应该是大小写混合,首字母小写。由大写字母区分单词。限制下划线的使用。
如:currentCustomer
常数:基本类型常数应该是全部大写的由下划线区分的单词。
如:HEAD_COUNT、MAXIMUM_SIZE、MIN_VALUE
B、程序主体结构规定
控制结构:所有语句,即使是一条语句,如果是某控制结构的一部分,都要使用大括号({ })括起来。
空格:在任意行上只放置一条语句,并且使用2或4个空格缩进使代码更易读。
Java代码的位置:所有代码都存在于一个类里
例如:修饰符 class 类名
{ 程序代码 }
注意:
- Java是严格区分大小写的;
- 功能执行语句以(;)结束,这个分号必须是英文输入法中的(;);
- 连续的字符串不能换行,可使用(+)连接。
5、Java代码的注释
作用:
1)、解释程序中某些部分的作用和功能,提高程序的可读性。
2)、可以使用注释暂时屏蔽某些语句,在程序调试时使用。
注释的形式:
1)、单行注释
int c = 10; // 定义一个整型
2)、多行注释
/* int c = 10; // 定义一个整型 int x = 5; */
注意:/*…*/中可以嵌套”//”注释,但不能嵌套”/*…*/”。
3)、文档注释
“/** ...............*/”。
6、Java中的标识符
1)、变量,方法,类和对象的名称都是标识符,程序员需要标识和使用的东西都需要标识符。
2)、在Java语言里标识符以字母或下划线、$符号开头,后面字符可以是字母、数字、下划线、$符号。(其他符号都不能用来命名标识符)
3)、标识符对字母大小写非常敏感,必须区分大小写,但是没有长度限制。
4)、关键字不能用作标识符命名。
5)、标识符中不能包含空格。
6)、标识符是由Unicode字符组成的,因此可以使用汉字作为标识符(不推荐,尽量不用);
7、关键字
- Java中一些赋以特定的含义、并用做专门用途的单词称为关键字,也可叫保留字。关键字不能作为普通的标识符使用。
- 所有Java关键字都是小写的,IF、THIS、NEW等都不是Java关键字;
- goto和const虽然从未使用,但也作被为Java保留关键字;
abstract:抽象
private:私有
public:公有
static:静态
final:定义常量
native:Java调用别的语言(C++)程序时使用
volatile:短暂
transient:短暂
synchronized:处理线程是使用
try:异常处理
break:退出循环
catch:捉异常
case:流程控制语句
finally:无论有没有
continue:循环继续
throw:抛出异常
default:缺省
throws:抛出异常
do:循环语句
while:循环语句
class:类
if:条件语句
extends:继承
else:条件语句
implements:实现接口
for:for循环语句
instanceof:引入包
return:返回
interface:判断一个对象是否属于某个类
switch:条件判断
new:创建新对象
package:包
super:超类
this:自己
8、java基本数据类型
- 整数类型(byte, short, int, long)
- 浮点类型(float, double)
- 字符型(char)
- 布尔型(boolean)
基本数据类型包括:整型、浮点型、字符型、逻辑型(布尔型)。
数据类型 |
名称 |
位长 |
默认值 |
取值范围 |
布尔型 |
boolean |
1 |
false |
true,false |
字节型 |
byte |
8 |
0 |
-128~127 |
字符型 |
char |
16 |
‘\u0000’ |
‘\u0000’~‘\uffff’ |
短整型 |
short |
16 |
0 |
-32768~32767 |
整型 |
int |
32 |
0 |
-2147483648~2147483647 |
长整型 |
long |
64 |
0 |
-9223372036854775808~9223372036854775807 |
浮点型 |
float |
32 |
0.0 |
±1.4E-45~±3.4028235E+38 |
双精度型 |
double |
64 |
0.0 |
±4.9E-324~±1.7976931348623157E+308 |
注意:
- 整数类型数据用于描述一个一定大小范围内的整数。
- 浮点类型数据用于描述一个范围很大的实数;
- 浮点类型数据有一定的精度限制。
- 字符类型为char,它用于表示一个字符,使用单引号’在 Java中char类型为16字节,采用Unicode表示。
- 逻辑类型为boolean,它用于表示真和假;boolean类型只有两个值真(true), 假(false);
- boolean类型有自己的运算,不能参与其他数据类型之间的运算。
9、常量
常量就是程序里持续不变的值,是不能改变的数据。
声明常量的格式如下:
final类型 常量名[,常量名]=值;
Java中的常量包括整型常量、浮点型常量、布尔常量、字符常量等。
整型常量:
十进制:不能以0开头,多个0~9之间的数字
十六进制: 以0x或0X开头 0x8a 0X56d
八进制:必须以0开头 034 0376
长整型:必须以L结尾 87L 345L
浮点数常量:
float型:2e3f 0.6f
double型:4.1d 1.23d
布尔常量:true 和 false
字符常量: ‘a’ ‘5’
字符串常量:“hello” “8698” “\nmain” 转义字符\n表示换行
null常量:null,表示对象的引用为空。
10、变量
在java语言中存储一个数据信息,必须将它保存到一个变量中。变量在使用前必须有定义,即有确定的类型和名称。
声明变量的语法:
类型 变量名[, 变量名][=初值];
例如:int i; char c; float a, b, c;
变量的声明有三种形式:
1、 声明变量。
例如: int i;
2、 变量赋值。在变量赋值之前要先声明变量。
例如:int i; i=5;
3、 变量的初始化。
例如:int i = 8;
11、基本数据类型之间的兼容性
基本数据类型之间的转换:“小”的数据类型可以直接赋给“大”的数据类型。“大”的不能赋值给“小”的数据类型(会出现编译错误)。
数据类型大小关系如下:
整数类:long > int > short > byte
浮点型:double > float
整型数据类型可以赋给浮点数据类型比如:
float short float int float long double long
注意:
char 可以赋给long和int ,但是不能赋给short 和byte(编译错误) 。
char 可以赋给float和double。
当整数型常量被声明为long类型时,只能赋值给long型变量。
当整数型常量在0~65535之间时,可以被赋值给char型变量。
char型常量可以被赋值给整数类变量,只要整数变量的类型可以容纳char型文字常量所表示的数值。
浮点型常量默认为double型,而double型常量不能赋值给float型变量。
boolean与其他数据类型没有兼容性。
12、数据类型转换
1、自动类型转换(隐式类型转换)
需要同时满足两个条件:
1)、两种类型彼此兼容
2)、目标类型的取值范围要大于源类型
2、强制类型转换(显示类型转换)
当两种类型不兼容,或目标取值类型范围小于源类型时,自动类型转换无法进行,需要进行强制类型转换。
数据类型强制转换的格式为:
(数据类型)数据表达式;
例如:int i = 5; byte b = (byte)i;
13、变量的作用域
变量的作用域指一个变量起作用的范围,它决定了一个变量何时可以访问、何时不可以访问。Java中任何变量的作用域都从该变量声明之后开始,并且只在该声明的语句块中使用,也就是该变量只能在声明它的那个花括号{}中使用。
变量有分为成员变量和局部变量。
成员变量:在类中声明的变量称为成员变量,又叫全局变量。
使用范围:通常在类开始处声明,可在整个类中使用。
局部变量:在方法或块(块由两个花括号)中声明的变量称为局部变量。
使用范围:从声明处开始到它所在方法或块的结束处。
例: { int x = 4; //这之间只有x可以访问 int y = 1; //x和y可以访问 { int z = 2; //x、y、z都可以访问 z = 5; } x = 4; //只有x和y可以访问,不可以访问z }
14、Java中的运算符
算术运算符、关系运算符、赋值运算符、逻辑运算符、位运算符、条件运算符
1)、算术运算符
运算符 |
运算 |
范例 |
结果 |
+ |
正号 |
+3 |
3 |
- |
负号 |
b=4;-b; |
-4 |
+ |
加 |
5+5 |
10 |
- |
减 |
6-4 |
2 |
* |
乘 |
3*4 |
12 |
/ |
除 |
5/5 |
1 |
% |
取模(求余) |
5%5 |
0 |
++ |
自增(前) |
a=2;b=++a; |
a=3;b=3; |
++ |
自增(后) |
a=2;b=a++; |
a=3;b=2; |
-- |
自减(前) |
a=2;b=--a; |
a=1;b=1; |
-- |
自减(后) |
a=2;b=a--; |
a=1;b=2; |
+ |
字符串相加 |
“he”+“llo” |
“hello” |
两个整数之间的相除(/)运算结果还是整数,其结果是除的结果的整数部分。
例如:5/2结果为2
要获得实数结果,运算中至少一个浮点数。
例如:5/2.0结果为2.5
2)、关系运算符
运算符 |
运算 |
范例 |
结果 |
== |
相等于 |
4==3 |
false |
!= |
不等于 |
4!=3 |
true |
< |
小于 |
4<3 |
false |
> |
大于 |
4>3 |
true |
<= |
小于等于 |
4<=3 |
false |
>= |
大于等于 |
4>=3 |
true |
3)、赋值运算符
运算符 |
运算 |
范例 |
结果 |
= |
赋值 |
a=3;b=2; |
a=3;b=2; |
+= |
加等于 |
a=3;b=2;a+=b; |
a=5;b=2; |
-= |
减等于 |
a=3;b=2;a-=b; |
a=1;b=2; |
*= |
乘等于 |
a=3;b=2;a*=b; |
a=6;b=2; |
/= |
除等于 |
a=3;b=2;a/=b; |
a=1;b=2; |
%= |
模等于 |
a=3;b=2;a%=b; |
a=1;b=2; |
4)、逻辑运算符
运算符 |
运算 |
范例 |
结果 |
& |
AND(与) |
false & true |
false |
| |
OR(或) |
false | true |
true |
^ |
XOR(异或) |
false ^ true |
true |
! |
NOT(非) |
!true |
false |
&& |
AND(短路与) |
false && true |
false |
|| |
OR(短路或) |
false || true |
true |
在使用短路与(&&)时,如果第一个操作数(或表达式)为“假”,则不再计算第二个操作数(或表达式),直接返回“假”。
在使用短路或(||)时,如果第一个操作数(或表达式)为“真”,则不再计算第二个操作数(或表达式),直接返回“真”。
逻辑运算符只能用于布尔(boolean)类型之间;其结果值为布尔(boolean)类型。
5)、位运算符
运算符 |
运算 |
计算规则 |
& |
按位与 |
只有参加运算的两位都为1,‘&’运算的结果才为1,否则为0。 |
| |
按位或 |
只有参加运算的两位都为0,‘|’运算的结果才为0,否则为1。 |
^ |
按位异或 |
只有参加运算的两位不同,‘^’运算的结果才为1,否则为0。 |
<< |
左移位 |
左移指定位数,右边补0。 |
>> |
右移位 |
右移高位是0,左边补0;高位是1,左边补1。 |
>>> |
无符号右移位 |
左边补0。 |
~ |
按位取反 |
1取反是0,0取反是1。 |
位运算符只可用于整数类型、char类型,不可应用于浮点类型。
6)、条件运算符
条件运算符是一个三目运算符,也是唯一的一个三元运算符,符号为“? :”,在程序中能实现简单的判断功能。
语法格式:
表达式1?表达式2:表达式3
其中表示1是一个布尔表达式,如果表达式1结果为true,则执行表达式2,否则执行表达式3。
举例说明:求a,b的最大值。
int a=4,b=6,max;
max=a>b?a:b;//将a和b中的较大值赋给max
15、Java中的控制语句
(1)、if(表达式)......else.......条件语句;
(2)、for(表达式)....... 循环语句;
(3)、while(表达式)....... 循环语句;
(4)、do.....while(表达式)......循环语句;
(5)、switch 多分支选择结构;
(6)、continue 结束本次循环语句;
(7)、break 终止执行switch或循环语句;
(8)、return 从方法返回语句。
1、 条件语句
分为四种:
1) 单分支条件语句
语法格式为:
if(条件表达式){ 语句或语句块; }
2) 二分支条件语句
语法格式为:
if(条件表达式){ 语句或语句块1; }else{ 语句或语句块2; }
3) 嵌套条件语句
语法格式为:
if(条件表达式){ if(条件表达式){ 语句或语句块;
} }else{ 语句或语句块2; }
4) 多分支条件语句
语法格式为:
if(条件表达式1){ 语句或语句块1; }else if(条件表达式2){ 语句或语句块2; } …… …… } else if(条件表达式n){ 语句或语句块n; }else{ 语句0; }
2、 for循环语句
语法格式为:for(变量初始化表达式;循环条件表达式;迭代部分)
{
语句或语句块;//循环体
}
for循环有一个特殊的循环,叫死循环。表现形式为:
boolean isOk = true; 或 for(;;){}
for(;isOk;){}
for循环可以再嵌套for循环。
注意:在for循环的初始化或迭代部分,可以有多个表达式,表达式之间用逗号隔开。例如:
int count =0; for(int a= 1,b=10;a<b;a++,b--){ count++; } 共循环多少次?
3、 while循环语句
语法格式为:while(循环条件 表达式){
语句或语句块;
}
4、 do-----while循环语句
语法格式为:
do{ 语句或语句块; }while(表达式);
(注意分号绝对不能省略)
5、 switch-----case多分支选择语句
语法格式为:
switch(条件表达式){ case 常量1: 语句1; break; case 常量2: 语句2; break; …… case 常量N: 语句N; break; [default:语句;break;] }
注意:
- 条件表达式的返回值类型必须是以下类型之一:int、byte、char、short。
- case子句中的值常量N必须是常量,而且所有case子句中的值应是不同的。
- default子句是可选的。
- break语句用来在执行完一个case分支后,是程序跳出switch语句,即终止switch语句的执行。
- 在一些特殊情况下,多个不同的case值要执行一组相同的操作,这时可以不用break。
6、 continue结束本次循环语句
使用continue语句可以立刻重新开始下一轮的循环,而不再执行循环后面的语句。
7、 break终止执行switch和循环语句
使用break语句可以立刻终止循环,开始执行循环后面的语句。
8、 return从方法返回语句
return语句主要作用是退出当前方法,将程序控制转移到方法的调用者。
一般格式为: return [值或表达式];
16、方法调用语句
方法调用语句是执行对象的某个方法。
一个完整的方法调用语句由某个方法调用加上一个分号构成。
调用语法格式为:类对象名称.方法名(参数);
例如:
System.out.println(“This is a statement call a method!”);
调用对象System.out的println方法。
17、表达式语句
表达式语句就是由一个表达式加一个分号构成的语句。
例如常见的赋值语句:i=i+1;而i=i+1只是一个表达式。
18、空语句
空语句就是只有一个分号构成的语句。例如: ;
19、复合语句
复合语句又叫块,由{}将一些语句括起来就构成一个复合语句。
例如:{
a=b+c;
t=a*100;
}
20、数组
(1)定义:是用来存储一组或多组相同类型数据的数据类型。
(2)数据类型:可以是基本数据类型(例如:数字型、字符型、布尔型),也可以是复合数据类型(例如:数组、类、字符串和接口)。
※数组本身就是一种复合数据类型,因此,数组的元素也可以是数组,这样就构成了二维数组和多维数组。
(3)数组作为复合数据类型,与基本数据类型最大的区别:
数组是通过引用来控制的,而基本数据类型是通过值来控制的。
1、一维数组的声明:
格式: 类型 数组名[ ]; 或 类型[ ] 数组名;
举例:int a[ ]; String[ ] b;
数组的初始化有两种方法:一种是直接初始化,另一种是动态初始化。
直接初始化
格式: 类型 数组名[ ] = { 值1,值2,…,值n};
举例:
int a[ ] = {1,2,3};
int b[ ]; b = {1,2,3};
动态初始化:
格式:
(1)声明时初始化:
类型 数组名[ ] = new 类型[ 数组长度];
(2)声明后初始化:
类型 数组名[ ];
数组名 = new 类型[数组长度];
2、访问数组元素
数组元素是通过数组名和下标来访问。未被初始化的数组,不能进行访问。
格式:数组名[下标]
Java中,数组的下标从0开始,直到 <数组长度-1>结束。
获得数组的长度,通过length属性来获得。
3、数组的复制
方法:
System.arraycopy(源数组,源数组起始位置,目标数组,目标数组起始位置,长度);
★注:不管是要复制的数组,还是被复制的数组,都必须先初始化。
举例:
int a[ ] = {1,2,3}, b[ ] = new int[3]; System.arraycopy(a,0,b,0,3); //将数组a复制到b
4、对象数组:
举例:
//定义一个对象数组,StringBuffer是一个字符串缓存类 StringBuffer a[ ] = new StringBuffer[2]; //给对象赋值 a[0] = new StringBuffer(“Array[0]”); a[1] = new StringBuffer(“Array[1]”); System.out.println(“a[0]=” + a[0] + “ a[1]=” + a[1] ); a[0].append(“ is Modified”); //追加字符串 System.out.println(“a[0]=” + a[0]);
5、二维数组和多维数组
前面提到过,数组的元素也可以是数组,如果一个数组的每一个元素都是一个一维数组,这样就构成一个二维数组。
定义格式:类型 数组名[ ][ ]; 或 类型[ ][ ] 数组名;
举例: int a[ ][ ]; double[ ][ ] b;
这几种定义不合法:int a[2][ ]; int b[ ][2]; int c[2][2];
二维数组的初始化:二维数组的初始化也有直接和动态初始化两种方式。
直接初始化格式: 类型 数组名[][]= {{ 值1,值2,…,值n} ,{ 值1,值2,…,值n}....};
举例:int a[ ][ ] = {{1,2,3},{4,5,6},{7,8,9}};
动态初始化格式
1类型 数组名=new 类型[长度1][长度2]; 长度1表示行,长度2表示列。
举例:int a[][]=new[3][5];
2类型 数组名=new 类型[长度1][];
数组名[0]=new 类型[长度20];
数组名[1]=new 类型[长度21];
……
数组名[长度1-1]=new 类型[长度2n];
举例:
int a[][];
a=new int[3][];
a[0]=new int[5];
a[1]=new int[8];
a[2]=new int[6];
6、二维数组的应用
举例:两个矩阵相乘的例子。
//声明并初始化数组 int a[ ][ ] = {{8,13},{4,7},{5,2}}; int b[ ][ ] = {{3,4,11},{6,1,10}}; int result[ ][ ] = new int[3][3]; int i,j,k; //通过嵌套循环实现矩阵相乘的运算 for(i=0;i<a.length;i++){ for(j=0;j<b[0].length;j++){ result[i][j] = 0; for(k=0;k<b.length;k++){ result[i][j] += a[i][k] * b[k][j]; } } } //打印结果 System.out.println(“The result of a * b is : ”); for(i=0;i<result.length;i++){ for(j=0;j<result [i].length;j++){ System.out.print(result[i][j] + “ ”); } System.out.println( ); //换行
}
7、一维数组的应用
例1:将整数序列{3,15,28,11,34,78,95,27,18}首末颠倒过来。
int a[ ] = {3,15,28,11,34,78,95,27,18}; int i, length, temp; length = a.length; for(i=0;i<(length/2);i++){ //以下将数组元素a[i]和a[length -1 - i]的值互换 temp = a[i]; a[i] = a[length -1 –i]; a[length -1 –i] = temp; } for(i=0;i<length;i++){ System.out.print(a[i] + “ ”); }
例2:从数据:32 25 78 69 13 97 86 38 62 9 中找到数据97所在的位置。
『用顺序查找(线性查找)方法编写程序』。
//声明并初始化数组 int a[ ] = {32,25,78,69,13,97,86,38,62,9}; int index = -1,i; //逐个元素与97相比较,找到则退出循环,否则继续 for(i=0;i<a.length;i++){ if(a[i] == 97){ index = i; break; } } if(index == -1){ //表示该数不存在 System.out.println(“ 97这个数不存在!”); }else{ System.out.println(“97这个数的下标是: ” + index); }
例3:将数据:37 28 51 13 64为例,用『冒泡法』进行升序排列。
下面编写程序代码:(冒泡法)
int a[ ] = {37,28,51,13,64}; int i, j, n, temp; n = a.length; for(j=1;j < n ;j++ ){ //共执行 n-1 轮 for(i=0;i< n – j; i++){ //第j轮 if (a[i] > a[i+1]){ //交换a[i]与a[i+1]的值 temp = a[i]; a[i] = a[i+1]; a[i+1] = temp; } } } //打印排序后的结果 for(i=0;i < n;i++){ System.out.print(a[i] + “ ”); }