java布尔矩阵程序_Java编程学习摘要（2）语法基础

Java编程学习摘要(2)语法基础

Java编程语言的基本语法知识：简单数据类型，运算符和表达式，控制语句，数组及字符串处理

重点：　　1． 深刻理解各知识点的概念，并熟记java 的语法规范。

2． 熟练使用各种数据类型的定义，表示和引用。

3． 能熟练使用各种控制语句。

4． 能熟练处理字符串。

难点：

1． 动态初始化复杂类型数组时，要先为数组中的元素开辟引用空间，再为每个元素开辟空间。

2．使用StringBuffer类表示和操作字符串时，要注意它可以处理可变字符串，即当在StringBuffer类型的字符串中插入字符而超出已分配的缓冲区时，系统会自动地为它分配额外的空间。

(一)简单数据类型：

标识符(identifier)是以字母、下划线(_)、美元符($)开始的一个字符序列，后面可以跟字母，下划线，美元符，数字。例如，identifier，userName，User_Name，_sys_val，

$change为合法的标识符，而2mail

room#是非法的标识符。

保留字(reserved

word)具有专门的意义和用途，不能当作一般的标识符使用(均用小写字母表示)。如class。下面列出了java语言中的所有保留字：abstract，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

。

简单数据类型：

整数类型(Integer)：byte， short， int，

long (数值范围见表)

浮点类型(Floating)：float，double

字符类型(Textual)：char (0～65535)　　　　　布尔类型(Logical)：boolean(true\false)

整型变量：

数据类型

所占位数

数的范围

byte

8

-27～27-1

short

16

-215～215-1

int

32

-231～231-1

long

64

-263～263-1

浮点型变量：

数据类型

所占位数

数的范围

float

32

3.4e-038 ～3.4e+038

double

64

1.7e-038 ～1.7e+038

复合数据类型：

class

interface

数组

常变量表示方法：1.常量：用保留字final来实现

final typeSpecifier

varName=value[,varName[=value]…];

如：final int NUM=100;

2.变量：Java 程序中基本存储单元，定义包括变量名、变量类型和作用域几个部分。其格式如下：

typeSpecifier

varName[=value[,varName[=value]…];

如：int count; char

c='a';按作用域来分，变量可以有下面几种：局部变量、类变量、方法参数和例外处理参数。在一个确定的域中，变量名应该是唯一的。

(二)简单数据类型中各类型数据间的优先关系和相互转换：不同类型数据间的优先关系如下：低------------------------------------------->高

byte,short,char-> int -> long

-> float -> double

自动类型转换规则如下：(先转化为同一类型，然后进行运算，转换从低级到高级)

操作数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

强制类型转换(高级数据要转换成低级数据)如：

int i;

byte b=(byte)i;

(三)运算符

1　算术运算符： +，―，*，/，%，++，――2　关系运算符：

>，=，<=，==，!=

3　布尔逻辑运算符：

!，&&，|| 4　位运算符：

>>，<>>，&，|，^，~5　赋值运算符

=，及其扩展赋值运算符如+=，―=，*=，/=等。6　条件运算符 ?

：(三目)7　其它：包括分量运算符·

，下标运算符 []，实例运算符instanceof，内存分配运算符new，强制类型转换运算符 (类型)，方法调用运算符 ()

等。

(四)表达式

布尔型表达式：

x&&y||z;

整型表达式： num1+num2;

运算符的优先次序：

优先次序(高->低)

运算符

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=

(五)控制语句：

◇

分支语句：if-else(条件),

switch(多分支)◇ 循环语句：while, do-while,

for◇ 与程序转移有关的跳转语句：break,

continue, return◇ 异常处理语句：try-catch-finally,

throw◇

注释语句：//，，(因新浪语法限制，可能无法显示)for循环：for( i=0, j=10; i

BlockLabel: { codeBlock }

break语句的第二种使用情况就是跳出它所指定的块，并从紧跟该块的第一条语句处执行。例如：

break BlockLabel；

break语句

a:{…… //标记代码块a

b:{…… //标记代码块b

c:{…… //标记代码块c

break b;

…… //此处的语句块不被执行

}

…… /此处的语句块不被执行

}

…… //从此处开始执行

}

continue从循环体中跳出转移到其他循环点

outer: for( int i=0; i<10; i++ ){ //外层循环

inner: for( int j=0; j<10; j++ ){ //内层循环

if( i

……

continue outer;

}

……

}

……

}

(六)数组

1． 一维数组的定义： type arrayName[

]；(type包括任何数据类型，包括简单和复合型)

例如：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的长度。4．二维数组的定义type arrayName[ ][ ]；

type [ ][ ]arrayName;5．二维数组的初始化◇ 静态初始化

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");//

为每个数组元素单独分配空间6．二维数组元素的引用：arrayName[index1][index2]

例如：

num[1][0];7．二维数组举例：两个矩阵相乘　　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();

}

}

}

(七)字符串的处理(java.lang.String类)

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

1．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);2．用StringBuffer表示字符串StringBuffer( ); //分配16个字符的缓冲区

StringBuffer( int len ); //分配len个字符的缓冲区

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

3. 访问字符串

(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()所返回的值通常是不同的。

4.修改字符串

(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中对字符串的连接操作是对源串本身进行的，操作之后源串的值发生了变化，变成连接后的串。

5.其他操作

(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不支持其它运算符的重载。