Head First Java 和 AcWing Java课程做的总结2。
2.1 判断语句
if语句
基本 if-else 语句:
- 当条件成立时，执行某些语句；否则执行另一些语句。
- else 语句可以省略
- 当只有一条语句时，大括号可以省略
(与C++不同的是，括号() 中的语句不能是单纯的数，如1/2/0等，而只能是逻辑表达式，即结果是 true 或 false )
练习：判断闰年
闰年有两种情况：
(1) 能被100整除时，必须能被400整除；
(2) 不能被100整除时，被4整除即可。
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int year = sc.nextInt();
if(year % 100 == 0){
if(year % 400 == 0)
System.out.println("Yes");
else
System.out.println("No");
}else{
if(year % 4 == 0)
System.out.println("Yes");
else
System.out.println("No");
}
}
}
常用比较运算符：
- 大于
> - 小于
< - 大于等于
>= - 小于等于
<= - 等于
== - 不等于
!=
用于逻辑表达式中，举例：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int a = nextInt(), b = nextInt();
if(a > b)System.out.printf("%d > %d\n", a, b);
if(a < b)System.out.printf("%d < %d\n", a, b);
if(a >= b)System.out.printf("%d >= %d\n", a, b);
if(a <= b)System.out.printf("%d <= %d\n", a, b);
if(a == b)System.out.printf("%d == %d\n", a, b);
if(a != b)System.out.printf("%d != %d\n", a, b);
}
}
if-else 连写：
if (s >= 85) {
System.out.println("A");
} else if (s >= 70) {
System.out.println("B");
} else if (s >= 60) {
System.out.println("C");
} else {
System.out.println("D");
}
条件表达式
- 与
&& - 或
|| - 非
!
举例：判断闰年
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int year = sc.nextInt();
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
System.out.println("yes");
else
System.out.println("no");
}
}
switch语句
注意： swtich语句中如果不加break语句，则从上到下匹配到第一个case后，会顺次执行后面每个case中的语句。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int day = sc.nextInt();
String name;
switch(day) {
case 1:
name = "Monday";
break;
case 2:
name = "Tuesday";
break;
case 3:
name = "Wednesday";
break;
case 4:
name = "Thursday";
break;
case 5:
name = "Friday";
break;
case 6:
name = "Saturday";
break;
case 7:
name = "Sunday";
break;
default:
name = "not valid";
}
System.out.println(name);
}
}
2.2 循环语句
while循环
可以简单理解为循环版的if语句。if语句是判断一次，如果条件成立，则执行后面的语句；while是每次判断，如果成立，则执行循环体中的语句，否则停止。
public class Main {
public static void main(String[] args) {
int i = 1, sum = 0;
while (i <= 100) {
sum += i * i * i;
i ++ ;
}
System.out.println(sum);
}
}
死循环：循环永久执行，无法结束。我们要避免写出死循环。比如：
int x = 1;
while (x == 1)
System.out.println("!");
do-while 循环
do while循环不常用。
do while语句与while语句非常相似。唯一的区别是，do while语句限制性循环体后检查条件。不管条件的值如何，我们都要至少执行一次循环。
public class Main {
public static void main(String[] args) {
int x = 1;
while (x < 1) {
System.out.println("x!");
x ++ ;
}
int y = 1;
do {
System.out.println("y!");
} while (y < 1);
}
}
for循环
基本思想：把控制循环次数的变量从循环体中剥离。
for (init-statement : condition: expression) {
statement
}
init-statement可以是声明语句、表达式、空语句，一般用来初始化循环变量；
condition是条件表达式，和while中的条件表达式作用一样；可以为空，空语句表示true；
expression一般负责修改循环变量，可以为空。
public class Main {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 100; i ++ )
sum += i * i * i;
System.out.println(sum);
}
}
// 循环体中只有一条语句时，可以不加大括号
init-statement可以定义多个变量，expression也可以修改多个变量。
public class Main {
public static void main(String[] args) {
int sum = 0;
for (int i = 1, j = 10; i < j; i ++, j -- ) {
sum += i * j;
}
System.out.println(sum);
}
}
跳转语句
break：
可以提前从循环中退出，一般与if语句搭配。
continue：
可以直接跳到当前循环体的结尾。作用与if语句类似。
3.5 多层循环
练习：打印1~100中的所有质数
public class Main {
public static void main(String[] args) {
for (int i = 2; i <= 100; i ++ ) {
boolean isPrime = true;
for (int j = 2; j < i; j ++ ) {
if (i % j == 0) {
isPrime = false;
break;
}
}
if (isPrime)
System.out.println(i);
}
}
}
2.3 函数
理解函数，最重要的是理解函数的执行顺序。（栈的顺序）
函数基础
一个典型的函数定义包括以下部分：修饰符、返回类型、函数名字、由0个或多个形参组成的列表以及函数体。
编写函数
//求阶乘
public class Main{
//private只有在当前类中可用
//public公有
private static int fact(int val){
int res = 1;
for(int i = 1; i <= val; i++)
res *= i;
return res;
}
}
函数名字是fact，它作用于一个整型参数，返回一个整型值。return语句负责结束fact并返回res的值。
修饰符包括private、static等，它们属于类相关的概念，会在下一章解释。
调用函数
public class Main{
private static int fact(int val){
int res = 1;
for(int i = 1; i <= val; i++)
res *= i;
return res;
}
public static void main(String[] args){
int res = fact(5);
System.out.printf("5! is %d\n", res);
}
}
函数的调用完成两项工作：
- 一是用实参初始化函数对应的形参；
- 二是将控制权转移给被调用函数。此时，主调函数的执行被暂时中断，被调函数开始执行。
形参和实参
实参是形参的初始值。第一个实参初始化第一个形参，第二个实参初始化第二个形参，依次类推。形参和实参的类型和个数必须匹配。
fact("hello"); // 错误：实参类型不正确
fact(); // 错误：实参数量不足
fact(42, 10, 0); // 错误：实参数量过多
fact(' '); // 正确：该实参能自动转换成int类型，' '的ASCII值为32，所以该操作等价于fact(32);
函数的形参列表
函数的形参列表可以为空，但是不能省略。
void f1() {/* …. */} // 空形参列表
形参列表中的形参通常用逗号隔开，其中每个形参都是含有一个声明符的声明。即使两个形参的类型一样，也必须把两个类型都写出来：
int f3(int v1, v2) {/* … */} // 错误
int f4(int v1, int v2) {/* … */} // 正确
函数返回类型
大多数类型都能用作函数的返回类型。一种特殊的返回类型是void，它表示函数不返回任何值。
函数的返回类型也可以是数组、字符串或者其他对象：
import java.util.Arrays;
public class Main {
private static int[] newArray() {
int[] a = {1, 2, 3};
return a;
}
private static String newString() {
return "Hello World";
}
public static void main(String[] args) {
System.out.println(Arrays.toString(newArray()));
System.out.println(newString());
}
}
变量的作用域
本章中我们只使用静态成员变量和静态成员函数，非静态成员变量/函数及其区别会在下一章中介绍。
函数内定义的变量为局部变量，只能在函数内部使用。
定义在类中的变量为成员变量，可以在类的所有成员函数中调用。
当局部变量与全局变量重名时，会优先使用局部变量。
public class Main {
private static int x = 4;
private static void f1() {
int x = 3;
System.out.println(x);
}
private static void f2() {
System.out.println(x);
}
private static void f3() {
System.out.println(x + 1);
}
public static void main(String[] args) {
f1();
f2();
f3();
}
}
参数传递
值传递
八大基本数据类型和String类型等采用值传递。
String不支持修改，每次修改时创建一个新地址来存新的值。原地址值不发生变化。
将实参的初始值拷贝给形参。此时，对形参的改动不会影响实参的初始值。
public class Main {
private static void f(int x) {
x = 5;
}
public static void main(String[] args) {
int x = 10;
f(x);
System.out.println(x);
}
}
引用传递（其实是特殊的值传递，值是遥控器）
除String以外的数据类型的对象，例如数组、StringBuilder等采用引用传递。
将实参的引用（地址）传给形参，通过引用找到变量的真正地址，然后对地址中的值修改。所以此时对形参的修改会影响实参的初始值。
import java.util.Arrays;
public class Main {
private static void f1(int[] a) {
for (int i = 0, j = a.length - 1; i < j; i ++, j -- ) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}
}
private static void f2(StringBuilder sb) {
sb.append("Hello World");
}
public static void main(String[] args) {
int[] a = {1, 2, 3, 4, 5};
f1(a);
System.out.println(Arrays.toString(a));
StringBuilder sb = new StringBuilder("");
f2(sb);
System.out.println(sb);
}
}
返回类型和return语句
return语句终止当前正在执行的函数并将控制权返回到调用该函数的地方。return语句有两种形式：
return;
return expression;
无返回值函数
没有返回值的return语句只能用在返回类型是void的函数中。返回void的函数不要求非得有return语句，因为在这类函数的最后一句后面会隐式地执行return。
通常情况下，void函数如果想在它的中间位置提前退出，可以使用return语句。return的这种用法有点类似于我们用break语句退出循环。
public class Main {
private static void swap(int[] a) { // 交换a[0]和a[1]
// 如果两个值相等，则不需要交换，直接退出
if (a[0] == a[1])
return;
// 如果程序执行到了这里，说明还需要继续完成某些功能
int tmp = a[0];
a[0] = a[1];
a[1] = tmp;
// 此处无须显示的return语句
}
public static void main(String[] args) {
int[] a = {3, 4};
swap(a);
System.out.printf("%d %d\n", a[0], a[1]);
}
}
有返回值函数
只要函数的返回类型不是void，则该函数内的每个分支都必须有return语句，且每条return语句都必须返回一个值。return语句返回值的类型必须与函数的返回类型相同，或者能隐式地转换函数的返回类型。
import java.util.Scanner;
public class Main {
private static int max(int a, int b) {
if (a > b)
return a;
return b;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int x = sc.nextInt(), y = sc.nextInt();
System.out.println(max(x, y));
}
}
函数重载
函数重载是指：在同一个类中存在多个函数，函数名称相同但参数列表不同。
编译器会根据实参的类型选择最匹配的函数来执行。
import java.util.Scanner;
public class Main {
private static int max(int a, int b) {
System.out.println("int max");
if (a > b) return a;
return b;
}
private static double max(double a, double b) {
System.out.println("double max");
if (a > b) return a;
return b;
}
public static void main(String[] args) {
System.out.println(max(3, 4));
System.out.println(max(3.0, 4.0));
}
}
函数递归
在一个函数内部，也可以调用函数本身。
private static int fib(int n) { // 求斐波那切数列第n项
if (n <= 2) return 1;
return fib(n - 1) + fib(n - 2);
}