JAVA语言基础组成

1.   JAVA语言基础组成

1.1        关键字

1.2        标示符

1.3        注释

1.4        常量和变量

1.5        运算符

1.6        语句

1.7        函数

1.8        数组

1.1        关键字

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

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

关键字列表：

1.2        标示符

定义：在程序中自定义的一些名称

定义合法标示符规则：

由26个英文字母大小写，数字：0~9符号：_，$组成

数字不可以开头

不可以使用关键字

 注意：

JAVA中严格区分大小写

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

Java中的名称规范：

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

•   xxxyyyzzz

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

•   XxxYyyZzz

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

•   xxxYyyZzz

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

•   XXX_YYY_ZZZ

1.3 注释

三种注释
       （1）// 单行注释
       （2）/*多行注释*/ 多行注释中不能添加多行注释
       （3）/**JAVA*/JAVA特有的注释，其中注释的内容可以被JDK提供的工具javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。
       注释的作用：调试程序

1.4  常量与变量

常量：程序运行过程中，不会改变的量

变量：内存中的一个存储区域,该区域有自己的名称（变量名）和类型（数据类型）,该区域的数据可以在同一类型范围内不断变化。（如同数学中的未知数）

重点：变量的作用范围在一对{}内，如果这段语句执行结束，那么变量将会自动释放。

定义变量的格式：

数据类型    变量名  =  初始化值；

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

|--数据类型

  |--基本数据 类型

       |--数值型

             |--整数类型

                  |--byte：一个字节  

                  |--short：两个字节 

                  |--int:四个字节  

                  |--long:八个字节

             |--浮点类型

                  |--float:四个字节

                  |--double:八个字节

       |--字符型

             |--char:两个字节

       |--布尔型

             |--boolean:一位

  |--引用数据类型

       |--类（class）

       |--接口（interface）

       |--数组（[]）

整数默认类型：int； 小数默认类型：double；

int类型，占4个字节，1个字节是8位，取值范围是-2^7~2^7-1

double类型，占8个字节，占了64位，取值范围是-2^63~2^63-1

自动类型转换（理解：小杯的水倒进大杯中，不会出现任何问题）

强制类型转换（理解：大杯的水倒入小杯中，将会溢出，数据将会丢失精度）

代码示例：

class  DataStyle1
{
      public static void main(String[] args)
      {
           byte b = 3;
           //b = b+3;由于整数类型默认类型为int，这里将会报错，可能损失精度
           b =(byte)(b+3);//这里进行强制转换
           int c = b+9;//此时的b自动提升为int型数据
           char a = 'a';
           int d = a+2;
           char e = (char)(a+2);
           System.out.println("b="+b);
           System.out.println("c="+c);
           System.out.println("d="+d);
           System.out.println("e="+e);
      }
}

输出结果：

1.5  运算符

1.5.1算数运算符

算术运算符的注意问题

如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数就另当别论。

对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。(和数学中的整除一致)

例如：intx=3510;x=x/1000*1000;  x的结果是3000

“+”除字符串相加功能外，还能把非字符串转换成字符串，（这个要注意）

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

代码示例：

class MainMath
{
	public static void main(String[] args) 
	{
		int x=3510;
		x=x/1000*1000;
		System.out.println("x="+x);//整数间进行/运算，将会省略小数
		System.out.println(5%-2);//结果为1，和正常的模运算没区别
		System.out.println((-7)%4);//结果为-3
		System.out.println("5+5="+5+5);//运算步骤：1,”5+5=5“+5；2，5+5=55
	}
}

1.5.2 逻辑运算符

作用：逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。

逻辑运算符图表

总结：（面试题）

&与运算，必须两边都为ture时，结果才为true；

&&短路与运算，两边结果都为true时，结果才为true，左边为false，右边不在运算

|或运算，只要有一边为true，结果就为true

||短路或运算，只要有一边结果为true，那么结果就为true，并且，如果左边结果为true，右边不在运算

^异或运算，两边结果不同时，结果true

逻辑运算符和位运算符区别（最近老是搞混）

逻辑运算符的作用：用于布尔型表达式的连接

位运算符的作用：用于二进制之间的运算

他们中都有&和|运算符

逻辑运算符中，&运算符两边的表达式都为真，结果才为真；|运算符两边的表达式有一方为真，结果为真。

位运算符中，&运算二进制都为1，结果才为1；|运算二进制有一个值为1，结果为1.

代码示例:

class LuoJi
{
      publicstatic void main(String[] args)
      {
           inta = 9;
           intb = 7;
           intc = 4;
           intd =3;
           System.out.println((a>b)&(d>c));//结果为false
           System.out.println(!(a>b));
           System.out.println((a<b)&&(d<c));//左边为false后，右边不在进行运算
           System.out.println((a>b)|(d>c));//两边都要运算
           System.out.println((a>b)||(d>c));//左边为true后，右边不在进行运算
      }
}

运行结果：

1.5.3 位运算符

位运算符是直接对二进制进行运算

图例说明：

6<<3

6>>3

6|3

6&3

6^3

1.5.4 三元运算符

三元运算符格式：

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

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

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

代码示例

class ThreeMath
{
      public static void main(String[] args)
      {
           int a = 5;
           int b = 7;
           System.out.println((a<b)?a:b);//符合(a<b)这个条件输出a,否则输出b;
      }
}

1.6  语句

程序流程控制三大结构

1.6.1判断结构

if语句  三种格式

格式一：

if(条件表达式)

{

       执行语句；

  }

格式二：

if(条件表达式)

{

        执行语句；

}

else

{

       执行语句；

  }

格式三：

if(条件表达式)

{

       执行语句；

}

elseif (条件表达式)

{

       执行语句；

}

……

else

{

       执行语句；

}

注意：当if语句有运算结果时，可以和三元运算符相互转换 

代码示例：

class ThreeMath
{
	publicstatic void main(String[] args)
	{
       		inta = 5;
       		intb = 7;
       		System.out.println((a<b)?a:b);//符合(a<b)这个条件输出a,否则输出b;
       		/*
       		下面语句可以转换为(a<b)?a:b
       		if(a<b)
       		{
            	 	System.out.println(a);
       		}else
       		{
             		System.out.println(b);
       		}
      	 	*/
	}
}

1.6.2选择结构

switch语句

格式：

switch(表达式)

{

case取值1:

       执行语句；

       break；

case取值2:

       执行语句；

       break；

…...

default:

       执行语句；

       break；

}

Switch语句的特点：

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

case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。

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

如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。

1.6.3循环结构

while语句

格式：

while(条件表达式)

{

执行语句；

}

do while语句

格式：

do

{

执行语句；

}while(条件表达式);

for语句

格式：

for(初始化表达式；循环条件表达式；循环后的操作表达式)

{

执行语句；

}

总结：

while语句和dowhile语句的区别：

while语句：先判断条件，只有条件满足才执行循环体

dowhile语句：先执行循环体，再判断条件；循环体至少会被执行一次。

while语句和for语句的区别：

1.   变量的作用域不同。for语句中定义的变量，在for语句执行结束后，自动释放；while语句中，由于变量是定义在while语句外的，所以只要还有语句使用这个变量那么这个变量就一直存在；

2.   while语句和for语句是可以相互转换的，如果需要定义循环增量，用for更合适。

代码示例：

class WhileFor
{
	publicstatic void main(String[] args)
	{
      		for(int a = 0;a <9 ;a++ )
      		{
            		System.out.println(a);
      		}
      		//System.out.println(a);因为变量a的范围只在for语句中有效，所以此处使用a会报错
      		intb =0;
      		while(b<9)
      		{
           	 	System.out.println(b);
            		b++;
      		}
      		System.out.println(b);//变量b定义在main函数内，所以，变量b在整个main函数中有效
	}
}

1.6.4 其他循环控制语句

break语句和continue语句的区别

break语句（跳出）

break语句应用于选择结构和循环结构中

break语句用于跳出循环，不再执行循环

continue语句（继续）

continue语句应用于循环结构中

continue语句用于结束此次循环，执行下次循环

标号是用来给循环起名称的，在嵌套循环中，break和continue后加上标号，那么此标号规定了break和continue的作用范围。

代码示例：

class  BiaoHao
{
	publicstatic void main(String[] args)
	{
      		outer:
      		for(int a = 0;a<5 ;a++ )
      		{
            		inner:
            		for(int b = 0;b <3 ;b++ )
            		{
                 		System.out.println("b="+b);
                 		break inner;//跳转出inner：for循环
            		}
            		System.out.println("a="+a);
            		continue outer;//结束此次循环，继续下次循环
      		}
	}
}

1.7函数

定义：函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。

函数的格式：

修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2)

{

执行语句;

return返回值;

}

返回值类型：函数运行后的结果的数据类型。

参数类型：是形式参数的数据类型。

形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。

实际参数：传递给形式参数的具体数值。

return：用于结束函数。（当返回值类型为void时，可以省略return语句）

返回值：该值会返回给调用者。

函数的特点：

定义函数可以将功能代码进行封装

便于对该功能进行复用

函数只有被调用才会被执行

函数的出现提高了代码的复用性

对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。

定义函数时的两个明确：（经典）

定义函数时，首先要明确这个函数有没有返回值，如果有，是什么数据类型？如果没有，使用void
其次，要明确是否有未知参数参与运算，如果有，分别定义这些参数

代码示例：

/**
需求：求任意两个整数的和
分析：定义一个函数，具备求和功能，其返回值类型是int型，需要传入两个参数，定义两个参数
*/
class Function
{
      public static void main(String[] args)
      {
           int sum = sum(5,6);
           System.out.println(sum);
      }
      public static int sum(int a,int b)//定义一个sum函数，返回值类型是int型
      {
           int sum = 0;
           sum = a + b;
           return sum;
      }
}

函数的重载：

在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。

重载的特点：与返回值类型无关，和参数列表有关

重载的好处：方便阅读，优化了程序设计

1.8数组

1.8.1 一维数组

定义：同一种类型数据的集合。其实数组就是一个容器。

格式：

1，元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

示例：int[] arr = new int[5]; 这里的5是数组中元素的个数，不是角标，切记

2，元素类型[] 数组名 = new 元素类型[]{元素，元素，……};

int[] arr = new int[]{3,5,1,7};

int[] arr = {3,5,1,7};

1.8.2二维数组

格式1.

int[][] arr = new int[3][2];

定义了名称为arr的二维数组

二维数组中有3个一维数组

每一个一维数组里有2个元素

一维数组的名称分别为arr[0], arr[1], arr[2]

给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;

格式2. 

int[][] arr = int[3][];

二维数组中有3个一维数组

每个一维数组都是默认初始化值null

可以对这个三个一维数组分别进行初始化

  arr[0] = new int[3];

  arr[1] = new int[1];

  arr[2] = new int[2];

格式3：

int[][] arr ={{3,8,2},{2,7},{9,0,1,6}};

定义一个名称为arr的二维数组

二维数组中的有三个一维数组

每一个一维数组中具体元素也都已初始化

第一个一维数组 arr[0] = {3,8,2};

第二个一维数组 arr[1] = {2,7};

第三个一维数组 arr[2] = {9,0,1,6};

第三个一维数组的长度表示方式：arr[2].length;

注意特殊写法情况

int[] x 一维数组

int y[]二维数组

1.8.3数组内存结构

一维数组内存结构图图示：

二维数组内存结构图图示：

以一维数组为例，描述初始化数组时，内存空间演变的过程

int[] arr =  new int[2];

1，当定义一个数组时，堆内存中开辟了一片空间，这片空间有其对应的地址值

2，这片空间分为两块，分别存储arr[0],arr[1]，并进行默认初始化，值为0.

3，栈内存中开辟一个空间，用于存储变量arr,堆内存中空间的地址值将赋给arr，此时arr指向堆内存中的数组

4， 当该数组使用完毕，栈内存中的arr将会自动被释放，堆内存中的数组没有了引用，就变成了垃圾，垃圾回收机制会在某一时间将其清除

总结：

栈内存和堆内存

变量存储于栈内存中，当变量不在使用时，会被内存自动释放

数组和对象通过new关键字创建并存储在堆内存中，这些就是所谓的实例对象，每个实例对象在内存中都有其对应的地址值，实例中的变量都有默认初始化值，当这些数组和对象不再被使用时，将会被垃圾回收器当做垃圾清理掉

数组操作中常见的异常

1，        数组角标越界异常(ArrayIndexOutOfBoundsException)

2，        空指针异常(NullPointerException)

常见的转义字符

\n:换行\b:退格（相当于backspace）           \r:按下回车键

\t:制表符（相当于Tab键）