第2章 Java基本语法

2019独角兽企业重金招聘Python工程师标准>>>

2.1 关键字

关键字的定义和特点

定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）。

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

保留字

Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标记符时要避免使用这些保留字：byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const

2.2 标识符

标识符

Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符。 凡是自己可以起名字的地方都叫标识符。

定义合法标识符规则

• 由26个英文字母大小写，0-9 ，_或 $ 组成。
• 数字不可以开头。
• 不可以使用关键字和保留字，但能包含关键字和保留字。
• Java中严格区分大小写，长度无限制。
• 标识符不能包含空格。

在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

Java中的名称命名规范

• 包名：多单词组成时所有字母都小写。如：xxxyyyzzz。
• 类名、接口名：多单词组成时，所有单词的首字母大写。如：XxxYyyZzz。
• 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。如：xxxYyyZzz。
• 常量名：所有字母都大写。多单词时每个单词用下划线连接。如：XXX_YYY_ZZZ。

2.3 变 量

变量的概念

• 内存中的一个存储区域。
• 该区域有自己的名称（变量名）和类型（数据类型）。
• Java中每个变量必须先声明，后使用。
• 该区域的数据可以在同一类型范围内不断变化。

使用变量注意

• 变量的作用域：一对{ }之间有效。
• 初始化值。

定义变量的格式

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

变量是通过使用变量名来访问这块区域的

变量的分类-按数据类型

对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。

变量的分类-按声明的位置的不同

• 在方法体外，类体内声明的变量称为成员变量。
• 在方法体内部声明的变量称为局部变量。

二者在初始化值方面的异同

同：都有生命周期。
异：局部变量除形参外，需显式初始化。

整数类型：byte、short、int、long

• Java各整数类型有固定的表数范围和字段长度，不受具体操作系统的影响，以保证java程序的可移植性。
• Java的整型常量默认为int 型，声明long型常量须后加‘l’或‘L’。（推荐使用L）

浮点类型：float、double

• 与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。
• Java的浮点型常量默认为double，声明float型常量，须后加‘f’或‘F’（推荐使用F）。
• 浮点型常量有两种表示形式：

1. 十进制数形式：如：5.12、512.0f、.512 (必须有小数点）
2. 科学计数法形式:如：5.12e2、512E2、100E-2

字符类型：char

• char 型数据用来表示通常意义上“字符”(2字节)
• 字符型常量的三种表现形式：

1. 字符常量是用**单引号(‘’)**括起来的单个字符，涵盖世界上所有书面语的字符。 例如：char c1 = 'a'; char c2 = '中'; char c3 = '9'。

2. Java中还允许使用**转义字符‘\’**来将其后的字符转变为特殊字符型常量。 例如：char c3 = ‘\n’; // '\n'表示换行符。

3. 直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。 如：\u000a 表示 \n。

• char类型是可以进行运算的。因为它都对应有Unicode码。

ASCII 码（略）

• 在计算机内部，所有数据都使用二进制表示。每一个二进制位（bit）有 0 和 1 两种状态，因此 8 个二进制位就可以组合出 256 种状态，这被称为一个字节（byte）。一个字节一共可以用来表示 256 种不同的状态，每一个状态对应一个符号，就是 256 个符号，从 0000000 到 11111111。
• ASCII码：上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0。
• 缺点：

1. 不能表示所有字符。
2. 相同的编码表示的字符不一样：比如，130在法语编码中代表了é，在希伯来语编码中却代表了字母Gimel (ג)

Unicode 编码（略）

• 乱码：世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码。
• Unicode：一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用 Unicode 没有乱码的问题。
• Unicode 的缺点：Unicode 只是一个符号集，它只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储：无法区别 Unicode 和 ASCII：计算机无法区分三个字节表示一个符号还是分别表示三个符号。

UTF-8（略）

• UTF-8 是在互联网上使用最广的一种 Unicode 的实现方式。
• UTF-8 是一种变长的编码方式。它可以使用 1-6 个字节表示一个符号，根据不同的符号而变化字节长度。
• UTF-8的编码规则：

1. 对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码（等同于ASCII码）。
2. 对于多字节的UTF-8编码，如果编码包含 n 个字节，那么第一个字节的前 n 位为1，第一个字节的第 n+1 位为0，该字节的剩余各位用来对字符进行编码。在第一个字节之后的所有的字节，都是最高两位为"10"，其余6位用来对字符进行编码。

布尔类型：boolean

• boolean 类型适于逻辑运算，一般用于程序流程控制：

if 条件控制语句；
while 循环控制语句； do-while 循环控制语句；
for 循环控制语句；

• boolean类型数据只允许取值true和false，无null。 不可以0或非0的整数替代false和true。

练习1

String str1 = 4; //判断对错：错 String str2 = 3.5f + ""; //判断str2对错：对 System.out.println(str2); //输出：3.5 System.out .println(3+4+"Hello!"); //输出：7Hello! System.out.println("Hello!"+3+4); //输出：Hello!34 System.out.println('a'+1+"Hello!"); //输出：98Hello! a==97 System.out.println("Hello"+'a'+1); //输出：Hello!a1

强制类型转换

• 自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符（()），但可能造成精度降低或溢出，格外要注意。
• 通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。 如：

String a = "43"; 
int i = Integer.parseInt(a);

• boolean类型不可转换为其它的数据类型。

补充： String类

• 值null可以赋值给任何**引用类型（类、接口、数组）**的变量，用以表示这个引用类型变量中保存的地址为空。
• String类属于引用类型，可用null赋值。
• String类是一个典型的不可变类，String对象创建出来就不可能被改变。创建出的字符串将存放在数据区，保证 每个字符串常量只有一个，不会产生多个副本。

String s0 = "hello";
String s1 = "hello";
String s2 = "he" + "llo";
System.out.println(s0 == s1);   //true
System.out.println(s0 == s2);  //true

String s3 = new String("hello");

又如何理解呢？

练习2

判断是否能通过编译
1）short s = 5;
s = s-2; //判断：no，改为 s =(short)(s-2);
2） byte b = 3;
b = b + 4; //判断：no，改为 b = (byte)(b + 4);
b = (byte)(b+4); //判断：yes
3） char c = 'a';
int i = 5;
double d = .314;
double result = c+i+d; //判断：yes a==97, 102.314
4） byte b = 5;
short s = 3;
short t = s + b; //判断：no,应该是 int类型接收

2.4运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

包括：

• 算术运算符
• 赋值运算符
• 比较运算符（关系运算符）
• 逻辑运算符
• 位运算符（略）
• 三元运算符

算术运算符

算术运算符的注意问题

• 如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。
• 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。 例如：

int x=3510;
x=x/1000*1000;

x的结果是？3000

• "+" 除字符串相加功能外，还能把非字符串转换成字符串。 例如：

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

• 以下二者的区别：

System.out.println('*' + '\t' +'*');   //93
System.out.println("*" + '\t' +'*');   //*	*

练习1：算术运算符：自加、自减

public class TestSign {
    public static void main(String[] args) {
        int i1 = 10, i2 = 20;
        int i = i1++;
        System.out.println("i=" + i);  //  i=10
        System.out.println("i1=" + i1);  //  i1=11
        i = ++i1;
        System.out.println("i=" + i); //   i=12
        System.out.println("i1=" + i1); // i1=12
        i = i2--;
        System.out.println("i=" + i); //  i=20
        System.out.println("i2=" + i2); // i2=19
        i = --i2;
        System.out.println("i=" + i); //   i=18
        System.out.println("i2=" + i2); //i2=18

    }
}

赋值运算符

• 符号：=

1. 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
2. 支持连续赋值。

• 扩展赋值运算符： +=, -=, *=, /=, %=

思考： ①和②有什么区别？

short s = 3; 
s=s+2;  // ①
s+=2;   // ②

① 编译失败。s=(short)(s+2); ② 编译通过

思考：

boolean b1 = false;
//区分好==和=的区别。
if(b1=true)
System.out.println("结果为真");  //输出
else
System.out.println("结果为假");

思考：

int i = 1;
i *= 0.1;
System.out.println(i);  //0
i++;
System.out.println(i);  //1

比较运算符

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

逻辑运算符

• ^ —逻辑异或
• &—逻辑与
• | —逻辑或
• && —短路与 （重点）
• || —短路或（重点）
• ！—逻辑非（重点）

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

单&时，左边无论真假，右边都进行运算； 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

• “|”和“||”的区别

||表示：当左边为真，右边不参与运算。

• 异或( ^ )与或( | )的不同之处是

当左右都为true时，结果为false。

理解：异或，追求的是“异”!

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

int x = 1;
int y = 1;
if (x++ == 2 & ++y == 2) {
    x = 7;
}
System.out.println("x=" + x + ",y=" + y);  //x=2,y=2

int x = 1, y = 1;
if (x++ == 2 && ++y == 2) {
    x = 7;
}
System.out.println("x=" + x + ",y=" + y);  //x=2,y=1

int x = 1, y = 1;
if (x++ == 1 | ++y == 1) {
    x = 7;
}
System.out.println("x=" + x + ",y=" + y);  //x=7,y=2

int x = 1, y = 1;
if (x++ == 1 || ++y == 1) {
    x = 7;
}
System.out.println("x=" + x + ",y=" + y); //x=7,y=1

位运算符（略）

三元运算符

格式：

• 表达式1和表达式2为同种类型

• 三元运算符与if-else的联系与区别：

三元运算符可简化if-else语句。 三元运算符要求必须返回一个结果。 if后的代码块可有多个语句。

练习

• 获取两个数中的较大数。

int num1 = 1;
int num2 = 2;
int max = num1 > num2 ? num1 : num2;
System.out.println(max);

• 获取三个数中的较大数。

int num1 = 0;
int num2 = -1;
int num3 = 1;
int temp = num1 > num2 ? num1 : num2;
int max = temp > num3 ? temp : num3;
System.out.println(max);

运算符的优先级

• 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。 如右表，上一行运算符总优先于下一行。
• 只有单目运算符、三元运算符、赋值运算符是从右向左运算的。

2.5 程序流程控制

• 顺序结构

程序从上到下逐行地执行，中间没有任何判断和跳转。

• 分支结构

根据条件，选择性地执行某段代码。 有if…else和switch两种分支语句。

• 循环结构

根据循环条件，重复性的执行某段代码。 有while、do…while、for三种循环语句。 注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

顺序结构

Java中定义成员变量时采用合法的前向引用。如：

public class Test{
    int num1 = 12;
    int num2 = num1 + 2;
}

错误形式：

public class Test{
   int num2 = num1 + 2;   //num1 未声明
   int num1 = 12;
}

分支语句1： if-else语句

if语句三种格式：

if(true){
	执行代码块；
}

if(条件表达式){
	执行代码块；
}
else{
	执行代码块；
}

if(条件表达式){
	执行代码块；
}
else if (条件表达式){
	执行代码块；
}
......
else{
	执行代码块；
}

if-else语句应用举例

public class TestAge {
    public static void main(String args[]) {
        int age = 75;
        if (age < 0) {
            System.out.println("不可能！");
        } else if (age > 250) {
            System.out.println("是个妖怪！");
        } else {
            System.out.println("人家芳龄" + age + ", 马马乎乎啦！");
            // 人家芳龄75, 马马乎乎啦！
        }
    }
}

if语句例题1

从键盘输入小明的期末成绩。 当成绩为100分时，奖励一辆BMW； 当成绩为（80，99]时，奖励一个台iphone5s； 当成绩为[60,80]时，奖励一本参考书； 其它时，什么奖励也没有。

public class Test1 {
	public static void main(String[] args) {
		int score = 69;
		if (score == 100) {
			System.out.println("奖励一辆BMW");
		} else if (score > 80 && score <= 99) {
			System.out.println("奖励一个台iphone5s");
		} else if (score > 60 && score <= 80) {
			System.out.println("奖励一本参考书");
		} else {
			System.out.println("什么奖励也没有");
		}
	}
}

if语句例题2

编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else),并且从小到大输出。

public class Test2 {
	public static void main(String[] args) {
		int num1 = 11112121;
		int num2 = 112290002;
		int num3 = 3322233;
		if (num1 > num2 && num1 > num3) {
			System.out.println(num1);
		} else if (num2 > num3 && num2 > num1) {
			System.out.println(num2);
		} else if (num3 > num1 && num3 > num2) {
			System.out.println(num3);
		}
	}
}

if语句练习1

1)对下列代码，若有输出，指出输出结果。

int x = 4;
int y = 1;
if (x > 2) {
       if (y > 2) 
                System.out.println(x + y);
                System.out.println("baidu");  //baidu
} else
       System.out.println("x is " + x);

 boolean b = true;
    if (b == false)  //如果写成if(b=false)能编译通过吗？如果能，结果是？ //能，c
        System.out.println("a");
    else if (b)
        System.out.println("b");  //b
    else if (!b)
        System.out.println("c");
    else
        System.out.println("d");

if语句练习2

大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件：高：180cm以上；富：财富1千万以上；帅：是。 如果这三个条件同时满足，则：“我一定要嫁给他!!!” 如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。” 如果三个条件都不满足，则：“不嫁！”

public class Test4 {
	public static void main(String[] args) {
		int high = 18;
		int wealth = 10009;
		boolean handsome = false;
		if (high > 180 && wealth > 10000000 && handsome) {
			System.out.println("我一定要嫁给他!!!");
		} else if (high > 180 || wealth > 10000000 || handsome) {
			System.out.println("嫁吧，比上不足，比下有余。");
		} else {
			System.out.println("不嫁");
		}
	}
}

分支结构2：switch语句

switch(变量){
	case 常量1:
		 语句1;
		break;
	case 常量2:
		 语句2;
		break;
	......
	case 常量N:
		 语句N;
		break;
	default:
		语句;
		break;
} 

switch语句应用举例

public class Test{
       public static void main(String args[]){
		int i = 1;
		switch (i) {
		case 0:
			System.out.println("zero");
			break;
		case 1:
			System.out.println("one");  //one
			break;
			default:
			System.out.println("default");
			break;
		}
	}
}

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;
            }
		}
}

使maven支持JDK1.7

    
        
            org.apache.maven.plugins
            maven-compiler-plugin
            3.1
            
                1.7
                1.7
            
        
    

switch语句有关规则

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

例题

1.使用 switch 把小写类型的 char型转为大写。只转换 a, b, c, d, e. 其它的输出 “other”。

public class Test5 {
	public static void main(String[] args) {
		char ch = 'z';
		switch (ch) {
		case 'a':
			ch = 'A';
			System.out.println(ch);
			break;
		case 'b':
			ch = 'B';
			System.out.println(ch);
			break;
		case 'c':
			ch = 'C';
			System.out.println(ch);
			break;
		case 'd':
			ch = 'D';
			System.out.println(ch);
			break;
		case 'e':
			ch = 'E';
			System.out.println(ch);
			break;
		default:
			System.out.println("other");
			break;
		}
	}
}

2.对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

public class Test6 {
	public static void main(String[] args) {
		int score = 8;
		if(score>60){
			System.out.println("合格");
		}else if(score<60){
			System.out.println("不合格");
		}
	}
}

3.根据用于指定月份，打印该月份所属的季节。 3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季。

public class Test7 {
	public static void main(String[] args) {
		int month = 6;
		switch (month) {
		case 3:
		case 4:
		case 5:
			System.out.println("春季");
			break;
		case 6:
		case 7:
		case 8:
			System.out.println("夏季");
			break;
		case 9:
		case 10:
		case 11:
			System.out.println("秋季");
			break;
		case 12:
		case 1:
		case 2:
			System.out.println("冬季");
			break;
		}
	}
}

4.编写程序：从键盘上输入2014年的“month”和“day”，要求通过程序输出输入的日期为2014年的第几天。

public class Test8 {
	public static void main(String[] args) {
		int month = 3;
		int day = 7;
		switch (month) {
		case 1:
			System.out.println("第" + day + "天");
			break;
		case 2:
			day = 31 + day;
			System.out.println("第" + day + "天");
			break;
		case 3:
			day = 31 + 28 + day;
			System.out.println("第" + day + "天");
			break;
		case 4:
			day = 31 + 28 + 31 + day;
			System.out.println("第" + day + "天");
			break;
		case 5:
			day = 31 + 28 + 31 + 30 + day;
			System.out.println("第" + day + "天");
			break;
		case 6:
			day = 31 + 28 + 31 + 30 + 31 + day;
			System.out.println("第" + day + "天");
			break;
		case 7:
			day = 31 + 28 + 31 + 30 + 31 + 30 + day;
			System.out.println("第" + day + "天");
			break;
		case 8:
			day = 31 + 28 + 31 + 30 + 31 + 30 + 31 + day;
			System.out.println("第" + day + "天");
			break;
		case 9:
			day = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + day;
			System.out.println("第" + day + "天");
			break;
		case 10:
			day = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + day;
			System.out.println("第" + day + "天");
			break;
		case 11:
			day = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + day;
			System.out.println("第" + day + "天");
			break;
		case 12:
			day = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + day;
			System.out.println("第" + day + "天");
			break;
		default:
			System.out.println("月份输入错误");
			break;
		}
	}
}

switch语句练习1

使用switch语句改写下列if语句：

 int a = 3;
 int x = 100;
 if(a==1)
	x+=5;
 else if(a==2)
	x+=10;
 else if(a==3)
	x+=16;
 else		
	x+=34;

修改为：

public class Test9 {
	public static void main(String[] args) {
		int a = 3;
		int x = 100;
		switch (a) {
		case 1:
			x += 5;
			break;
		case 2:
			x += 10;
			break;
		case 3:
			x += 16;
			break;
		default:
			x += 34;
			break;
		}
		System.out.println(a);
		System.out.println(x);
	}
}

switch和if语句的对比

if 和 switch语句很像，具体什么场景下，应用哪个语句呢？

• 如果判断的具体数值不多，而且符合byte、 short 、int、 char这四种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。
• 其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。

switch语句练习2

编写程序：从键盘上读入一个学生成绩，存放在变量score中，根据score的值输出其对应的成绩等级：
score≥90 等级：A
70= 60 score<60 等级：D

public class Test10 {
	public static void main(String[] args) {
		int score = 88;
		if (score >= 90) {
			System.out.println("A");
		} else if (score >= 70 && score < 90) {
			System.out.println("B");
		} else if (score >= 60 && score < 70) {
			System.out.println("C");
		} else if (score < 60) {
			System.out.println("D");
		}
	}
}

switch语句练习3

从键盘分别输入年、月、日，判断这一天是当年的第几天 注：判断一年是否是闰年的标准： 1）可以被4整除，但不可被100整除 2）可以被400整除

public class Test11 {
	public static void main(String[] args) {
		int year = 2020;
		int month = 8;
		int day = 10;

		switch (month) {
		case 1:
			System.out.println("第" + day + "天");
			break;
		case 2:
			day = 31 + day;
			System.out.println("第" + day + "天");
			break;
		case 3:
			day = 31 + 28 + day;
			System.out.println("第" + day + "天");
			break;
		case 4:
			day = 31 + 28 + 31 + day;
			System.out.println("第" + day + "天");
			break;
		case 5:
			day = 31 + 28 + 31 + 30 + day;
			System.out.println("第" + day + "天");
			break;
		case 6:
			day = 31 + 28 + 31 + 30 + 31 + day;
			System.out.println("第" + day + "天");
			break;
		case 7:
			day = 31 + 28 + 31 + 30 + 31 + 30 + day;
			System.out.println("第" + day + "天");
			break;
		case 8:
			day = 31 + 28 + 31 + 30 + 31 + 30 + 31 + day;
			System.out.println("第" + day + "天");
			break;
		case 9:
			day = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + day;
			System.out.println("第" + day + "天");
			break;
		case 10:
			day = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + day;
			System.out.println("第" + day + "天");
			break;
		case 11:
			day = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + day;
			System.out.println("第" + day + "天");
			break;
		case 12:
			day = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + day;
			System.out.println("第" + day + "天");
			break;
		default:
			System.out.println("月份输入错误");
			break;
		}
		boolean flag = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
		if (flag) {
			System.out.println("闰年");
		} else {
			System.out.println("不是闰年");
		}

	}
}

循环结构

• 循环语句功能

在某些条件满足的情况下，反复执行特定代码的功能。

• 循环语句的四个组成部分

初始化部分（init_statement） 循环条件部分（test_exp） 循环体部分（body_statement） 迭代部分（alter_statement）

• 循环语句分类

for 循环 while 循环 do/while 循环

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语句例题

编写程序FooBizBaz.java，从1循环到150并在每行打印一个值，另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7的倍数行上打印输出“baz”。 1 2 3 foo 4 5 biz 6 foo 7 baz … 15 foo biz … 105 foo biz baz

public class FooBizBaz {
	public static void main(String[] args) {
		String str = "";
		for (int i = 1; i <= 150; i++) {
			str = i + "";
			if (i % 3 == 0) {
				str = i + "foo";
			}
			if (i % 5 == 0) {
				str += "biz";
			}
			if (i % 7 == 0) {
				str += "baz";
			}

			System.out.println(str);
		}
	}
}

for语句练习

1.打印1~100之间所有奇数的和

public class Test13 {
	public static void main(String[] args) {
		int sum = 0;
		for (int i = 1; i <= 100; i++) {
			if (i % 2 != 0) {
				sum += i;
			}
		}
		System.out.println(sum);
	}
}

2.打印1~100之间所有是7的倍数的整数的个数及总和（体会设置计数器的思想）

public class Test14 {
	public static void main(String[] args) {
		int sum = 0;
		for (int i = 1; i <= 100; i++) {
			if (i % 7 == 0) {
				// System.out.println(i);
				sum++;
			}
		}
		System.out.println(sum);
	}
}

3.输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。例如： 153 = 111 + 333 + 555

public class Test15 {
	public static void main(String[] args) {
		for (int i = 100; i <= 999; i++) {
			int bai = i / 100;
			int shi = i % 100 / 10;
			int ge = i % 100 % 10;
			if (i == bai * bai * bai + shi * shi * shi + ge * ge * ge) {
				System.out.println(i);
			}

		}
		// int i = 782;
		// System.out.println(i / 100);
		// System.out.println(i % 100 / 10);
		// System.out.println(i % 100 % 10);
	}
}

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);
    }
}

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之间所有偶数的和。用for和while语句分别完成。

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

		int sum2 = 0;
		int k = 1;
		while (k <= 100) {
			if (k % 2 == 0) {
				sum2 += k;
			}
			k++;
		}
		System.out.println(sum2);
		//总结：还是for好.
		//while循环容易把累计条件忘记写了，结果导致内存溢出。
	}
}

编写程序二：从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。

public class Test17 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入整数：");
        int positive = 0;
        int negative = 0;
        while (true) {   //死循环
            int num = input.nextInt();
            if (num > 0) {
                positive++;
            } else if (num < 0) {
                negative++;
            } else {
                break;  //跳出死循环
            }
        }
        System.out.println("正数的个数是：" + positive);
        System.out.println("负数的个数是：" + negative);
    }
}

补充

最简单无限循环格式：while(true) 或 for(;;)。 无限循环存在的原因是并不知道循环多少次，需要根据某些条件，来控制循环。

class PositiveNegative {
	public static void main(String[] args) {
		//while(true)
		Scanner scanner = new Scanner(System.in);
        int a = 0;//统计正数的个数
        int b = 0;//统计负数的个数
        for(;;){
            System.out.println("请输入一个整数：");
            int z = scanner.nextInt();
            if(z>0)
                a++;
            else if(z<0)
                b++;
            else
                break; 
        }
        System.out.println("正数的个数为："+a);
        System.out.println("负数的个数为："+b);
	} 
}

嵌套循环

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

练习题

九九乘法表

public class Test20 {
    public static void main(String[]args){
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(i+"*"+j+"="+(i*j)+"\t");
            }
            System.out.println();
        }
    }
}

1—100之间的所有质数。 质数又称素数。指在一个大于1的自然数中，除了1和此整数自身外，不能被其他自然数整除的数。

 public class Test21 {
    public static void main(String[] args) {
        int n = 100;
        outer:
        for (int i = 2; i < n; i++) {
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    continue outer;
                }
            }
            System.out.println(i);
        }
    }
}

特殊流程控制语句1

• break 语句 break语句用于终止某个语句块的执行

{   ......
	  break;
    ......
}

break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块

label1:  {  ...... 
label2:	         {  ......
label3:			{   ......
		   break label2;
		   ......
		        }
	          }
         }

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语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环。

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

• return：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。
• 与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内。

特殊流程控制语句说明

• break只能用于switch语句和循环语句中。
• continue 只能用于循环语句中。
• 二者功能类似，但continue是终止本次循环，break是终止本层循环。
• break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
• 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。

2.6 数组

• 数组是多个相同类型数据的组合，实现对这些数据的统一管理。
• 数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
• 数组属引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象的成员变量。

一维数组声明

一维数组的声明方式： type var[] 或 type[] var； 例如：

int a[];
int[] a1;
double  b[];
Mydate[] c;  //对象数组	

Java语言中声明数组时不能指定其长度(数组中元素的数)。 例如：

int a[5];    //非法

一维数组初始化

动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行。

int[] arr = new int[3];
arr[0] = 3;
arr[1] = 9;
arr[2] = 8;

MyDate dates[];
dates = new MyDate[3];
dates[0] = new MyDate(22, 7, 1964);
dates[1] = new MyDate(1, 1, 2000);
dates[2] = new MyDate(22, 12, 1964);

静态初始化：在定义数组的同时就为数组元素分配空间并赋值。

int a[] = new int[]{ 3, 9, 8};
int[] a = {3,9,8};

MyDate dates[] = {
        new MyDate(22, 7, 1964),
        new MyDate(1, 1, 2000),
        new MyDate(22, 12, 1964)
}

创建基本数据类型数组

Java中使用关键字new创建数组对象。

创建基本数据类型一维数组对象

public class Test{
   public static void main(String args[]){
	int[] s;
	s = new int[10];
	for ( int i=0; i<10; i++ ) {
	    s[i] =2*i+1;
		System.out.println(s[i]);
	}
   }
}

创建对象数组

创建元素为引用类型(对象)的数组

class MyDate{
        
        private int day;
        private int month;
        private int year;
        
        public MyDate(int d, int m, int y){
		    day = d;    
		    month = m;   
		    year = y;
        }
        
        public void display(){
	    	System.out.println(year + "-" + month + "-" + day);
        }
 }

数组元素的默认初始化

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

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

• 对于基本数据类型而言，默认初始化值各有不同。
• 对于引用数据类型而言，默认初始化值为null(注意与0不同！)。

数组元素的引用

• 定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
• 数组元素的引用方式：数组名[数组元素下标]

1. 数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
2. 数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 → n-1； 如 int a[]=new int[3]; 可引用的数组元素为a[0]、a[1]、a[2]

• 每个数组都有一个属性length指明它的长度。 例如：a.length 指明数组a的长度(元素个数) 数组一旦初始化，其长度是不可变的。

练习1:

1.(1)定义类Pritimive，在类中定义一个有3个元素的boolean类型的数组t作为其成员变量。数组元素未赋值。 定义类Array1，在Array1的main()方法中创建Pritimive对象d，输出其成员变量t的三个元素值。 练习目的：检验基本数据类型数组创建时的自动赋值。 (2)给对象d的成员变量t赋值为{true,true,true}，并输出t的三个元素值。

2.定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定，打印出3年级(state值为3）的学生信息。 提示：生成随机数：Math.random()，返回值类型double;
四舍五入取整：Math.round(double d)，返回值类型long。

3.从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
成绩>=最高分-10 等级为’A’
成绩>=最高分-20 等级为’B’ 成绩>=最高分-30 等级为’C’
其余等级为’D’
提示：先读入学生人数，根据人数创建int数组，存放学生成绩。

多维数组（略）

数组中涉及的常见算法

• 求数组元素的最大值、最小值、平均数、总和等
• 数组的复制、反转
• 数组元素的排序

练习5

定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，平均值，和值，并输出出来。

public class TestArray {
    public static void main(String[] args) {
        int nums[] = {2, 3, 5, 7, -9, 3, 4, 1, 6, 0};
        int max = nums[0];   //最大值
        int min = nums[0];   //最小值
        int avg = 0;         //平均值
        int sum = 0;         //和值
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > max) {
                max = nums[i];
            }
            if (nums[i] < min) {
                min = nums[i];
            }
            sum += nums[i];
            avg = sum / nums.length;
        }
        System.out.println("max=" + max);
        System.out.println("min=" + min);
        System.out.println("sum=" + sum);
        System.out.println("avg=" + avg);
    }
}

练习 6

使用简单数组
(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 = { 2, 3, 5, 7, 11, 13, 17, 19 };
		for (int i = 0; i < array1.length; i++) {
			System.out.println(array1[i]);
		}
		System.out.println("--------------");
		int[] array2 = array1;
		for (int k = 0; k < array2.length; k++) {
			if (k % 2 == 0) {
				array2[k] = k;
				System.out.println(array2[k]);
			}
		}
	}
}

思考：array1和array2是什么关系？ 拓展：修改题目，实现array2对array1数组的复制

数组排序

• 插入排序

直接插入排序、折半插入排序、Shell排序

• 交换排序

冒泡排序、快速排序（或分区交换排序）

• 选择排序

简单选择排序、堆排序

• 归并排序
• 基数排序

排序方法的选择

(1)若n较小(如n≤50)，可采用直接插入或直接选择排序。 当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插入，应选直接选择排序为宜。

(2)若文件初始状态基本有序(指正序)，则应选用直接插入、冒泡或随机的快速排序为宜；

(3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。

冒泡排序

排序思想：

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

数组排序

java.util.Arrays类的sort()方法提供了数组元素排序功能：

import java.util.*;
public class Sort {
	public static void main(String[] args) {
		int [] number = {5,900,1,5,77,30,64,700};
		Arrays.sort(number);
		for(int i = 0; i < number.length; i++)
			System.out.println(number[i]);
	}
}

操作数组的工具类：Arrays

java.util.Arrays类包含了用来操作数组（比如排序和搜索）的各种方法。Arrays拥有一组static方法。

• equals()：比较两个array是否相等。array拥有相同元素个数，且所有对应元素两两相等。
• fill()：将值填入array中。 
• sort()：用来对array进行排序。 
• binarySearch()：在排好序的array中寻找元素。 
• System.arraycopy()：array的复制。   

数组操作常见问题

• 数组脚标越界异常(ArrayIndexOutOfBoundsException)

int[] arr = new int[2];
System.out.println(arr[2]);

访问到了数组中的不存在的脚标时发生。

• 空指针异常(NullPointerException)

int[] arr = null;
System.out.println(arr[0]);

arr引用没有指向实体，却在操作实体中的元素时。

转载于:https://my.oschina.net/mondayer/blog/3024315