Java基础语法和函数

----------------------android培训、java培训、期待与您交流！ ---------------------- 

英语角:

•  synchronized  同步的；同步化的
•  implements    实施，执行
•  instance      实例，情况
•  transient     短暂的，暂态的
•  default       默认的
•  debug       调试，改正

一、关键字的定义、特点以及分类

定义：被Java语言赋予了特殊含义的单词

特点：关键字中所有字母都为小写

1、用于定义数据类型的关键字：

基本数据类型：byte、short、int、long、float、double、char、boolean

类类型：class、interface

空类型：void

  2、控制流程语句的关键字
表判断：if 、else、else if、  

表选择：  switch、case 、 default

表循环：while、for、do、break、continue

 if语句的特点：

 （1）for里面的连个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环

后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。

（2）while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放。而while循环使用的变量

在循环结束后还可以继续使用。

（3）最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制

循环。

switch语句的特点：

（1）switch语句选择的类型只有四种：byte，short，int ， char。

（2）case之间与default没有顺序。先执行第一个case，没有匹配的case执行default，default总是最后执行。  

（3）结束switch语句的两种情况：遇到break，执行到switch语句结束。

（4）如果case或者default没有对应的break，程序会继续执行可以执行的语句，直到遇到break或者switch结尾结束。

break和continue的区别：

• continue：应用于循环结构。打断当前循环，继续进行下一次循环。
• break： 应用于选择结构和循环结构。 用来改变程序执行流程，立刻跳出当前循环块并顺序执行下一句。
• 这两个语句离开应用范围，存在是没有意义的。
• 这个两个语句单独存在，下面都不可以有语句，因为执行不到。
• 标号的出现，可以让这两个语句作用于指定的范围。

	w:for(int x=0; x<3; x++)
		{
			for(int y=0; y<4; y++)
			{
				System.out.println("x="+x);
				break w;
			}				
		}
	此时，break直接跳出外循环。	

	w:for(int x=0; x<3; x++)
		{
			for(int y=0; y<4; y++)
			{
				System.out.println("x="+x);
				continue w;
			}				
		}
 此时，continue继续执行下一次外循环。

3、定义访问权限修饰符的关键字：private、protected、public

protected 受保护的

private 私有的。用于修饰类中的成员(成员变量，成员函数)。私有只在本类中有效。

public公有的。在方法和变量的声明中使用，它表示这个方法或变量能够被其它类中的元素访问。权限最大。

4、定义类、函数、变量修饰符的关键字：abstract、final、static、synchronized

abstract 抽象的。用于修饰类和函数 ，被abstract修饰的类和函数分别叫抽象类，抽象方法。

• 抽象方法一定在抽象类中。
• 抽象类不可以用new创建对象。因为调用抽象方法没意义。
• 抽象类中的抽象方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用。如果子类只覆           盖了部分抽象方法，那么该子类还是一个抽象类，这样做没有实际意义。
• 
  

abstract class Student//抽象类
	{
	abstract void study();//抽象函数
	void sleep()
		{
			System.out.println("躺着");
		}
	}




final 最终的。可用于修饰类、方法、变量。

• 被final修饰的类不可以被继承。为了避免被继承，被子类复写可以将该类用final修饰。
• 被final修饰的方法不可以被复写。
• 被final修饰的变量是一个常量只能被赋值一次。既可以修饰成员变量，也可以修饰局部变量。作为常量：常量的书  写规范所有字母都大写，如果由多个单词组成。单词间通过_连接。
• 内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量（后面会再次说到）。

     static静态的。用于修饰成员(成员变量，成员函数）不用于修饰类。当成员被静态修饰后，除了可以实例化对象后	被对象调用外，还可以直接被类名调用。被static修饰的成员的特点：

  
  
随着类的加载而加载。也就说，静态成员会随着类的消失而消失。说明它的生命周期在所有变量中最长。
优先于的对象存在明确一点：静态先存在，对象是后存在的。
被所有对象所共享
可以直接被类名所调用。格式：类名.静态成员。
静态使用注意事项：
1，静态方法只能访问静态成员。非静态方法既可以访问静态也可以访问非静态。
2，静态方法中不可以定义this，super关键字。因为静态优先于对象存在。所以静态方法中不可以出现this。
3，主函数是静态的。

5、定义类与类、类与接口之间关系的关键字： extends、implements

extends 继承

implements 实现

6、建立实例及引用实例、判断实例的关键字： new、this、super、instanceof

new 创建新的对象。

this 当前对象引用，代表它所在函数所属对象的引用。哪个对象在调用this所在的函数，this就代表哪个对象。当定义 类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。但凡本类功能内部使用了了 本类对象，都用this表示。

super代表父类对象的引用。

如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this。子类要访问父类中的同名变量用super。

7、异常处理的关键字try、catch、finally、throw、throws

处理异常的两种方式：捕获（try{ } catch（）{ }finally{ }）后面关于异常部分会详解。

抛出（throw和throws）

throw和throws的用法：

  
  
throw定义在函数内，用于抛出异常对象。
throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。
	当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，否则编译失败。
	注意，RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。

8、包的关键字： import、package

import 导入包。

package包。

在源文件的开始时导入后面将要引用的一个类或整个包，就不必在使用包中的内容的时候加上包的名字。

9、其他关键字： native、transient、volatile、assert

特殊：main不是关键字，只是能被JVM识别的一个名称。

二、Java中的标识符

1. 在程序中自定义的一些名称叫标识符。由26个英文字母大小写，数字：0-9 符号：_ $ 组成。
2.     定义合法标识符规则：1，数字不可以开头。2，不可以使用关键字。
3.         Java中严格区分大小写
4.     名称规范：

• 包名：多单词组成时所有字母都小写。

xxxyyyzzz

• 类名接口名：多单词组成时，所有单词的首字母大写。

XxxYyyZzz

• 变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。

xxxYyyZzz

• 常量名：所有字母都大写。多单词时每个单词用下划线连接。

  XXX_YYY_ZZZ

  注意：在起名字的时，为了提高阅读性，要尽量有意义。

三、常量与变量

常量表示不能改变的数值。 

Java中常量的分类： 

1，整数（int）常量。所有整数 

2，小数（float和double）常量。所有小数 

3，布尔型（boolean）常量。较为特有，只有两个数值。true false。

4，字符（char）常量。将一个数字字母或者符号用单引号( ' ' )标识。 

5，字符串（String）常量。将一个或者多个字符用双引号标识。

6，null常量。只有一个数值就是:null. 

对于整数java有三种表现形式。

     十进制：0-9 ，满10进1. 

   八进制：0-7 ，满8进1. 用0开头表示。

   十六进制：0-9，A- F，满16进1. 用0x开头表示。

进制间的转化：

  1）十进制转二进制：取2的余数运算

2）二进制转十进制：取2的幂运算

3）二进制转八进制：从右向左取二进制三位为一位，不足补0，算出每三位的十进制值（不超过7）。

4）二进制转十六进制：从右向左取二进制四位为一位，不足补0，算出每四位的十进制值。

十进制与十六进制数之间的对应关系：

1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	0
1	2	3	4	5	6	7	8	9	A	B	C	D	E	F	0

5）二进制的负数形式：取反后再求其补码

例：求-6的二进制：

              0000-0000  0000-0000  0000-0000  0000-0110   6的二进制表示

              1111-1111  1111-1111  1111-1111  1111-1001   将6的二进制数取反

            + 0000-0000  0000-0000  0000-0000  0000-0001   对取反后的数加1

          --------------------------------------------------------------------------------------------------

              1111-1111  1111-1111  1111-1111  1111-1010

则-6的二进制为：1111-1111  1111-1111  1111-1111  1111-1010。

说明：二进制的负数形式的最高位皆为1。

变量是内存中的一个存储区域。

该区域有自己的名称（变量名）和类型（数据类型），该区域的数据可以在同一类型范围内不断变化。

为什么要定义变量：用来不断的存放同一类型的常量，并可以重复使用。

 使用变量注意：

• 变量的作用范围（一对{  }之间有效）；
• 初始化值；
• 定义变量的格式：数据类型    变量名  =  初始化值；

注：格式是固定的，记住格式，以不变应万变。

理解：变量就如同数学中的未知数。

变量之间的类型转换：自动类型转换和强制类型转换

Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空 间。

整型(4种)： byte(1Byte)、int(4 Bytes )、short(2 Bytes )、long(4 Bytes) 

浮点型(2种)：float、double(8 Bytes ) 

布尔型（1种）boolean

字符型（1种）char (2B)

整数默认类型：int （4个字节，32位）   小数默认类型：double（8字节，64位）

表达式的数据类型自动提升的情况：

所有的byte型、short型和char的值将被提升到int型。

如果一个操作数是long型，计算结果就是long型；

如果一个操作数是float型，计算结果就是float型；

如果一个操作数是double型，计算结果就是double型。

分析  System.out.println(‘a’)与System.out.println(’a’+1) 的区别。

第一个‘a’是字符型，打印出来的是字母a。

第二个‘a’要和整型数1进行运算自动提升为整型。最终结果是98.

思考：

byte b1=3,b2=4,b;//第一句

b=b1+b2;//第二句

b=3+4;//第三句

哪句是编译失败的呢？为什么呢？

第二句编译失败。因为 b1+b2后的结果自动提升为整型，不能存入字节型变量中。

四、运算符和转移字符

算术运算符

      算术运算符的注意问题：

• • 如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数就另当别论。如-5%2=-1。
  • 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。 
  • “+”除字符串相加功能外，还能把非字符串转换成字符串 ，

例如：System.out.println("5+5="+5+5);//打印结果是？  结果：   5+5=  55。

赋值运算符

符号： = , +=, -=, *=, /=, %= 

示例： int a,b,c; a=b=c =3; int a = 3; a+=5;等同运算a=a+5; 

思考： short s = 3; 

     s=s+2; 

     s+=2; 有什么区别？

s=s+2编译时会报错。因为整数默认类型为int，s+2算得的结果是int类型，不能被存入short型变量中。

s+=2编译不会报错。因为 只进行一次赋值运算，将（ s  +2）的类型自动转换后赋给s.

 

比较运算符 

 注意1：比较运算符的结果都是boolean型，也就是要么是true，要么是false。

 2：比较运算符“==”不能误写成“=” 。

逻辑运算符 

  逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
 “&”和“&&”的区别：
 单&时，左边无论真假，右边都进行运算； 
 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
 “|”和“||”的区别同理，双或时，左边为真，右边不参与运算。 

 异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。

三元运算符：

格式： (条件表达式)?表达式1：表达式2； 

如果条件为true，运算后的结果是表达式1；

        如果条件为false，运算后的结果是表达式2； 

示例： 获取两个数中大数。 int x=3,y=4,z; z = (x>y)?x:y;//z变量存储的就是两个数的大数。

  转义字符：

1、概述：通过 \ 来转变后面字母或符号的含义。如：\n表示换行。

2、常用转义字符：

      \b：退格                        \n：换行

      \t：制表符，相当于tab键         \r：回车

      \\：表示反斜杠                  \'：表示单引号             \"：表示双引号