JavaSE基础学习之语言基础

2.1 关键字

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

关键字的定义和特点

定义：被Java语言赋予了特殊含义的单词。 特点：关键字中所有字母都为小写。

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

class、interface、byte、short、int、long、float、double、char、boolean、void

用于定义数据类型值的关键字

true、false、null

用于定义流程控制的关键字

if、else、switch、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.2 标识符

  1.定义合法标识符规则：1.不可以以数字开头，2.不可以使用关键字
  2.由26个英文字母组成，数字：0-9，符号：_$组成

2.3 注释

//这是单行注释

/*
多行注释
多行注释
*/

 主要要注意的就是Java特有的一个注释：文档注释.它和多行注释最大的区别就是文档注释可以被Javadoc.exe提取出来。javadoc.exe会帮你把文档注释生成一个网页的说明书

/**
这是文档注释
*/

2.4 常量和变量

一、常量表示不能改变的数值。
Java中常量的分类：
  1.整数常量：所有整数。
  2.小数常量：所有小数。
  3.布尔(boolean)型常量：只有两个数值：true和false。
  4.字符常量：将一个数字字母或者符号用单引号(’ ')标识。
  5.字符串常量：将一个或者多个字符用双引号(" ")标识。
  6.null常量：只有一个数值就是null。
对于整数：有四种表现形式。
  二进制：0,1，满2进1。
  八进制：0-7，满8进1.
  十六进制，0-9，A-F,满16进1，用0x开头表示。
  负数的二进制表现形式：对应正数二进制取反加1
  例：-6=6取反再加一
  0000-0110取反=1111-1001+0000-0001=1111-1010
注意：负数的二进制最高位永远是1
二、变量的概念
  1.内存中的一个存储区域
  2.该区域有自己的名称(变量名)和类型(数据类型)
  3.该区域的数据可以在同一类型范围内不断变化
  4.为什么要定义变量：用来不断的存放同一类型的常量，并可以重复使用。
  5.使用变量注意：1.要先初始化 2.变量的作用范围(一对｛｝)
  6.格式：数据类型 变量名 = 初始化值
三、数据类型
自动类型转换(隐式类型转换)
  所有的byte、short、char的值将被自动提升为int型。
  long就是long
  float就是float
  double就是double
强制类型转换(显式类型转换)

	byte b=3；
	b=b+4；

由于b是一个字节而4是int型4个字节，所以程序将会提醒你可能丢失精度。

b=(byte)(b+4);

将运算结果强制转换为byte就不会丢失精度了。但是如果数值较大还是会损失精度，因为强制类型转换只是将高位舍弃掉而已，如果高位有数据将会造成数据的丢失。

System.out.print('a'+1);//运行后输出结果为多少呢？

答案是98。因为‘a’+1时，将会把‘a’自动转换为Ascii码表中的数值，a为97加1就等于98了。

思考   第三行中为什么byte b=b1+b2;会报错？

	byte b1=3;
    byte b2=7;
    byte b=b1+b2;//报错

原因是byte在运算时会自动转型为int型，所以b1+b2的结果是int型的，但是b是byte型，类型不匹配所以发生错误。正确应该这样写：

	byte b1=3;
    byte b2=7;
  	byte b=(byte)(b1+b2);

2.5 运算符

1. 算术运算符
分为+、-、*、/；对应数学中的加减乘除。还有一个%取余，就是取余数。
注意：int型在运算时将会自动舍弃小数位。任何数据与字符串相加都是相连接，例：3+“2”=32
自增与自减(++ --)

int a=1,b;
b=a++;
System.out.println("a="+a+",b="+b);//a=2,b=1
b=++a;
System.out.println("a="+a+",b="+b);//a=2,b=2

当运行b=a++;时，会先将a赋值给b，然后a在加一；当运行b=++a;时，a会先加一，然后在赋值给b；
这就是++放在前面与后面的区别。

思考：输出结果会是多少呢？

int i=3;
i=i++;
System.out.println("i="+i);

答案是3；

2. 赋值运算符
  =、+=、-+、/=、%=

	int i=2;
	i+=2;//其实就是i=i+2；

  思考：i = i + 2;为什么会报错？

	short i=2;
	//i+=2;
	i = i + 2;

  还是那个类型提升的问题，i + 2；运行完是int型，类型不匹配就会发生错误。那为什么i+=2；可以呢？因为i+=2；在运行时将会进行自动的类型提升所以不会报错。i+=2；实质上就是i=(short)(i+2);
3. 比较运算符

运算符	运算	范例	结果
==	相等于	1==2	false
!=	不等于	1!=2	true
<	小于	1 < 2	true
>	大于	1 > 2	false
<=	小于等于	1 <=2	true
>=	大于等于	1 >=2	false
instanceof	检查是否是类的对象	"a" instanceof String	true

   注意：比较运算符是boolean型，其结果都是true或者false。

4. 逻辑运算符

运算符	运算	范例	结果
&	AND(与)	false & true	false
|	OR(或)	false | true	true
^	XOR(异或)	false ^ true	true
!	NOT(非)	! false	true
&&	AND(短路与)	true && false	false
||	OR(短路或)	true || false	true

  短路与：只要一边是false就直接为false不再计算右边的表达式
  短路或：只要一边为true就直接为true不再计算右边的表达式
  异或：和或有点区别，异或只有两边不同为真，两边相同为假。

5. 位运算符

运算符	运算	范例
<<	左移	3 << 2 =12 3*2*2=12
>>	右移	12 >> 2 =3 12/2/2=3
>>>	无符号右移	12 >>> 2 = 3
&	与运算	6 & 3=2
|	或运算	6 | 3=7
^	异或运算	6 ^ 3=5
~	反码	~6=-7

   注意：位运算符操纵的是二进制。6=0110,3=0011 一个数异或同一个数两次，结果还是那个数。 无符号右移：数据右移时，高位出现的空位都用0补。 练习   1.最有效率的方式算出2乘以8等于几？
  2.对两个整数变量的值进行互换(不使用第三方变量)

	System.out.println(2<<3);
	
	int i=2,j=3;
	j=i^j;
	i=i^j;
	j=i^j;
	System.out.print("i="+i+",j="+j);

6. 三元运算符
  格式：
  (条件表达式)?表达式1:表达式2；
  如果条件为真，结果为表达式1；
  如果条件为假，结果为表达式2；

2.6 语句

一、if语句的三种格式：(判断结构)
1.if(条件表达式){
  执行语句；
}

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

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

二、switch语句(选择结构)
switch(表达式){
  case 取值1：
    执行语句;
    break;
  default:
    执行语句；
    break;
}
注意：如果case没有break；将会执行到下一个case中。
三、while、do while、for(循环结构)
1.while(条件表达式){
  执行语句；
}
2.do{
  执行语句；
}while(条件表达式)
特点：无论条件是否满足，至少执行一次
3.for(初始化表达式;循环条件表达式；循环后的操作表达式){
  执行语句；
}
4.break、continue(其他流程控制语句)
  break语句：跳出，应用于选择结构和循环结构。
  continue语句：结束当前循环，后面的不再执行，应用于循环结构。

2.7 函数

- 函数的定义
什么是函数？
  函数就是定义在类中的具有特定功能的一段独立小程序。
  函数也称为方法。
函数的格式:
  修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2){
    执行语句
    return 返回值;
  }
  返回值类型：函数运行后的结果的数据类型。
  参数类型：是形式参数的数据类型。
  形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
  实际参数：传递给形式参数的具体数值。
  return：用于结束函数。
  返回值：该函数运算后的结果，该结果会返回给调用者。

- 函数的特点

• 定义函数可以将功能代码进行封装。
• 便于对该功能进行复用。
• 函数只有被调用才会执行。
  注意：1.函数只能调用函数，不能在函数内部定义函数。定义函数时，函数的结果应该返回给调用者。

- 函数的重载

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

• 重载的特点
  与返回值类型无关，只看参数列表。

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

2.8 数组

1. 数组的定义
   概念：同一类型数据的集合，其实数组就是一个容器。
2. 格式
   元素类型[ ] 数组名 = new 元素类型[ 元素个数或数组长度]
   示例:int[] arr = new int[10];
   元素类型[] 数组名 = new 元素类型[]{元素、元素}
   示例：int[] arr=new int[]{1,3,5,7,9};
      int[] arr={1,3,5,7,9};
3. 堆栈
   栈内存
   存储的都是局部变量。而且变量所属的作用域一旦结束，该变量就自动释放。
   堆内存
   存储的是数组和对象，凡是new出来的都在堆中。
   特点：
   1.每一个实体都有首地址值。
   2.堆内存中的每一个变量都有默认初始化值，根据类型不同而不同。整数是0，小数是0.0或0.0f，boolean是false，char’\u0000’
   3.垃圾回收机制
   
4. 数组的常见操作
   遍历：

	int[] arr=new int[]{1,3,5,7,9};
	for(int i=0;i<arr.length;i++){
		System.out.print(arr[i]+" ");
	}
	//1 3 5 7 9

最值：

    public static int findMax(int[] arr){
        int max=arr[0];
        for(int i=0;i<arr.length;i++){
            if(max<arr[i]){
                max=arr[i];
            }
        }
        return max;
    }//9

排序-选择排序：

	public static void main(String[] args){
       int[] arr=new int[]{12,78,90,567,34,124,56,65,23};
       sort(arr);
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        //12 23 34 56 65 78 90 124 567 
    }
    //排序算法-选择排序：每一轮选出最小一个值
    public static void sort(int[] arr){
        //外层控制排序次数，n个数只需要n-1次
        for(int i=0;i<arr.length-1;i++){
            //内层遍历数组元素，已经排好的不再遍历，所以j=i+1；
            for(int j=1+i;j<arr.length;j++){
                if(arr[i]>arr[j]){
                    temp(arr,i,j);
                }
            }
        }
    }
    //交换数组中两个数
    public static void temp(int[] arr,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }

排序-冒泡排序：

	public static void main(String[] args){
       int[] arr=new int[]{12,78,90,567,34,124,56,65,23};
       sort(arr);
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
    //排序算法-冒泡排序：两两比较，较轻的气泡冒出
    public static void sort(int[] arr){
        //外层控制排序次数，n个数只需要n-1次
        for(int i=0;i<arr.length-1;i++){
            //从后往前比较，较轻的气泡先冒出
            for(int j=arr.length-1;j>i;j--){
                if(arr[j]<arr[j-1]){
                    temp(arr,j,j-1);
                }
            }
        }
    }
    //交换数组中两个数
    public static void temp(int[] arr,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }

二分查找:

	//二分查找必须是已经排序好的数据
    public static int halfSearch(int[] arr,int key){
        //分别定义头、尾和中间变量
        int f=0,r=arr.length-1,m=(f+r)/2;
        //循环条件是中间变量不等于key
        while (arr[m]!=key) {
            //key大于m，则将头提升至m之后
            if (arr[m] < key) {
                f = m + 1;
                //key<m,则将尾提升至m之前
            } else if (arr[m] > key) {
                r = m - 1;
            }
            //当头大于尾，说明找不到key
            if(f>r){
                return -1;
            }
            //m再次等于头尾之和除2
            m=(f+r)/2;
        }
        return m;
    }

十进制转十六进制：

	public static String toHex(int num){
        String b="";
        while (num!=0){
            int temp=num&15;
            if(temp>9){
                b=(char)('A'+temp-10)+b;
            }else {
                b = temp + b;
            }
            num=num>>4;
        }
        return b;
    }

1. 二维数组
   格式：1.int[ ][ ] arr = new int[3][2];
      2.int[ ][ ]arr = new int [ 3][ ];
      3.int[ ][ ]arr={ {元素},{ },{ } };
   

2.9思维导图