初步学习Java篇续

• 4 、运算符
• 5 、程序流程控制
• 6 、数组

4.1.算术运算符

算术运算符的注意问题：

• 如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。
• 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
  例如：int x=3510;x=x/1000*1000; x的结果是？
• “+”除字符串相加功能外，还能把非字符串转换成字符串.
  例如： System.out.println(“5+5=”+5+5); //打印结果是？5+5=55
• 以下二者的区别：
  System.out.println(‘’ + ‘t’ +'’);
  System.out.println(""+ ‘t’ +'');

练习：
public class TestSign{
public static void main(String[] args){
int i1 = 10,i2 = 20;
int i = i1++;
System.out.print(“i=”+i); //i=10
System.out.println(“i1=”+i1);//i1=11
i = ++i1;
System.out.print(“i=”+i);//i=12
System.out.println(“i1=”+i1);//i1=10 11 12 13
i = i2–;
System.out.print(“i=”+i);//i=20
System.out.println(“i2=”+i2);//i2=19
i = --i2;
System.out.print(“i=”+i);//i=18
System.out.println(“i2=”+i2);//i2=18

4.2.赋值运算符

• 符号：=
  （1）当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
  （2）支持连续赋值。
  扩展赋值运算符： +=, -=, *=, /=, %=
  思考1：

        short s = 3;                                           
        s=s+2;  ①
        s+=2;    ②
        ①和②有什么区别？ 
  

4.3.比较运算符

比较运算符的结果都是boolean型，也就是要么是true，要么是false。
比较运算符“==”不能误写成“=” 。

4.4.逻辑运算符
&—逻辑与 | —逻辑或 ！—逻辑非
&& —短路与 || —短路或 ^ —逻辑异或

• 逻辑运算符用于连接布尔型表达式，在Java中不可以写成33 & x<6 。
• “&”和“&&”的区别： 单&时，左边无论真假，右边都进行运算； 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
• “|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。 在不需要逻辑运算两边都参与运算的时候，尽量使用&&和||
• 异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。
  理解：异或，追求的是“异”!

练习2：请写出每题的输出结果




4.5.位运算符

注意：无<<<
位运算是直接对二进制进行运算

4.6.三元运算符

• 顺序结构 ：Java中定义成员变量时采用合法的前向引用。

如：

       public class Test{
                  int num1 = 12;
                  int num2 = num1 + 2; } 
                  
       错误形式：
        public class Test{
                  int num2 = num1 + 2；
                  int num1 = 12; }

5.1、分支语句1： if-else语句

• if语句例题1
  判断小明的期末成绩。
  当成绩为100分时，奖励一辆BMW；
  当成绩为（80，99]时，奖励一个台iphone5s；
  当成绩为[60,80]时，奖励一本参考书；
  其它时，什么奖励也没有。

   	int score =80 ;
   	if(score == 100) {
   		System.out.println("奖励一辆宝马");
   	}else if(score > 80 && score <=90) {
   		System.out.println("奖励一天iPhone5s");
   	}else if(score >= 60 & score <= 80) {
   		System.out.println("奖励一本参考书");
   	}else {
   		System.out.println("什么奖励都没有");
   	}

5.2、分支结构2：switch语句

例子：

public class Test{
	       public static void main(String args[]){
			String season = “summer”;
			switch (season) {
		       	case “spring”:
				System.out.println(“春暖花开");
				break;
		       	case “summer”:
				System.out.println(“夏日炎炎");
				break;
			case “autumn”:
				System.out.println(“秋高气爽");
				break;
			case “winter”:
				System.out.println(“冬雪皑皑");
				break;
		        	default:
				System.out.println(“季节输入有误");
				break;
		 	}
          }
}

- switch语句有关规则：

• switch(表达式)中表达式的返回值必须是下述几种类型之一：byte，short，char，int，枚举，String；
• case子句中的值必须是常量，且所有case子句中的值应是不同的；
• default子句是可任选的，当没有匹配的case时，执行default
• break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾
  

public class Test{
	       public static void main(String args[]){
		      	char  input = 'a';//可以输入任意值验证
       	switch(input) {
        	case 'a':
      		System.out.println("A");
        		break;
        	case 'b':
        		System.out.println("B");
        		break;
        	case 'c':
        		System.out.println("C");
        		break;
        	case 'd':
     		System.out.println("D");
      		break;
       	case 'e':
      		System.out.println("E");
       		break;
        	default:
      		System.out.println("other");
       		break;
        	}
          }
}

	int i = 67;
	switch(i / 60) {
	case 1:
		System.out.println("合格");
	break;
     default:
    	 System.out.println("不合格");
    	 break;
	}

      int i = 6;//i可以去任意值验证
   	  switch (i) {
   	  case 1:
   		  System.out.println("冬季");
   		  break;
   	 case 2:
  		  System.out.println("冬季");
  		  break;
   	 case 12:
  		  System.out.println("冬季");
  		  break;
   	 case 3:
  		  System.out.println("春季");
  		  break;
   	case 4:
 		  System.out.println("春季");
 		  break;
   	case 5:
 		  System.out.println("春季");
 		  break;
   	case 6:
 		  System.out.println("夏季");
 		  break;
  	case 7:
 		  System.out.println("夏季");
 		  break;
  	case 8:
 		  System.out.println("夏季");
 		  break;
  	case 9:
 		  System.out.println("秋季");
 		  break;
  	case 10:
 		  System.out.println("秋季"); 
 		  break;
  	case 11:
 		  System.out.println("秋季");
 		  break;
 		  default:
 			  System.out.println("输入错误，请检查");
 			  break;
 			 
   	  }

- switch和if语句的对比：
if和switch语句很像，具体什么场景下，应用哪个语句呢？
（1） 如果判断的具体数值不多，而且符合byte、 short 、int、char这四种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。
（2）其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。

• 循环结构

循环语句功能：在某些条件满足的情况下，反复执行特定代码的功能
循环语句的四个组成部分：
-初始化部分（init_statement）
-循环条件部分（test_exp）
-循环体部分（body_statement）
-迭代部分（alter_statement）
循环语句分类：
-for 循环
-while 循环
-do/while 循环

5.3、for 循环语句
语法格式：
for (初始化表达式①; 布尔值测试表达式②; 更改表达式)｛
语句或语句块③；
｝
例如：

public class ForLoop {
		public static void main(String args[]){
		          int result = 0;
		          for(int i=1; i<=100; i++) {
			  result += i;
		          }
  	          System.out.println("result=" + result);
		}
	} 

for (int i = 1;i <=150; i++) {
   		String str = "";
   		str += i;
   		if(i % 3 == 0) {
   			str += " foo";
   		}
   		if(i % 5 ==0) {
				str += " biz";
			}
   		if(i % 7 ==0) {
				str += " baz";
			}
   		System.out.println(str);
   }
//或者如下：   	
   	for(int i = 1; i <=150;i ++) {
   		System.out.print(i +"");
   		if(i%3==0) {
   			System.out.print("foo ");
   		}
   		if(i%5==0) {
   			System.out.print("biz ");
   	}
   		if(i%7==0) {
			System.out.print("baz ");
			}
   		System.out.println();
   		}

 //求100以内的奇数和
       	int sum = 0;//定义变量sum用于累加的和
       	for (int i =1 ;i <=100;i++) {//i的值在1~100之间变化
       		if(i%2!=0) {//判断是否为奇数
       			sum += i;//实现sum与i的累加
       		}
       	}
       	System.out.println("sum ="+ sum);

//   	打印1~100之间所有是7的倍数的整数的个数及总和（体会设置计数器的思想）
   	int sum = 0; 
   	int j =0;//用于计算7的倍数的整数的个数
   	for(int i = 1;i<=100;i ++) {
   		if(i% 7 ==0) {
   			sum +=i;
   			j++;
   		}
   	}    	
   	System.out.println( "个数有"+j);
   	System.out.println("总和sum="+sum);

    	 //输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身
     	  for(int i = 100;i<=999;i++) {
     		  int n = i/100;
     		  int m = (i-n*100)/10;
     		  int k = i- n*100-m*10;
     		 int res = n*n*n + m*m*m + k*k*k ;
     		 if(res == i) {
  			 System.out.println(i);
     	  }
     	  }

5.4、while 循环语句
语法格式：
[初始化语句]
while( 布尔值测试表达式)｛
语句或语句块;
更改语句;
}

		public class WhileLoop {
		    public static void main(String args[]){
            int result = 0;
			int i=1;
			while(i<=100) {
			        result += i;
            	        i++;
			}
			  System.out.println("result=" + result);
		         }
		} 

应用举例

5.5、do-while 循环语句

语法格式
[初始化语句]
do｛
语句或语句块;
更改语句;
｝while(布尔值测试表达式);

应用举例

	public class WhileLoop {
	        public static void main(String args[]){
    		  int result = 0,  i=1;
		        do{
		        	 result += i;
       		       	   i++;
			 }while(i<=100);
		 System.out.println("result=" + result);
	       }
	}  

 //求1到100之间所有偶数的和 	
   	int k = 1;int res = 0;
   	while(k <= 100) {
    		if(k % 2==0) {
   		res = res + k;
   	}
   		k++;
   	}
    	System.out.println(res);

for循环可以自己尝试写一下。

5.6、嵌套循环

• 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环和内层循环。
• 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
• 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n=mn次。

例题：1）九九乘法表

//打印九九乘法表
   	for(int i =1;i <=9;i++) {
   		for(int j=1;j<=i;j++){
  			System.out.print(j + " * " + i +" = "+( j * i )+ " ");
   		}
    		System.out.println();
    	}

2）1—100之间的所有质数

//1—100之间的所有质数
    	for (int i =1;i<=100;i++) {
    		int k =0;
    		for(int j = 1;j <=i;j++) {
    			if(i%j==0) {
    				k++;
    		}
    	}
   		System.out.println(i);
    	}  

• 特殊流程控制语句1
  break 语句
  break语句用于终止某个语句块的执行
  { ……
  break;
  ……
  }
  注意：break终止当前所在的循环

例子：

public class TestBreak{
		public static void main(String args[]){
	    for(int i = 0; i<10; i++){ 
	     	if(i==3)
		      break;	  
	    	System.out.println(" i =" + i);
	    }
	    System.out.println("Game Over!");
		}
}

• 特殊流程控制语句2
  continue 语句：
  continue语句用于跳过某个循环语句块的一次执行 。
  continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环 。

public class ContinueTest {
      public static void main(String args[]){
	     	 for (int i = 0; i < 100; i++) {
	          if (i%10==0)
		continue;
		     System.out.println(i);
		     } 
	      }  
      } 

• 特殊流程控制语句3
  （1）return：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。
  （2）与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内。
• 特殊流程控制语句说明：
• break只能用于switch语句和循环语句中。
• continue 只能用于循环语句中。
• 二者功能类似，但continue是终止本次循环，break是终止本层循环。
  break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。

6.1、一维数组的声明
一维数组的声明方式：
type var[] 或 type[] var；
➢例如：
int a[];
int[] a1;
double b[];
Mydate[] c; //对象数组哦一维数组

6.2、一维数组初始化

（1）动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行
int[] arr = new int[3];
arr[0] = 3;
arr[1] = 9;
arr[2] =8
（2）静态初始化：在定义数组的同时就为数组元素分配空间并赋值。
int a[] = new int[]{ 3, 9, 8};
int[] a = {3,9,8};

6.3、数组元素的引用

• 定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
• 数组元素的引用方式：数组名[数组元素下标]
• 数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
• 数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；如int a[]=new int[3]; 可引用的数组元素为a[0]、a[1]、a[2]
• 每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数)
• 数组一旦初始化，其长度是不可变的

6.4、数组元素的默认初始化

• 数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。例如：

public class Test {
public static void main(String argv[]){
int a[]= new int[5]; 
System.out.println(a[3]);	//a[3]的默认值为0
      }
} 

6.5、多维数组
二维数组[][]：数组中的数组
（1）格式1（动态初始化）：int[ ][ ] arr = new int[3][2];
定义了名称为arr的二维数组，二维数组中有3个一维数组， 每一个一维数组中有2个元素
一维数组的名称分别为arr[0], arr[1], arr[2]，给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;
（2）格式2（动态初始化）：int[][] arr = new int[3][];
二维数组中有3个一维数组，每个一维数组都是默认初始化值null (注意：区别于格式1），可以对这个三个一维数组分别进行初始化，
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];
注：
int[][]arr = new int[][3]; //非法

（3）格式3（静态初始化）：int[][] arr = new int[][]{{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,y[]; x是一维数组，y是二维数组。
Java中多维数组不必都是规则矩阵形式

声明：int[] x,y[]; 以下选项允许通过编译的是：
1、 x[0] = y; //no, x[0]是一个数，y是一个二维数组

2、 y[0] = x; //yes， y[0]就是一维数组，x是一维数组

3、 y[0][0] = x;//no， y[0][0] 是一个数字，x是一维数组

4、 x[0][0] = y;//no， x[0][0] 不存在，x是一维数组，没有第二维

5、 y[0][0] = x[0];//yes， y[0][0] 是一个数字， x[0]是一个数

6、 x = y; //no， x是一维数组，y是一个二维数组
一维数组：int[] x 或者int x[]
二维数组：int[][] y 或者 int[] y[] 或者 int y[][]

数组中涉及的常见算法：
1.求数组元素的最大值、最小值、总和、平均数

   	//数组求最大值：
    	int a[] = new int [] {10,4,8,2,1};
    	int max =a[0];//假设第一个数是最大值
    	for(int i = 0;i//循环每个数
    		if(max < a [i]) {
   			max = a[i];//前后比较，把大的数赋值给max
   		}
    	};
    	System.out.println("最小值="+max);
    //最小值：
    	int b[]=new int[] {2,9,6,0,5};
   	    int min = b[0];//假设第一个数是最小值
     	for(int j=0;j//循环j跟每个数比较
    		if(min > b[j]) {
    			min = b[j];//把最小值赋给min
    		}
    	}
    	System.out.println("最小值="+min);
    		
    //求总和、平均数：
    	int c[]= new int [] {1,5,4,5,5};
    	int sum=0;
    	for(int i=0;i
   		sum += c[i];
    	}
    	System.out.println("总和："+sum);
    	System.out.println("平均数："+(sum/c.length));

数组的复制

int a[]= new int [] {1,5,4,5,5};
 int []copy= new int[a.length];//声明一个跟a长度一致的数组
 for(int i=0;i
	 copy[i]=a[i];//遍历每个a[]的值，按顺序赋予copy
	 } 

数组的反转：

        int arr[]= new int [] {1,5,4,5,5,4};
   		int []temp =new int [arr.length];//考虑声明一个数组b;数组b的长度与a的长度一致，我们倒着循环a，正着给b元素赋值;
   		//temp[0]=arr[5],temp[1]=arr[4],temp[2]=arr[3],temp[3]=arr[2],temp[4]=arr[1],temp[5]=arr[0]    	
   	    int k=0;//k是新数组temp的下标
     	   for(int i=arr.length-1;i>=0;i--) {//一个数组的最后一个元素，它的下标等于数组的长度-1，因为元素的下标是从0开始
        temp[k]=arr[i];//temp就是arr的倒序的数组，
   		k++;
    	}
   	    arr=temp;//然后再把temp的赋值给arr
   	       for(int i=0;i
   		         System.out.println(arr[i]);
    	}

冒泡排序

• 排序思想：相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其它的数进行类似操作。

作业：使用简单数组
(1)创建一个名为TestArray的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。
(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
(3)显示array1的内容。
(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。

public class TestArray {
	public static void main(String【】 args) {
         int [] array1=new int[]{2,3,5,7,11,13,17,19};
		 int [] array2=new int[array1.length];
		     for(int i=0;i
			    System.out.print(array1[i]+"t");
		 }
		 System.out.println();
		  array2=array1;
		     for(int i=0;i
			    if(i%2==0){
				   array2[i]=i;
				   System.out.print(array2[i]+"t");
			}
		}
}
}

数组操作常见问题
（1）数组下标越界异常(ArrayIndexOutOfBoundsException)

   int[] arr = new int[2];
  System.out.println(arr[2]);
//访问到了数组中的不存在的脚标时发生。

（2）空指针异常(NullPointerException)

int[] arr = null;
System.out.println(arr[0]);
//arr引用没有指向实体，却在操作实体中的元素时。