黑马程序员--------语法基础

-----Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

Java语法基础

1，关键字：

其实就是某种语言赋予了特殊含义的单词。保留字：其实就是还没有赋予特殊含义，但是准备日后要使用过的单 词。 

2，标示符：

Java中的包、类、方法、参数和变量的名字，可由任意顺序的大小写字母、数字、下划线（_）和美元符号（$）组成，但标识符不能以数字开头，不能是Java中的保留关键字。下面是合法的标识符：yourname your_name _yourname $yourname

下面是非法的标识符：

class 67.9 Hello Careers

1），数字不可以开头。

2），不可以使用关键字。

3，常量：是在程序中的不会变化的数据。

4，变量：其实就是内存中的一个存储空间，用于存储常量数据。

4.1 作用：方便于运算。因为有些数据不确定。所以确定该数据的名词和存储空间。

4.2 特点：变量空间可以重复使用。

4.3变量的作用域和生存期:

4.3.1 变量的作用域：作用域从变量定义的位置开始，到该变量所在的那对大括号结束； 

4.3.2 生命周期：  变量从定义的位置开始就在内存中活了； 

变量到达它所在的作用域的时候就在内存中消失了；

5，数据类型 

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

2）：引用数据类型: 数组、类、接口。

级别从低到高为：byte,char,short(这三个平级)-->int-->float-->long-->double 

自动类型转换：从低级别到高级别，系统自动转的；

强制类型转换：什么情况下使用?把一个高级别的数赋给一个别该数的级别低的变量；

6,运算符号： 

1）、算术运算符。+ - * / % %:任何整数模2不是0就是1，所以只要改变被模数就可以实现开关运算。 +:连接符。 ++,--  

2）、赋值运算符。 = += -= *= /= %=  

3）、比较运算符。特点：该运算符的特点是：运算完的结果，要么是true，要么是false。 

4）、逻辑运算符。& | ^ ! && || 逻辑运算符除了 ! 外都是用于连接两个boolean类型表达式。 

&: 只有两边都为true结果是true。否则就是false。

^:异或：和或有点不一样。两边结果一样，就为false。两边结果不一样，就为true.& 和 &&区别： & ：无论左边结果是什么，右边都参与运算。  

&&:短路与，如果左边为false，那么右边不参数与运算。 

| 和|| 区别： |：两边都运算。  

||：短路或，如果左边为true，那么右边不参与运算。 

5）、位运算符:用于操作二进制位的运算符。& | ^ << >> >>>(无符号右移)

7，语句。 

If else If switch do while while for这些语句什么时候用？ 

7.1）、当判断固定个数的值的时候，可以使用if，也可以使用switch。建议使用switch，效率相对较高。 switch(变量){case 值:要执行的语句;break; „ default:要执行的语句; } 细节：1）：break是可以省略的，如果省略了就一直执行到遇到break为止； 

2）：switch 后面的小括号中的变量应该是byte,char,short,int四种类型中的一种；3）：default可以写在switch结构中的任意位置；如果将default语句放在了第一行，则不管expression与case中的value是否匹配，程序会从default开始执行直到第一个break出现。 

7.2）、当判断数据范围，获取判断运算结果boolean类型时，需要使用if。 

7.3）、当某些语句需要执行很多次时，就用循环结构。  

while和for可以进行互换。区别在于：如果需要定义变量控制循环次数。建议使用for。因为for循环完毕，变量在内存中释放。

7.4 )  break:作用于switch ，和循环语句，用于跳出，或者称为结束。break语句单独存在时，下面不要定义其他语句，因为执行不到，编译会失败。当循环嵌套时，break只跳出当前所在循环。要跳出嵌套中的外部循环，只要给循环起名字即可，这个名字称之为标号。continue:只作用于循环结构，继续循环用的。作用：结束本次循环，继续下次循环。该语句单独存在时，下面不可以定义语句，执行不到。

8，方法：

为了提高代码的复用性，可以将其定义成一个单独的功能，该功能的体现就是java中的方法。方法就是体现之一。java中的函数的定义格式：

修饰符 返回值类型 方法名(参数类型 形式参数1，参数类型 形式参数1，„){  

执行语句； 

return 返回值； 

} 

当方法没有具体的返回值时，返回的返回值类型用void关键字表示。如果方法的返回值类型是void时，return语句可以省略不写的，系统会帮你自动加上。 return的作用：结束方法。结束功能。 

8.1如何定义一个方法？

8.1.1 方法其实就是一个功能，定义方法就是实现功能，通过两个明确来完成： 

1）、明确该功能的运算完的结果，其实是在明确这个方法的返回值类型。 

2）、在实现该功能的过程中是否有未知内容参与了运算，其实就是在明确这个方法的参数列表(参数类型&参数个数)。

8.1.2方法的作用： 

1）、用于定义功能。

2）、用于封装代码提高代码的复用性。

注意：方法中只能调用方法，不能定义方法。

8.1.3主方法： 

1）、保证该类的独立运行。 

2）、因为它是程序的入口。 

3）、因为它在被jvm调用。 

方法定义名称是为什么呢？ 

答：1）、为了对该功能进行标示，方便于调用。 

2）、为了通过名称就可以明确方法的功能，为了增加代码的阅读性。

8.1.4 方法重载

重载的定义是：在一个类中，如果出现了两个或者两个以上的同名方法，只要它们的参数的个数，或者参数的类型不同，即可称之为该方法重载了。如何区分重载：当方法同名时，只看参数列表。和返回值类型没关系。

9 , Java内存区Java把内存划分为4个部分 1. 代码区 1、栈区 3、堆区 4、静态区域 

1、栈区（stacksegment）—由编译器自动分配释放,存放函数的参数值，局部变量的值等，具体方法执行结束之后，系统自动释放JVM内存资源 

2、堆区（heapsegment）—一般由程序员分配释放，存放由new创建的对象和数组，jvm不定时查看这个对象，如果没有引用指向这个对象就回收

3、静态区（datasegment）—存放全局变量，静态变量和字符串常量，不释放 

4、代码区（codesegment）—存放程序中方法的二进制代码，而且是多个对象共享一个代码空间区域

10 数组

10.1一维数组 一维数组：用于存储同一类型数据的一个容器。好处：可以对该容器中的数据进行编号，从0开始。数组用于封装数据，就是一个具体的实体。 如何在java中表现一个数组呢？两种表现形式。

1）、元素类型[] 变量名 = new 元素类型[元素的个数]；

2）、元素类型[] 变量名 = {元素1，元素2...}； 

3）、System.arrayCopy(source,0,dest,0,x)：语句的意思就是：复制源数组从下标0开始的x个元素到目标数组，从目标数组的下标0所对应的位置开始存取。 

4）、Arrays.sort(数组名)为数组排序的操作，但这个方法在java.util这个包里面，所以在用到的时候需要先将它导入

<span style="white-space:pre">		</span>10.1.1处理数组

<span style="white-space:pre">		</span>
		double[] myList = new double[10];
		//1）使用输入值初始化数组
		java.util.Scanner input new java.util.Scanner(System.in);
		System.out.println("Enter " +myList.length+"values");
		for(int i = 0;i< myList.length; i++)
			myList[i] = input.nextDouble();
		//2)使用随机数初始化数组
		for(int i = 0;i<myList.length;i++)
			myList[i] = Math.random()*100;
		//3)打印数组
		for（int i = 0;i <myList.length;i++)
			System.out.print(myList[i] + " ");
		//4）对所有元素求和并打印
		double sum = 0;
		for（int i = 0;i <myList.length;i++)
			sum += myList[i];
		System.out.print(sum );
		//5)找出最大元素的最小下标
		double max = myList[0]；
		int  indexOfMax = 0;
		for（int i= 1 ； i<myList.length; i ++){
			if (myList[i] > max){
			max = myList[i];
			indexOfMax = i;
			}
		}
		//6随意打乱元素顺序
		for (int i = 0; i <MyList.length; i++){
			int index = (int)(Math.random() * myList.length);
			double temp = myList[i];
			myList[i] = myList[index];
			myList[index] = temp;
		}
		//7移动元素
		double temp = myList[0];
		for (int i = 1;i <MyList.length;i++){
			myLIst[i- 1] = myList[i];
		}
		myList[myList.length -1] = temp;
	//10.1.2查找
		//1）线性查找
		public class LinearSearch{
			public static void main(String[]
 args){
		   int[] list = new int{1,4,4,2,5,-3,6,2};
		   int a = linearSearch(list,4);// returns 1
		   int b = linearSearch(list,-4);// returns -1
		   int c = linesrSearch(list,-3);// returns 5
		   }
		    public static int lnearSearch(int[] list ,int key){
			    for(int = 0; i <list.length;i++){
				    if(key == list[i]
					    return i;
				}
				return -1;
			}	 
		
	}

2)二分查找

二分查找的前提是数组已排好顺序，若没有排好则要先排序。

思路；1如果要查找的关键元素小于 中间元素，只要在数组的前半元素中继续查找关键元素。2 如果关键元素和中间元素相等，则匹配成功，查找结束。

3 如果关键元素大于中间元素，只要在数组的后半部分元素中查找关键元素。

public class BinarySearch{
			public static void main(String[]
args){      	int[] list = {2,4,7,10,11,45,50,59,60,66,69,70,79};
				 int a = binarySearch(list,2);//Returns 0
				 int b = binarySearch(list,11);//Returns 4
				 int c = binarySearch(list,12);//returns -6
				 int d = binarySearch(list,1)://Returns -1
				 int e = binarySearch(list,3); //Returns -2
			}
				 
			public static  int binarySearch(int[] list,int key){
				int low = 0;
				int high = list.length-1;
				while(high >= low){
					int mid = (low+high)/2;
					if(key<list[mid])
						high = mid - 1;
					else if (key==list[mid])
					return mid;
					else 
						low = mid +1;
				}
				return  -low-1;
			}
		}

10.1.3 排序

<span style="white-space:pre">	</span>//1）插入排序
		public static void sort(int[] a){
			 for(int i = 1; i < a.length;i++){
				int temp = a[i];
				int j;
				for ( j = i -1; j>= 0;j--){
					if(a[j] > temp)
						a[j+1] = a[j];
					else
						break;
				}
			a[j +1] = temp;
			}
	}
	//2）选择排序
	public static void xuanZheSort(int[] a){
		for(int i =0; i < a.length -1;i++){
			int min = a[i];
			int minOfIndex = i;
			for (int j = i + 1; j< a.length;j++){
				if (min > a[j]){
					min = a[j];
					minOfIndex = j;
				}
			}
			if(minOfIndex != i){
				a[minOfIndex] = a[i];
				a[i] = min;
			}
		}
	}
	//3）冒泡排序
	public static void bubbleSort(int[] a ){
		for(int x= 0;x <a.length-1;x++){
			for(int y = 0;y <a.length -x -1;y++){
				//-x 让每次比较的元素减少，-1：是避免下标越界；
				if (a[y] > a[y+1]){
					swap(a,y,y+1);
				}
			}
		}
	}
	public static void swap(int[] arr, int a ,int b){
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}

10.2二维数组  

1）、元素类型[][] 变量名 = new 元素类型[一维数组的个数][每个一维数组元素的个数]；

2）、元素类型[][] 变量名 ={ {元素1，元素2...}，{元素1，元素2...}，{元素1，元素2...}... } 3）、 int[][] list = int[3][4]; list[2][2] = 4;

10.2.1二维数组的基本处理

int[][] matrix = new int[10][10];

1）使用输入值初始化数组

java.util.Scanner input = new java.util.Scanner(System.in);
	System.out.println("Enter" + matrix.length+ "rows and"+matrix[0].length + "colums");
	for(int row =0;row<matrix.length; row++){
		for(int column = 0;column <matrix[row].length;column++)
			matrix[row][column];
	}
	//2)使用随机数初始化数组
	for(int row =0;row<matrix.length; row++){
		for(int column = 0;column <matrix[row].length;column++)
			matrix[row][column] = (int)(Math.random() *100);
	}
	//3)打印数组
	for(int row =0;row<matrix.length; row++){
		for(int column = 0;column <matrix[row].length;column++)
			System.out.print(matrix[row][column] + "\t");
		System.out.println();
	}
	//4)求所有元素的和
	int total = 0；
	for(int row =0;row<matrix.length; row++){
		for(int column = 0;column <martix[row].length;column++)
			  total += matrix[row][column];
		System.out.println(total);
	}
	//5)对数字安列求和
	for(int column = 0;column <matrix[0].length;column++ ){
		int sum = 0;
		for(  int row =0;row<matrix.length; row++)
			sum += martix[row][column];
		System.out.println（“sum of column " + column + "is" +sum);
	}
	//6)哪一行的和最大
	int maxRow = 0;
	int indexOfMaxRow = 0;
	for(int column = 0 ;column<matrix[0].length;column++){
		maxRow += matrix[0][column];
	for(int row =1;row <matrix.length;row++){
		int totalOfThisRow = 0;
		for(int column =0;column<matrix[row].length;column++){
			totalOfThisRow += matrix[row][column];
			if (totalOfThisRow > maxRow){
				maxRow = totalOfThisRow;
				indexOfMaxRow = row;
			}
		}
		System.out.println("Row" + indexOfMaxRow+"has the maximum sum of " + maxRow);