Java语言基础

1.关键字

关键字：被java语言赋予了特殊含义的单词。

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

例：class,interface,byte,short,int,long,float,double,char,boolean,void,

true,false,null;

       if,else,seitch,case,default,while,do,for,break,continue,return;

       private,protected,public;

       abstract,final,static,synchronized;

       extends,implements;

       new,this,super,instanceof;

       try,catch,finally,throw,throws;

       package,import;

       native,strictfp,transient,volatile,assert.

2.标识符

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

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

定义合法标识符规则：

       1.数字不可以开头。

       2.不可以使用关键字。

Java中严格区分大小写。

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

3.注释

单行注释：“   //   ”

多行注释：“   /* 注释内容 */   ”

单行注释可嵌套单行注释，也可嵌套多行注释；多行注释可嵌套单行注释，但不可嵌套多行注释

文档注释：“   /**  文档注释内容 */   ”

注释作用：注解说明，调试程序。

4.常量和变量

4.1常量：不能改变的数值。

     分类：整数（二进制-负数为对应正数取反加1，八进制‘0’开头，十进制，十六进制‘0x’开头），小数，布尔型，字符，字符串，null

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

      意义：用来不断地存放同一类型的变量，并可以重复使用

      注意：变量的作用范围（一对｛｝之间有效）；初始化值

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

4.3数据类型

      整数型默认：int       浮点型默认：double

数据类型

基本数据类型				引用数据类型
数值型		字符型（char）	布尔型（boolean）	类（class）	接口（interface）	数组（[]）
整数类型（byte,short,int,long）（1，2，4，8字节）（8，16，32，64位）	浮点类型（float,double）（4，8字节）（32，64位）

5.运算符

运算符

算术运算符	+，-，*，/，%（取余，模运算），++（自增1），--（自减1），
赋值运算符	=，+=（a+=1 <==> a=a+1自动强制转换），-=，*=，/=，%=
比较运算符	<, >, ==, !=, >=, <=, instanceof（结果只能是true或false）
逻辑运算符 （用于连接两个boolean类型表达式）	&（与，只有两边都为true，结果才为true）； |（或，两边有一个为true，结果就为true）； ^（异或，两边结果相同，结果是false；两边结果不同，结果是true）； ！（非）； &&（短路与，左边false，右边不再判断，结果为false）； ||（左边true，右边不再判断，结果为true）
位运算符	<<左移，>>右移（高位原来是什么就用什么补位），>>>无符号右移（高位用0补位），&与运算，|或运算，^异或运算（一个数异或同一个数两次，还等于原数，6^3^3=6），~反码
三元运算符	（条件表达式）？true的结果：false的结果

int i = 0;
int j = i++;    //j=0

//等同于
int temp = i;
i = i+1;
j = temp;

/*********************/

short s = 3;
s += 4;    //等同于 s = (short)(s + 4);
s = s + 4;    //类型报错

	//对两个整数变量的值进行互换 (不需要第三方变量)
	int a = 3,b = 5;
	System.out.println("a="+a+",b="+b);

	/*
	开发时，使用第三方变量的形式，因为阅读性强。
	int c ;
	c = a;
	a = b;
	b = c;
	*/


	//这种方式不要用，如果两个整数的数值过大，会超出int范围，会强制转换。数据会变化。
	/*
	a = a + b; //a = 3 + 5;a = 8;
	b = a - b; //3+5-5 = 3;b = 3;
	a = a - b; //3+5-3 = 5;a = 5;
	*/
		
	
	//面试的时候用。
	a = a ^ b; //a = 3 ^ 5;
	b = a ^ b; //b = (3^5)^5; b = 3;
	a = a ^ b; //a = (3^5)^3; a = 5;
	

6.语句

6.1判断结构

if语句：3种格式

/*
1 
if (条件表达式) {
    执行语句;
}

2
if(条件表达式) {
    执行语句;
}else {
    执行语句;
}

3
if(条件表达式) {
    执行语句;
}else if (条件表达式) {
    执行语句;
}
......
else {
    执行语句;
}

6.2选择结构

/*
    switch(表达式) 表达式结果类型：byte,short,int,char
    {
        case 取值1:
            执行语句;
            break;
        case 取值2:
            执行语句;
            break;
        ......
        default:
            执行语句;
            break;
    }

if和switch的应用：

if:
	1,对具体的值进行判断。
	2,对区间判断。
	3,对运算结果是boolean类型的表达式进行判断。

switch:
	1,对具体的值进行判断。
	2,值的个数通常是固定的。
	对于几个固定的值判断，建议使用switch语句，因为switch语句会将具体的答案都加载进内存。
	效率相对高一点。

*/

6.3循环结构

/*
代表语句：while , do...while , for

    while(条件表达式)
    {
        执行语句;        条件表达式为true，执行
    }
***********************************************************************************
  
    do                    do  while 至少执行一次
    {
        执行语句;
    }while(条件表达式);    先执行 do{}，条件表达式为true，再次执行 do{}。。。

***********************************************************************************

    for(初始化表达式; 循环条件表达式; 循环后的操作表达式)
    {
        执行语句;    (循环体)
    }

for和while之间的区别：循环结束后，while的变量依旧可用，for的变量已经被释放，内存占用问题
*/

当对某些代码执行多次时，使用循环结构。对某一条件只进行一次判断时，使用if语句；当对某些条件进行多次判断时，使用while语句。（注：明确哪些语句需要循环，哪些不需要；循环通常要定义条件，控制循环次数。）

6.4 break，continue

break：跳出。

作用范围：switch语句，循环语句。

注：当break语句单独存在时，下面不要定义其他语句，因为执行不到；break跳出所在的当前循环；如果出现了循环嵌套，break想要跳出指定的循环，可以通过标号来完成。

continue:继续。

作用的范围：循环结构。

continue：结束本次循环，继续下次循环。如果continue单独存在时，下面不要有任何语句，因为执行不到。作用外循环时，同样需要通过标号来完成。

7.函数

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

格式：

           修饰符  返回值类型  函数名（参数类型，形式参数1，参数类型，形式参数2，...）

         ｛

                      执行语句；

                       return  返回值；

           ｝

特点：没有具体返回值时，返回值类型是void，“return；”可以省略不写；定义函数可以将功能性代码进行封装；便于对该功能进行复用；只有被调用才会执行；提高了代码的复用性。

注意：函数中只能调用函数，不能再定义函数。

重载（overload）：同一类中，允许存在一个以上同名函数，只要他们的参数个数或参数类型不同即可。

重载特点：与返回类型无关，只看参数

8.数组

数组：同一种类型数据的集合。一个容器。可以自动给数组元素从0开始编号，方便操作

格式：元素类型[ ]  数组名 = new  元素类型[元素个数或数组长度];    例：int[] arr = new int[5];（5个长度的数组，只能存储int值）

           元素类型[ ]  数组名 = new  元素类型[ ]{元素，元素，...};      例：int[] arr = new int[]{2，5，8，9，4，2};      <==>   int[] arr =  {2，5，8，9，4，2};

数组操作：存和取。核心：对角标的操作。

int[] arr = {2,5,8,7,3,6};
//通过for循环取所有值
for(int i = 0; i < arr.length; i++){
    System.out.println("arr[" + i + "] = " + arr[i]);
}

 

内存的划分：

1，寄存器。

2，本地方法区。

3，方法区。

4，栈内存：存储的都是局部变量，而且变量所属的作用域一旦结束，该变量就自动释放。

5，堆内存： 存储是数组和对象(其实数组就是对象)， 凡是new建立在堆中。

堆内存特点： 1)，每一个实体都有首地址值。2)，堆内存中的每一个变量都有默认初始化值，根据类型的不同而不同。整数是0，小数0.0或者0.0f，boolean false char '\u0000'。3)，垃圾回收机制。