java基础语法

java基础语法

Java 语法介绍(一):Java语言的基本组成

Java语言主要由以下五种元素组成：标识符、关键字、文字、运算符和分隔符。这五种元素有着不同的语法含义和组成规则，它们互相配合，共同完成Java语言的语意表达。下面我们分别予以讲解。

1：标识符

　　变量，类和方法都需要一定的名称，我们将这种名称叫做标识符。Java中对标识符有一定的限制。

首先：所有的标识符的首字符必须是字母（大小写）、下划线＿或美元符￥；其次标示符是由数字（0--9），所有从A--Z的大写字母、a--z的小写字母和下划线＿、美元符￥和所有在十六进制0xc0前的ASCII码等构成；第三注意表示符不能使用系统保留的关键字做标示符。

　以上是标识符命名的基本规则，以下是一个正误对照表，通过它会对标识符的命名规则有一个更好的了解：

　　　　　　合法标识符　　非法标识符

　　　　　　try　　　　　　try#　　 （注：不能用#作为标示符）　　　　　

　　　　　　group_7　　　　7group （注：不能用数字符号开头）

　　　　　　opendoor　　　 open-door （ 注：不能用下-作为标示符号）

　　　　　　boolean_1　　　boolean (注：boolean 为关键字，不能用关键字做标示符)

2：关键字

　　关键字是Java语言本身使用的标识符，它有其特定的语法含义。所有的Java关键字将不能被用作标识符，Java的关键字有：

abstract、continue、for、new、switch、boolean、default、goto、null、synchronized、break、do、if、package、this、byte、double、implements、private、threadsafe、byvalue、else、import、

protected、throw、case、extends、instanceof、public、transient、catch、false、int return、

true、char、final、interface、short、try、class、finally、long、static、void、const、 float

、native、super、while等。

3：数据类型

　　Java有着不同的数据类型，Java的数据类型有：整型、浮点型、布尔型、字符型、字符串型。

　　整型数据是最普通的数据类型，它的表现方式有：十进制、十六进制和八进制。十六进制整数必须以0X作为开头。

　　每一个整型数据占有32位的存储空间，即四个字节。这意味着整型数据所表示,的范围在-2,147,483,648和2,147,483,648之间，假如由于某些原因，你必须表示一个更大的数，64位的长整型应该是足够的。如果你想把一个整数强制存为一个长型（long），你可以在数字后面加字母l。

　　浮点数据用来代表一个带小数的十进制数。例如1.35或23.6。是浮点数的标准形式，还可以用科学计数法的形式，下面是一些例子：

　　3.1415926　　0.34　　.86　　.01234　　9.999E8

　　标准的浮点数叫做单精度浮点数，它的存储空间为32位，也就是四个字节。也有64位的双精度浮点数。你可以用D后缀确定你想使用这种双精度浮点数。

　　布尔类型是最简单的一种数据类型，布尔数据只有两种状态：真和假，通常用关键字true和false来表示这两种状态。

　　字符型数据是由一对单引号括起来的单个字符。它可以是字符集中的任意一个字符，如：´a´，´b´字符串数据类型是用一对双引号括起来的字符序列，字符串数据实际上是由String类所实现（类这个概念我们将在后续章节中详细讲解），而不是Ｃ语言中所用的字符数组。每一个字符串数据将产生一

个String类的新的实例，读者不必对字符串与类这个概念发生关系而感到担心，由于类的特性，你不必担心如何去实现它们，它们会自己照顾好自己，需要说明的是字符串在Java里作为类只是出于安全的考虑。

　　下面给出了几个字符串的例子

　　　　"How are your"

　　　　"I am Student

4：运算符

　　任何语言都有自己的运算符，Java语言也不例外，如＋、－、＊、／等都是运算符，运算符的作用是与一定的运算数据组成表达式来完成相应的运算。对不同的数据类型，有着不同的运算符。

5：分隔符

　　分隔符用来使编译器确认代码在何处分隔。‘’‘’‘;’‘:’都是Java语言的分隔符。

Java 语法介绍(二):运算符

1：优先级

　优先级是指同一式子中多个运算符被执行和次序，同一级里的操作符具有相同的优先级，相同优先级得操作符号相遇是，根据结合性决定运算次序，下面从高到低的优先级列出了运算符。同一行中的运算符优先级相同。

　　.　　[]　　() 　　结合性从左到右

　　++　　--　　!　　~ 　　结合性从左到右

　　*　　/　　% 　　结合性从左到右

　　+　　- 　　结合性从左到右

　　<<　　>>　　>>> 　　结合性从左到右

　　<　　>　　<=　　>= 　　结合性从左到右

　　==　　!= 　　结合性从左到右

　　& 　　结合性从左到右

　　^ 　　结合性从左到右

　　&& 　　结合性从左到右

　　|| 　　结合性从左到右

　　?: 　　结合性从右到左

　　= 　　结合性从右到左

　　例如对于表达式：a=b+c*d/(c^d)，因为括号优先级最高，所以先计算c^d，接着是c*d，然后除以c^d，最后，把上述结果与b的和存储到变量a中。

2：整型运算符

　　整型运算符按操作数的多少可分为一元和二元两类，一元运算符一次对一个变量进行操作，二元运算符一次对两个变量进行操作。对于运算来说，如果有一个变量或操作数是长整型的，那么结果就肯定是长整型的，否则即使操作数还没有确定是字节型、短整型或字符型，运算结果都是整型，下表是一元运算符。

运算符 实际操作 例子

　　- 　　改变整型数符号 　　-i

　　~ 　　位运算：非 　　~i

　　++ 　　加1 　　i++

　　-- 　　减1 　　i--

注：一元取反运算符（－）用来改变整数的正负号，逐位求反把所变量所有是1的位变成0，是0的位变成1，加加和减减（＋＋，－－）把变量的值加1或减1。

　　以下是一个具体例子：

　　int i=0;

　　int j=1;

　　for (i=1;i<10;i++)

　　{

　　j--;

　　System.out.println(i+""+j+"");

　　}

　　一元运算符执行的方式是改变它们所作用的变量的值，对一元取反和逐位求反来说，变量的值并不

改变，而对加和减运算（＋＋，－－）来说，就量的值被改变了，例如：

　　　　int i=10,j=10,k=10,l=10;

　　　　System.out.println(i+""+j+""+k+""+l+"");

　　　　j++;

　　　　i--;

　　　　~k;

　　　　-l;

　　　　System.out.println(i+""+j+""+k+""+l+"");

　　注意：j和i被改变并打印出它们的新值，可是k和l仍然为原来的数值，当在复合表达式中使用一元取反和逐位求余运算时，你实际上是在用一个临时存贮操作数的新值。

　　＋＋和－－既是前置运算符也是后置运算符，这就是说，它们既可以放在操作数前面（＋＋x），也可以放在后面（x＋＋），如果它们被用在复合语句中如：

　　　　i=x++; 或 i=++x;

　　那么第一个语句中x把值赋给i以后再加1，而第二个语句先把x加1，再把新的x值赋给i。

　　整型运算符的第二种类型是二元运算符，这种运算并不改变操作数的值，而是返回一个必须赋给变量的值，下表列出了二元运算符。

运算符 实际操作 例子

　　+ 　　加运算 　　a+b

　　- 　　减运算 　　a-b

　　* 　　乘运算 　　a*b

　　/ 　　除运算 　　a/b

　　% 　　取模运算 　　a%b

　　& 　　与运算 　　a&b

　　| 　　或运算 　　a|b

　　^ 　　异或运算 　　a^b

　　<< 　　左移 　　a<<b

　　>> 　　右移 　　a>>b

　　>>> 　　右移 　　a>>>b

注意：>>与>>>的基本功能都是右移，但>>是用符号位来填充右移后所留下的空位，而>>>则是用零来填充右移后所留下的空位。

　　还有一类运算，它们形如：j-=i，这里-=是二元运算-和赋值运算=的复合运算，它等价于j=j-i，这种复合方式适用于所有的二元运算符。

　　这里有几点关于整型运算进一步说明，首先，整数除法向靠近0的方向取整；其次，如果你除以0或者对0取模，程序就会在运行时被强行中止，如果你的运算结果超出最小极限，或者说是下溢，结果将为0，如果超出了最大极限，就将会导致结果的回绕。

3：布尔运算符

　　另外还有一些运算符能产生布尔类型的结果，我们把它们称为布尔运算符，下表列出了这些运算符。

运算符 实际操作 例子

< 小于 a<b

> 大于 a>b

<= 小于等于 a<=b

> 大于等于 a>=b

== 等于 a==b

!= 不等于 a!=b

　　在这里要指出的是相等运算符==可能会给你带来许多麻烦，很多人在比较两个值时往往错用了等号=，以致于变成了赋值操作，所以在编程中一定要注意你在比较数值时用的是==。布尔类型本身还有几个逻辑运算符，它们可以对布尔类型的数据进行运算：!,&&,//

　　其实如果你把布尔类型的值true等效地看成1，false看成0，那么对于相同的运算符，整型运算的法则对布尔类型也是适用的。

　　布尔运算符中还有一种三元运算符，它的格式如下：

　　Operand ? Statement1:Statement2在这个式子中，先计算Operand的真假，若为真，则执行Statement1，若为假，则执行Statement2。

下面的代码给出了这种运算的一个例子：

　　(a>b)?a:b;

　　这个表达式将返回a和b中较大的那个数值。

4：浮点型运算符

　　传统的浮点型二元运算除了赋值运算符(+=,-=.*=./)取模(%)和取模赋值(%=0)使浮点数值等价于整数除法，同样，++和--使变量的值增加或减小1。

　　同整型变量相似，结果被放在最大长度的类型里，如果运算包括两个浮点类型，结果也是个浮点类型，如果有一个或几个是双精度浮点型，结果就是双精度浮点型，当你使用关系运算符：>、<、>=、<=、==和!=时，注意浮点变量与整型的不同，只有a==b成立并不能说明a<b和a>b不成立，这是因为浮点类型数值次序同整型不同，当你写程序，对浮点型数值进行假设时要小心，浮点型数值也包括inf，代表无穷大，溢出产生无穷大inf，下溢产生0。

5：字符串运算符+运算符可以把字符串并置起来，如果哪一个操作数不是字符串，在并置之前它会被转换成字符串，另外，+=运算符把两个字符串并置的结果放进第一个字符串里，在前面的例子里，当你想把几项打印在同一行里时使用的是+运算符，试着在解释器里用System.out.println和+运算符来造成不同的组合输出。

Java 语法介绍(三):变量

为了在Java中存储一个数据，必须将它容纳在一个变量之中。而数据类型决定了一个变量可以赋给什么值以及对变量进行什么样的操作。定义一个变量的两个基本要素是：类型和标识符，通常你可以用如下

语法去说明变量：

　　type identifer[,identifer]; 　　该语句告诉编译器用“type”的类型和以“identifer”为名字建立一个变量，这里的分号将告诉编译器这是一个说明语句的结束；方格中的逗号和标识符表示你可以把几个类型相同的变量放在同一语句进行说明，变量名中间用逗号分隔。

　　在你创建了一个变量以后，你可以给它赋值，或者用运算符对它进行一些运算。类型将决定变量所代表的不同种类的数据，在Java语言中有两种变量。最基本的是简单类型变量，他们不建立在任何其他类型上，整数、浮点、布尔和字符类型都是这类型（注意和其他编程语言不太一样一点是，字符串在这里是作为一个类的实例出现）；另外Java可以定义构造另一种变量类型：类，这些类型建立在简单类型之上，它包括数值、变量和方法，是一种数据与代码相结合的复合结构。

1： 整型变量的说明

　　整型变量按所占内存大小的不同可分为四种不同的类型，最短的整型是byte，它只有八位长，然后是短整型short，它有16位，int类型有32位，长整型long是64位，下面是这些整型变量的说明示例。

　　　　byte bCount; （内存中占用： 8 Bits）

　　　　short sCount; （内存中占用：16 Bits）

　　　　int nCount; （内存中占用：32 Bits）

　　　　long LCount; （内存中占用：64 Bits）

　　　　int nx,ny,nz; （内存中占用：32 Bits）

2：浮点变量的说明

　　浮点类型可用关键字float或double来说明，float型的浮点变量用来表示一个32位的单精度浮点数，而double型的浮点变量用来表示一个64位的双精度浮点数。double型所表示的浮点数比float型更精确

　　　float areas;

　　　　double weihgt;

3：字符变量说明

　　Java使用16位的Unicode字符集。因此Java字符是一个16位的无符号整数，字符变量用来存放单个字符。例如：

　　　　char a;

　　　　a=´c´;

4：布尔变量说明

　　布尔型有真和假两个逻辑值，另外，逻辑运算符也将返回布尔类型的值，例如：

　　boolean onClick;

　　mouseOn=true;

　　布尔型是一个独立的类型，Java中的布尔类型不代表0和1两个整数，不能转换成数字。

5：变量的使用范围

　　当你说明了一个变量后，它将被引入到一个范围当中，也就是说，该名字只能在程序的特定范围内使用。变量的使用范围是从它被说明的地方到它所在那个块的结束处，块是由两个大括号所定义的，例

如：

class Example

public static void main(String args[])

int i;

......

public void function()

char c;

......

　　整型变量i在方法main中说明，因为main的块不包括function块，所以任何在function块中对i的引用都是错误的。对字符型变量c也同样如此。

　　在某一个特定情形中，变量能被别的变量所隐藏，如：在一个块中说明一个变量，而在这个块中建立一个新块并且在其中定义相同名字的变量，这样在第二个块中，程序对该变量的使用均是指第二次定义的那个变量。这样我们说，第一个变量被隐藏了，作者并不建议采用这种定义变量的方法。变量隐藏的示例如下：

class Example

public static void main(String args[])

int i; // * * *

boolean try=true;

while(try)

int i; //以下对变量i的引用均指这里定义的i

......

//以下对变量i的引用均指* * *处定义的i

......

　　当你定义一个变量时，首先必须明确它的活动范围，并根据它的实际功能来命名，此外还应尽量使用详细的注释，这些办法可以使你能够清晰地区分变量，变量被隐藏的问题也会大大减少。

6：类型转换

　　系统方法System.in.read返回一个整型数值，但你却常常想要把它当作一个字符来使用。现在的问题是，当有一个整数而你需要把变成一个字符时应当去做些什么呢？你需要去做一个类型转换为一个字符。从一种类型转换到另一种类型可以使用下面的语句：

　　　　int a;

　　　　char b;

　　　　a=(int)b;

　　加括号的int告诉编译器你想把字符变成整型并把它放在a里，另一方面，如果你想做相反的转换，你可以使用：

　　　　b=(char)a;

　　记住整型和字符型变量位长不同是非常重要的，整型是32位长，字符型是16长，所以当你从整型转换到字符型可能会丢失信息。同样，当你把64位的长整型数转换为整型时，由于长整型可能有比32位更多的信息，你也很可能会丢失信息。即使两个量具有相同的位数，比如整和浮点型（都是32位），你在转换小数时也会丢失信息，Java不允许自动类型转换，当你进行类型转换要注意使目标类型能够容纳原类型的所有信息，不会丢失信息的类型转换有：

原始类型 　　　　目标类型

byte -〉short -〉char -〉int -〉long -〉float -〉double

short -〉int -〉long -〉float -〉double

char -〉int -〉long -〉float -〉double

int -〉long -〉float -〉double

long -〉float -〉double

float -〉double

　　需要说明的是，当你执行一个这里并未列出的类型转换时可能并不总会丢失信息，不过进行这样一个理论上并不安全的转换是很危险的。

Java 语法介绍(四):数组

1：数组说明

　数组是Java语言中的特殊类型。它们存放能通过索引来引用的一系列对象，另外，你可以定义数组的

数组，下面是一些示例：

int i[];

char C[];

float f[][];

2：数组运算符

　　在JAVA中数组的分配是通过使用new运算符建立数组然后把它赋给变量，如：

　　　　int i[]=new int[10];

　　前面这个例子建立了一个包括10个整型变量的数组并把它赋给i，你将得到按数字顺序的变量i[0]，i[1]，......，i[8]，i[9]，注意下标是从第一个元素的0开始，到数组个数减1。

　　数组的使用与变量相同，每一个数组成员都可以被用在同类变量被使用的地方，Java也支持多维数组。

　　　　char c[][]=new char[10][10];

　　　　float f[][]=new float[5][];

　　清注意在第二个说明中只有一维的尺度被确定，Java要求在编译时（即在源代码中）至少有一维的尺度被确定了，其余维的尺度可以在以后分配。

　　数组主要用于你有大量相关数据想要存贮在一起而且能够简单地通过数字访问它们，数组是非常强有力的。

Java 语法介绍(五):条件控制

条件控制:if和switch

1：条件语句

条件语句是程序设计中最常用的语句，用他来选择程序的执行流程，Java中的基本条件判断语句是if...else...语句。其机构为：

if (条件表达式)

{

语句1

}

Else

{

语句2

}

语句3

　“条件表达式”的值为真时执行“语句1”，然后执行语句3；否则执行“语句2”，然后执行语句3。

　下面是一个用if--else语句构造多分支程序的例子：

if(a>5) b=1

else if(a>4) b=2

else if(a>3) b=3

...

else b=-1;

2：switch分支结构（开关语句）

　　switch分支结构用于多条件选择，虽然在多条件选择的情况下，也可以使用if...else...结构来实现，但是使用开关语句会使程序更为精炼、清晰。开关语句得格式为：

switch(条件表达式)

{

case 常量表达式1:

语句1 ;

break ;

case 常量表达式2:

语句2 ;

break ;

//......

case 常量表达式n:

语句n ;

break ;

default:

//

break

}

　　开关表达式首先计算出条件表达式的值，如果其值等于某个常量表达式，则执行该常量表达式后的语句，如果其值与所有的常量表达式的值不相等，则执行defualt后的语句。

　　在switch语句中，你通常在每一种case情况后都应使用break语句，否则，第一个相等情况后面所有的语句都会被执行，这种情况叫做落空。你可以试着分别加上去和去掉break语句来执行下面的例子：

class Switch Test

public static void main(String args[])

throws java.io.IOException

char a;

System.out.println("Enter a number from 1--3:");

a=(char)System.in.read();

switch(a)

case´1´:System.out.println("win a Car!");break;

case´2´:System.out.println("picked the goat");break

case´3´:System.out.println("get to keep your 100");

break;

default:System.out.println("entry");

　　在代码中加break语句后，你应明确知道程序将会发生的变化，并要确认程序没有转移到你不想执行代码上。

　　掌握了以上这些基本语句之后，你可以写更加实际点的程序了，下面这个程序计算从终端输入的数字和字符的数量。

class SwitchTest

public static void main (String args[])

throws java.io.IOException

int numberOfDigits=0,numberOfSpaces=0,numberOfOthers=0;

char c;

while((c=(char)System.in.read())!=´´)

switch(c)

case´0´:

case´1´:

...

...

case´8´:

case´9´:numberOfDigits++;break;

case´ ´:numberOfSpaces++;break;

default:numberOfOthers++;break;

System.out.println(":");

System.out.println("Number of digits="+numberOfDigits+"");

System.out.println("Number of spaces="+numberOfSpaces+"");

System.out.println("Number of others="+numberOfOthers+"");

　　代码的while循环从键盘读入字符直至输入一个回车符，循环内部的switch语句先把它和数字比较，当发现相等时，它就使对应的统计变量的值加1，然后break语句结束switch语句，程序回到等待键盘输入的状态。程序中，在default语句中的break是不必要的，不过加上它可以使程序风格保持一致。

Java 语法介绍(六):循环

循环: for,while和do

　　Java中有三种循环控制语句，他们是：for语句、while语句和do语句，下面分别说明这三种语句的结构。

1：for循环

for语句的格式为：

　　for (初始化语句; 条件语句; 控制语句)

　　{

　　　　语句1 ;

　　　　语句2 ;

　　　　语句n ;

　　}

　　　for 语句的执行顺序是：首先执行“初始化语句”；然后测试“条件语句”；若条件成立，则执行语句1到语句n；然后执行“控制”语句；接着再测试条件语句是否成立，如果成立则重复执行以上过程，直至条件不成立时才结束for循环。如：

for(i=0;i<10;i++)......;

　　int i,a[]=new int[10];

　　for (i=0,i<10;i++) a[i]= 0;

　这段代码把整型数组a中的所有元素都赋成0。

　　你可以在for循环的头部说明你的变量，而且最后一个表达式可以省略，不过要确定在语句中对变量的值有所改变，如：

　　for(int i=0;i<=10;) i+=i;

　　for循环中，“初始化语句”、“条件语句”和“控制语句”都可以省略，但是其间的分号不能省略。例如：

　　int i =0 ;

　　for (; ; ;)

　　{

　　　　if i>10 break ;

　　　　i = i +1 ;

　　}

for循环中省略“条件语句”时，在for语句{}中必须包换转句语句控制程序在某个条件满足时跳出for循环，否则将形成死循环

2：while循环

　while循环和for循环类似，其格式为：

　　while (条件语句)

　　{

　　　　语句1 ;

　　　　语句2 ;

　　　　....

　　　　语句n ;

　　}

　　执行while时，先测试“条件语句”，如果条件成立，则执行语句1到语句n，直至条件不成立时调处循环。

　　int i=0 ;

　　while (i<10)

　　{

　　 i++ ;

　　 System.out.println("Hey!.get me out of here!:);

　　}

3：do ... while 循环

　　do ... while 循环语句的格式为：

　　do

{

　　　　语句1 ;

　　　　语句2 ;

　　　　....

　　　　语句n ;

}

　　while (条件语句) ;

　　do ...while 语句的功能是首先执行语句1到语句n，然后进行条件测试，如果条件成立，则继续执行语句1到语句n，否这跳出循环。如：

　　boolean test=false;

　　do

　　{

　　......

　　}

　　while(test);

　　这种控制并不是很常用，但有时却非常重要，使用时注意结尾处while语句后的分号。

Java 语法介绍(七):Brake和Label

1：break

　 break语句提供了一种方便的跳出循环的方法。

boolean test=true;

　　int i=0;

　　while(test)

{

　 　 i++;

　 　if(i>=10) break;

}

　执行这段程序时，尽管while条件表达式始终为真，全循环只运行10次。

2：标号label

　　标号提供了一种简单的break语句所不能实现的控制循环的方法，当在循环语句中遇到break时，不管其它控制变量，都会终止。但是，当你嵌套在几层循环中想退出循环时又会怎样呢？正常的break只退出一重循环，你可以用标号标出你想退出哪一个语句。

char a;

　　outer: //this is the label for the outer loop

　　for(int i=0;i<10;i++)

　　{

　　for(int j=0;j<10;j++)

　　　　{

　　　　　　a=(char)System.in.read();

　　　　　　if(a==´b´)

　　　　　　　　break outer;

　　　　　　if(a==´c´)

　　　　　　　　continue outer;

　　　　}

　　}

在这个例子中，循环从键盘接受100个输入字符，输入“b”字符时，break outer语句会结束两重循环，注意continue outer语句，它告诉计算机退出现在的循环并继续执行outer循环。

最后

以上就是害羞野狼为你收集整理的java基础语法的全部内容，希望文章能够帮你解决java基础语法所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。