45fan.com - 路饭网

搜索: 您的位置主页 > 网络频道 > 阅读资讯:Java语言基础知识大全

Java语言基础知识大全

2016-09-02 15:11:18 来源:www.45fan.com 【

Java语言基础知识大全

2.1简单数据类型

2.1.1 标识符和保留字

1.标识符
程序员对程序中的各个元素加以命名时使用的命名记号称为标识符(identifier)。Java语言中,标识符是以字母,下划线(_),美元符($)开始的一个字符序列,后面可以跟字母,下划线,美元符,数字。例如,identifier,userName,User_Name,_sys_val, $change为合法的标识符,而2mail room#,class 为非法的标识符。

2.保留字
具有专门的意义和用途,不能当作一般的标识符使用,这些标识符称为保留字(reserved word),也称为关键字,下面列出了java语言中的所有保留字:

bstract,break,byte,boolean,catch,case,class,char,continue,default,double,do,else,extends,false,final,float,for,finally,if,import,implements,int,interface,instanceof,long,length,native,new,null,package,private,protected,public,return,switch,synchronized,short,static,super,try,true,this,throw,throws,threadsafe,transient,void,while 。

java语言中的保留字均用小写字母表示

2.1.2 数据类型概

1. java中的数据类型划分
java语言的数据类型有简单类型和复合类型:
简单数据类型包括:
整数类型(Integer):byte, short, int, long
浮点类型(Floating):float,double
字符类型(Textual):char
布尔类型(Logical):boolean

复合数据类型包括:
class
interface
数组


2.常量和变量
常量:用保留字final来实现
final typeSpecifier varName=value[,varName[=value]…];
如:final int NUM=100;

变量:是java 程序中的基本存储单元,它的定义包括变量名、变量类型和作用域几个部分。其定义格式如下:
typeSpecifier varName[=value[,varName[=value]…];
如:int count; char c='a';

变量的作用域指明可访问该变量的一段代码,声明一个变量的同时也就指明了变量的作用域。按作用域来分,变量可以有下面几种:局部变量、类变量、方法参数和例外处理参数。在一个确定的域中,变量名应该是唯一的。局部变量在方法或方法的一个块代码中声明,它的作用域为它所在的代码块(整个方法或方法中的某块代码)。类变量在类中声明,而不是在类的某个方法中声明,它的作用域是整个类。方法参数传递给方法,它的作用域就是这个方法。例外处理参数传递给例外处理代码,它的作用域就是例外处理部分。

2.1.3 简单数据类型

1.布尔类型--boolean

布尔型数据只有两个值true和false,且它们不对应于任何整数值。布尔型变量的定义如:
boolean b=true;


2.字符类型--char

字符常量:
字符常量是用单引号括起来的一个字符,如'a','A';

字符型变量:
类型为char,它在机器中占16位,其范围为0~65535。字符型变量的定义如:
char c='a'; /*指定变量c为char型,且赋初值为'a'*/


3.整型数据

整型常量:
十进制整数
如123,-456,0
八进制整数
以0开头,如0123表示十进制数83,-011表示十进制数-9。
十六进制整数
以0x或0X开头,如0x123表示十进制数291,-0X12表示十进制数-18。

整型变量:

 

数据类型
所占位数
数的范围
byte
8
-27~27-1
bhort
16
-215~215-1
int
32
-231~231-1
long
64
-263~263-1


4.浮点型(实型)数据

实型常量:
十进制数形式
由数字和小数点组成,且必须有小数点,如0.123, 1.23, 123.0
科学计数法形式
如:123e3或123E3,其中e或E之前必须有数字,且e或E后面的指数必须为整数。
float型的值,必须在数字后加f或F,如1.23f。

实型变量:

 

数据类型
所占位数
数的范围
float
32
3.4e-038 ~3.4e+038
double
64
1.7e-038 ~1.7e+038

5.简单数据类型的例子:

【例2.1】
public class Assign {
public static void main (String args [ ] ) {
int x , y ; //定义x,y两个整型变量
float z = 1.234f ; //指定变量z为float型,且赋初值为1.234
double w = 1.234 ; //指定变量w为double型,且赋初值为1.234
boolean flag = true ; //指定变量flag为boolean型,且赋初值为true
char c ; //定义字符型变量c

String str ; //定义字符串变量str
String str1 = " Hi " ; //指定变量str1为String型,且赋初值为Hi
c = ' A ' ; //给字符型变量c赋值'A'
str = " bye " ; //给字符串变量str赋值"bye"
x = 12 ; //给整型变量x赋值为12
y = 300; //给整型变量y赋值为300
}
}

2.1.4 简单数据类型中各类型数据间的优先关系和相互转换

1.不同类型数据间的优先关系如下:

低------------------------------------------->高
byte,short,char-> int -> long -> float -> double


2.自动类型转换规则

整型,实型,字符型数据可以混合运算。运算中,不同类型的数据先转化为同一类型,然后进行运算,转换从低级到高级;

 

操作数1类型
操作数2类型
转换后的类型
byte、short、char int int
byte、short、char、int long long
byte、short、char、int、long float float
byte、short、char、int、long、float double double


3.强制类型转换

高级数据要转换成低级数据,需用到强制类型转换,如:
int i;
byte b=(byte)i; /*把int型变量i强制转换为byte型*/

2.2 运算符和表达式

2.2.1 运算符

对各种类型的数据进行加工的过程成为运算,表示各种不同运算的符号称为运算符,参与运算的数据称为操作数,按操作数的数目来分,可有:
一元运算符:++,--,+,-
二元运算符:+,-,>
三元运算符:?:

基本的运算符按功能划分,有下面几类:

1算术运算符: +,―,*,/,%,++,――。
例如:
3+2;
a-b;
i++;
--i;


2关系运算符: >,<,>=,<=,==,!=。
例如:
count>3;
I==0;
n!=-1;


3布尔逻辑运算符: !,&&,|| 。
例如:
flag=true;
!(flag);
flag&&false;


4位运算符: >>,<<,>>>,&,|,^,~。
例如:
a=10011101; b=00111001;则有如下结果:
a<<3 =11101000;
a>>3 =11110011 a>>>3=00010011;
a&b=00011001; a|b=10111101;
~a=01100010; a^b=10100100;


5赋值运算符 =,及其扩展赋值运算符如+=,―=,*=,/=等。
例如:
i=3;
i+=3; //等效于i=i+3;


6条件运算符 ? :
例如:result=(sum= =0 ? 1 : num/sum);

7其它:
包括分量运算符· ,下标运算符 [],实例运算符instanceof,内存分配运算符new,强制类型转换运算符 (类型),方法调用运算符 () 等。例如:
System.out.println("hello world");
int array1[]=new int[4];

2.2.2 表达式

表达式是由操作数和运算符按一定的语法形式组成的符号序列。一个常量或一个变量名字是最简单的表达式,其值即该常量或变量的值;表达式的值还可以用作其他运算的操作数,形成更复杂的表达式。

1.表达式的类型

表达式的类型由运算以及参与运算的操作数的类型决定,可以是简单类型,也可以是复合类型:
布尔型表达式: x&&y||z;
整型表达式: num1+num2;


2.运算符的优先次序

表达式的运算按照运算符的优先顺序从高到低进行,同级运算符从左到右进行:

 

优先次序
运算符
1
. [] ()
2
++ -- ! ~ instanceof
3
new (type)
4
* / %
5
+ -
6
>> >>> <<
7
> < >= <=
8
= = !=
9
&
10
^
11
|
12
&&
13
||
14
?:
15
= += -= *= /= %= ^=
16
&= |= <<= >>= >>>=


例如,下述条件语句分四步完成:
Result=sum==0?1:num/sum;
第1步:result=sum==0?1:(num/sum)
第2步:result=(sum==0)?1:(num/sum)
第3步:result=((sum==0)?1:(num/sum))
第4步:result=

2.3控制语句

Java程序通过控制语句来执行程序流,完成一定的任务。程序流是由若干个语句组成的,语句可以是单一的一条语句,如c=a+b,也可以是用大括号{}括起来的一个复合语句。Java中的控制语句有以下几类:
分支语句:if-else, switch
循环语句:while, do-while, for
与程序转移有关的跳转语句:break, continue, return
例外处理语句:try-catch-finally, throw
注释语句://,/* */, /** */

2.3.1 分支语句

分支语句提供了一种控制机制,使得程序的执行可以跳过某些语句不执行,而转去执行特定的语句。

1.条件语句 if-else

if(boolean-expression)
statement1;
[else statement2;]


2.多分支语句 switch

switch (expression){
case value1 : statement1;
break;
case value2 : statement2;
break;
…………
case valueN : statemendN;
break;
[default : defaultStatement; ]
}

表达式expression的返回值类型必须是这几种类型之一:int,byte,char,short。
case子句中的值valueN必须是常量,而且所有case子句中的值应是不同的。
default子句是可选的。
break语句用来在执行完一个case分支后,使程序跳出switch语句,即终止switch语句的执行(在一些特殊情况下,多个不同的case值要执行一组相同的操作,这时可以不用break)。

2.3.2 循环语句

循环语句的作用是反复执行一段代码,直到满足终止循环的条件为止。Java语言中提供的循环语句有:
while语句
do-while语句
for语句

1.while语句

[initialization]
while (termination){
body;
[iteration;]
}


2.do-while语句

[initialization]
do {
body;
[iteration;]
} while (termination);


3.for语句

for (initialization; termination; iteration){
body;
}

for语句执行时,首先执行初始化操作,然后判断终止条件是否满足,如果满足,则执行循环体中的语句,最后执行迭代部分。完成一次循环后,重新判断终止条件。
初始化、终止以及迭代部分都可以为空语句(但分号不能省),三者均为空的时候,相当于一个无限循环。
在初始化部分和迭代部分可以使用逗号语句,来进行多个操作。逗号语句是用逗号分隔的语句序列。
for( i=0, j=10; i……
}

2.3.3 跳转语句

break语句
continue语句
返回语句return

1.break语句

在switch语中,break语句用来终止switch语句的执行。使程序从switch语句后的第一个语句开始执行。
在Java中,可以为每个代码块加一个括号,一个代码块通常是用大括号{}括起来的一段代码。加标号的格式如下:
BlockLabel: { codeBlock }
break语句的第二种使用情况就是跳出它所指定的块,并从紧跟该块的第一条语句处执行。例如:
break BlockLabel;
break语句
a:{…… //标记代码块a
b:{…… //标记代码块b
c:{…… //标记代码块c
break b;
…… //此处的语句块不被执行
}
…… /此处的语句块不被执行
}
…… //从此处开始执行
}


2.continue语句

continue语句用来结束本次循环,跳过循环体中下面尚未执行的语句,接着进行终止条件的判断,以决定是否继续循环。对于for语句,在进行终止条件的判断前,还要先执行迭代语句。它的格式为:
continue;

也可以用continue跳转到括号指明的外层循环中,这时的格式为
continue outerLable;

例如:
outer: for( int i=0; i<10; i++ ){ //外层循环
inner: for( int j=0; j<10; j++ ){ //内层循环
if( i……
continue outer;

}
……
}
……
}


3.返回语句return

return语句从当前方法中退出,返回到调用该方法的语句处,并从紧跟该语句的下一条语句继续程序的执行。返回语句有两种格式:
return expression ;
return;

return语句通常用在一个方法体的最后,否则会产生编译错误,除非用在if-else语句中

2.3.4 例外处理语句

包括try,catch,finally,throw语

2.4 数组

java语言中,数组是一种最简单的复合数据类型。数组是有序数据的集合,数组中的每个元素具有相同的数据类型,可以用一个统一的数组名和下标来唯一地确定数组中的元素。数组有一维数组和多维数组。

2.4.1 一维数组

1. 一维数组的定义

type arrayName[ ];
类型(type)可以为Java中任意的数据类型,包括简单类型和复合类型。
例如:
int intArray[ ];
Date dateArray[];



2.一维数组的初始化

静态初始化
int intArray[]={1,2,3,4};
String stringArray[]={"abc", "How", "you"};


动态初始化
1)简单类型的数组
int intArray[];
intArray = new int[5];

2)复合类型的数组
String stringArray[ ];
String stringArray = new String[3];/*为数组中每个元素开辟引用
空间(32位) */

stringArray[0]= new String("How");//为第一个数组元素开辟空间
stringArray[1]= new String("are");//为第二个数组元素开辟空间
stringArray[2]= new String("you");// 为第三个数组元素开辟空间


3.一维数组元素的引用

数组元素的引用方式为:
arrayName[index]

index为数组下标,它可以为整型常数或表达式,下标从0开始。每个数组都有一个属性length指明它的长度,例如:intArray.length指明数组intArray的长度。

2.4.2 多维数组

Java语言中,多维数组被看作数组的数组。

1.二维数组的定义

type arrayName[ ][ ];
type [ ][ ]arrayName;


2.二维数组的初始化

静态初始化
int intArray[ ][ ]={{1,2},{2,3},{3,4,5}};

Java语言中,由于把二维数组看作是数组的数组,数组空间不是连续分配的,所以不要求二维数组每一维的大小相同。

动态初始化
1) 直接为每一维分配空间,格式如下:
arrayName = new type[arrayLength1][arrayLength2];
int a[ ][ ] = new int[2][3];

2) 从最高维开始,分别为每一维分配空间:
arrayName = new type[arrayLength1][ ];
arrayName[0] = new type[arrayLength20];
arrayName[1] = new type[arrayLength21];

arrayName[arrayLength1-1] = new type[arrayLength2n];

3) 例:
二维简单数据类型数组的动态初始化如下,
int a[ ][ ] = new int[2][ ];
a[0] = new int[3];
a[1] = new int[5];

对二维复合数据类型的数组,必须首先为最高维分配引用空间,然后再顺次为低维分配空间。
而且,必须为每个数组元素单独分配空间。

例如:
String s[ ][ ] = new String[2][ ];
s[0]= new String[2];//为最高维分配引用空间
s[1]= new String[2]; //为最高维分配引用空间
s[0][0]= new String("Good");// 为每个数组元素单独分配空间
s[0][1]= new String("Luck");// 为每个数组元素单独分配空间
s[1][0]= new String("to");// 为每个数组元素单独分配空间
s[1][1]= new String("You");// 为每个数组元素单独分配空间


3.二维数组元素的引用

对二维数组中的每个元素,引用方式为:arrayName[index1][index2]
例如: num[1][0];


4.二维数组举例:

【例2.2】两个矩阵相乘
public class MatrixMultiply{
public static void main(String args[]){
int i,j,k;
int a[][]=new int [2][3]; //动态初始化一个二维数组
int b[][]={{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}};//静态初始化
一个二维数组

int c[][]=new int[2][4]; //动态初始化一个二维数组
for (i=0;i<2;i++)
for (j=0; j<3 ;j++)
a[i][j]=(i+1)*(j+2);
for (i=0;i<2;i++){
for (j=0;j<4;j++){
c[i][j]=0;
for(k=0;k<3;k++)
c[i][j]+=a[i][k]*b[k][j];
}
}
System.out.println("*******Matrix C********");//打印Matrix C标记
for(i=0;i<2;i++){
for (j=0;j<4;j++)
System.out.println(c[i][j]+" ");
System.out.println();
}
}
}

2.5 字符串的处理

2.5.1 字符串的表示

Java语言中,把字符串作为对象来处理,类String和StringBuffer都可以用来表示一个字符串。(类名都是大写字母打头)

1.字符串常量

字符串常量是用双引号括住的一串字符。
"Hello World!"


2.String表示字符串常量

用String表示字符串:
String( char chars[ ] );
String( char chars[ ], int startIndex, int numChars );
String( byte ascii[ ], int hiByte );
String( byte ascii[ ], int hiByte, int startIndex, int numChars );
String使用示例:
String s=new String() ; 生成一个空串

下面用不同方法生成字符串"abc":
char chars1[]={'a','b','c'};
char chars2[]={'a','b','c','d','e'};
String s1=new String(chars1);
String s2=new String(chars2,0,3);
byte ascii1[]={97,98,99};
byte ascii2[]={97,98,99,100,101};
String s3=new String(ascii1,0);
String s4=new String(ascii2,0,0,3);


3.用StringBuffer表示字符串

StringBuffer( ); /*分配16个字符的缓冲区*/
StringBuffer( int len ); /*分配len个字符的缓冲区*/
StringBuffer( String s ); /*除了按照s的大小分配空间外,再分配16个
字符的缓冲区*/

2.5.2 访问字符串

1.类String中提供了length( )、charAt( )、indexOf( )、lastIndexOf( )、getChars( )、getBytes( )、toCharArray( )等方法。

public int length() 此方法返回字符串的字符个数
public char charAt(int index) 此方法返回字符串中index位置上的字符,其中index 值的 范围是0~length-1
public int indexOf(int ch)
public lastIndexOf(in ch)

返回字符ch在字符串中出现的第一个和最后一个的位置
public int indexOf(String str)
public int lastIndexOf(String str)
返回子串str中第一个字符在字符串中出现的第一个和最后一个的位置
public int indexOf(int ch,int fromIndex)
public lastIndexOf(in ch ,int fromIndex)
返回字符ch在字符串中位置fromIndex以后出现的第一个和最后一个的位置
public int indexOf(String str,int fromIndex)
public int lastIndexOf(String str,int fromIndex)
返回子串str中的第一个字符在字符串中位置fromIndex后出现的第一个和最后一个的位置。
public void getchars(int srcbegin,int end ,char buf[],int dstbegin)
srcbegin 为要提取的第一个字符在源串中的位置, end为要提取的最后一个字符在源串中的位置,字符数组buf[]存放目的字符串, dstbegin 为提取的字符串在目的串中的起始位置。
public void getBytes(int srcBegin, int srcEnd,byte[] dst, int dstBegin)
参数及用法同上,只是串中的字符均用8位表示。


2.类StringBuffer提供了 length( )、charAt( )、getChars( )、capacity()等方法。

方法capacity()用来得到字符串缓冲区的容量,它与方法length()所返回的值通常是不同的。

2.5.3 修改字符串

修改字符串的目的是为了得到新的字符串,类String和类StringBuffer都提供了相应的方法。有关各个方法的使用,参考java 2 API。

1.String类提供的方法:

concat( )
replace( )
substring( )
toLowerCase( )
toUpperCase( )

public String contat(String str);
用来将当前字符串对象与给定字符串str连接起来。
public String replace(char oldChar,char newChar);
用来把串中出现的所有特定字符替换成指定字符以生成新串。
public String substring(int beginIndex);
public String substring(int beginIndex,int endIndex);
用来得到字符串中指定范围内的子串。
public String toLowerCase();
把串中所有的字符变成小写。
public String toUpperCase();
把串中所有的字符变成大写。


2.StringBuffer类提供的方法:

append( )
insert( )
setCharAt( )

如果操作后的字符超出已分配的缓冲区,则系统会自动为它分配额外的空间。
public synchronized StringBuffer append(String str);
用来在已有字符串末尾添加一个字符串str。
public synchronized StringBuffer insert(int offset, String str);
用来在字符串的索引offset位置处插入字符串str。
public synchronized void setCharAt(int index,char ch);
用来设置指定索引index位置的字符值。

注意:String中对字符串的操作不是对源操作串对象本身进行的,而是对新生成的一个源操作串对象的拷贝进行的,其操作的结果不影响源串。

相反,StringBuffer中对字符串的连接操作是对源串本身进行的,操作之后源串的值发生了变化,变成连接后的串。

2.5.4 其它操作

1.字符串的比较

String中提供的方法:
equals( )和equalsIgnoreCase( )
它们与运算符'= ='实现的比较是不同的。运算符'= ='比较两个对象是否引用同一个实例,而equals( )和equalsIgnoreCase( )则比较两个字符串中对应的每个字符值是否相同。


2.字符串的转化

java.lang.Object中提供了方法toString( )把对象转化为字符串。


3.字符串"+"操作

运算符'+'可用来实现字符串的连接:
String s = "He is "+age+" years old.";
其他类型的数据与字符串进行"+"运算时,将自动转换成字符串。具体过程如下:
String s=new StringBuffer("he is").append(age).append("years old").toString();

注意:除了对运算符"+"进行了重载外,java不支持其它运算符的重载。

本讲小结】

java中的数据类型有简单数据类型和复合数据类型两种,其中简单数据类型包括整数类型、浮点类型、字符类型和布尔类型;复合数据类型包含类、接口和数组。表达式是由运算符和操作数组成的符号序列,对一个表达式进行运算时,要按运算符的优先顺序从高向低进行,同级的运算符则按从左到右的方向进行。条件语句、循环语句和跳转语句是java中常用的控制语句。

数组是最简单的复合数据类型,数组是有序数据的集合,数组中的每个元素具有相同的数据类型,可以用一个统一的数组名和下标来唯一地确定数组中的元素。Java中,对数组定义时并不为数组元素分配内存,只有初始化后,才为数组中的每一个元素分配空间。已定义的数组必须经过初始化后,才可以引用。数组的初始化分为静态初始化和动态初始化两种,其中对复合数据类型数组动态初始化时,必须经过两步空间分配:首先,为数组开辟每个元素的引用空间;然后,再为每个数组元素开辟空间。Java中把字符串当作对象来处理, java.lang.String类提供了一系列操作字符串的方法,使得字符串的生成、访问和修改等操作容易和规范。

 

本文地址:http://www.45fan.com/a/question/71332.html
Tags: 语言 Java 基础知识
编辑:路饭网
关于我们 | 联系我们 | 友情链接 | 网站地图 | Sitemap | App | 返回顶部