Java是一门通用性编程语言,其特征包括但不限于面对对象、跨平台、多线程、高性能等等.Java的最大的特点是跨平台,利用及其稳定的Java虚拟机(Java Virtual Machine)同样的源代码可能在任何平台运行。这不仅仅提高了软件的可移植性,也简化了开发者的工作。

Java是一门设计优良的编程语言,它是一门完全的面向对象编程语言,面向对象编程是一种重要的编程思想,对于构建复杂的系统有很大的积极作用.

Java 介绍和环境配置

Java最早是由SUN公司开发的,最早被命名为Oak,最初主要针对于小型家电的嵌入器应用。后来互联网崛起,SUN改造了Oak,在1995以Java的名称正式发布,随着互联网的快速发展,Java也成了最受欢迎的语言。

Java分出了三个不同版本:Java SE (Standard Edition),Java EE (Enterprise Edition) ,和Java ME (Micro Edition).

  • Java SE (Standard Edition) 标准版本,其他包含了JVM和常用的库.
  • Java EE (Enterprise Edition)是企业版本,在Java SE的基础上加了更多的库和API,提供了Web应用、数据库和消息服务等等的库,方便了企业级应用的开发.
  • Java ME (Micro Edition) 嵌入式设备Java开发语言平台.

JVM (Java Virtual Machine)

JVM使你的Java代码在不同的计算机平台上能够顺利运行.一串Java代码在计算机上运行的步骤是:

  1. Java编译器将 Java代码编译成Java字节码
  2. JVM将Java字节码转换成计算机平台支持的机器码(计算机的CPU直接执行的一组指令)
  3. CPU执行机器码

JRE(Java Runtime Environment)

RE(Java运行时环境)是一个软件包,提供Java类库,Java虚拟机(JVM)和运行Java应用程序所需的其他组件。

如果你只需要运行Java代码而不需要开发Java程序,则你只需下载JRE就够了.

JDK(Java Development Kit)

JDK(Java开发套件)是使用Java开发应用程序所需的软件开发套件。当您下载JDK时,还将同时下载JRE。JDK除了包含JRE,还包含许多开发工具(编译器,JavaDoc,Java Debugger等)。

如果你需要进行Java程序开发,则应该下载JDK.

JDK、JRE、JVM的关系如下图:

下载安装Java开发环境

oracle官网下载最新的 Java SE的 JDK.

下载完JDK后,我们需要设置JAVA的环境变量,这样系统运行Java代码时,才能从正确的路径调用程序来运行代码。

MAC

使用Mac的朋友可以使用以下的步骤来设置环境变量:

将下载好的安装包解压缩后,记住安装目录的路径,然后在~/.bach_profile中设置新的环境变量:

1
2
export JAVA_HOME=/Users/haozheng/Java/jdk-13.0.1.jdk/Contents/Home
export PATH=$JAVA_HOME/bin:$PATH

在上面的步骤中,我们将JAVA_HOME的bin(binary)目录添加到PATH是为了在任意文件夹下都可以运行java。

最后在Terminal中运行 java -version 如果出现以下信息就代表Java安装成功了!

1
2
3
4
$ java -version
java version "13.0.1" 2019-10-15
Java(TM) SE Runtime Environment (build 13.0.1+9)
Java HotSpot(TM) 64-Bit Server VM (build 13.0.1+9, mixed mode, sharing)

Windows

Windows平台在安装完成后,也是需要将 jdk 的bin目录添加到 Path中.

运行Java 代码

写完后的Java代码运行示意图如:

源代码被Java编译器转化成字节码(Byte Code),然后通过JVM这个虚拟机,字节码就能在各个平台上运行。

首先我们使用javac编译器将源代码转化成字节码,在Main.java的目录下执行命令 javac Main.java(源代码):

1
$ javac Main.java

如果没有任何的语法错误,那么当前目录中就会多出一个 Main.class 文件(字节码):

1
2
$ ls 
Main.java Main.class

接下来我们就能使用 java Main 来运行程序:

1
2
$ java Main 
Hello World!

变量和内置数据类型

变量

变量是内存中用于存储数据的位置。为了指示存储区域,应该为每个变量赋予唯一的名称(标识符)。

创建变量的语法:以数据类型开始, 空格后面是变量的名字,然后可以紧跟着是数值,最后必须以分号( ; )结尾.

1
int speedLimit = 80;

speedLimitint数据类型的变量,并分配了值80.

您可以在不分配值的情况下声明变量,以后可以根据需要存储值。

1
2
int speedLimit;
speedLimit = 80;

变量的值可以在程序中更改,因此名称为“变量”。

1
2
3
int speedLimit = 80;
... .. ...
speedLimit = 90;

Java是一种静态类型的语言。这意味着必须先声明所有变量,然后才能使用它们。

同样,您不能在同一范围内更改Java中变量的数据类型。

变量命名规则

Java编程语言具有自己的一组变量命名规则和约定

  • Java中的变量区分大小写.
  • 变量的名称是Unicode字母和数字的序列。它可以以字母,$或_开头。但是习惯上以字母开头。同时变量名不能使用空格.
  • 创建变量时,请选择一个有意义的名称。例如: scopenumsn更好理解.
  • 如果选择一个单词的变量名,请使用所有小写字母。
  • 如果选择具有多个单词的变量名,请对第一个单词使用所有小写字母,并在每个后续单词中使用大写字母。

变量类型

Java语言中有四种变量类型:

  • 实例变量(非静态字段)
  • 类变量(静态字段)
  • 局部变量
  • 参数

内置数据类型

Java中有8种基本内置数据类型,这些数据类型的大小和作用各不相同:

数据类型 数据大小 具体描述
byte 1 byte -128到127之间的整数
short 2 bytes -32,768到32,767之间的整数
int 4 bytes 整数(-2,147,483,648 ~ 2,147,483,647)
long 8 bytes 长整数(-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807)
float 4 bytes 浮点数(小数后6到7位)
double 8 bytes 浮点数(小数后15位)
boolean 1 bit true 或 false(正或否)
char 2 bytes 单个字符或字母(ASCII数值)

boolean

  • 布尔数据类型具有两个可能的值,即true或false.
  • 默认值:false.
  • 它们通常用于 true/false 条件.
1
2
3
4
5
6
7
class BooleanExample {
public static void main(String[] args) {

boolean flag = true;
System.out.println(flag);
}
}

输出:

1
true

byte

  • byte类型的值可以从-128到127(8位带符号二进制补码整数).
  • 如果可以确定变量的值在[-128,127]之内,则可以使用它代替int或其他整数数据类型来节省内存.
  • 默认值:0
1
2
3
4
5
6
7
8
class ByteExample {
public static void main(String[] args) {

byte range;
range = 124;
System.out.println(range);
}
}

输出:

1
124

short

  • short类型的值可以从-32768到32767(16位带符号二进制补码整数).
  • 如果可以确定变量的值在[-32768,32767]之内,则可以使用它代替其他整数数据类型来节省内存.
  • 默认值:0
1
2
3
4
5
6
7
8
class ShortExample {
public static void main(String[] args) {

short temperature;
temperature = -200;
System.out.println(temperature);
}
}

输出:

1
-200

int

  • int数据类型的值可以从-2,147,483,648 ~ 2,147,483,647(32位带符号二进制补码整数)
  • 如果使用Java 8或更高版本,则可以使用无符号32位整数,最小值为0。
  • 默认值:0
1
2
3
4
5
6
7
class IntExample {
public static void main(String[] args) {

int range = -4250000;
System.out.println(range);
}
}

输出:

1
-4250000

long

  • 长数据类型的值可以从(-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807)(64位带符号的二进制补码整数)
  • 如果您使用的是Java 8或更高版本,则可以使用最小值为0的无符号64位整数
  • 默认值:0
1
2
3
4
5
6
7
class LongExample {
public static void main(String[] args) {

long range = -42332200000L;
System.out.println(range);
}
}

输出:

1
-42332200000

double

  • double数据类型是双精度64位浮点
  • 切勿将其用于诸如货币之类的精确值
  • 默认值:0.0(0.0d)
1
2
3
4
5
6
7
class DoubleExample {
public static void main(String[] args) {

double number = -42.3;
System.out.println(number);
}
}

输出:

1
-42.3

float

  • float数据类型是单精度32位浮点.
  • 切勿将其用于诸如货币之类的精确值.
  • 默认值:0.0(0.0f)
1
2
3
4
5
6
7
class FloatExample {
public static void main(String[] args) {

float number = -42.3f;
System.out.println(number);
}
}

输出:

1
-42.3

如果需要告诉编译器变量是单精度,应该在数值后面加一个f.

char

  • 这是16位Unicode字符.
  • char数据类型的最小值为'\u0000'(0),char数据类型的最大值为'\uffff'.
  • 默认值:'\u0000'
1
2
3
4
5
6
7
class CharExample {
public static void main(String[] args) {

char letter = '\u0051';
System.out.println(letter);
}
}

输出:

1
Q

您得到输出Q,因为Q的Unicode值为'\u0051'

1
2
3
4
5
6
7
8
9
10
11
class CharExample {
public static void main(String[] args) {

char letter1 = '9';
System.out.println(letter1);

char letter2 = 65;
System.out.println(letter2);

}
}

输出:

1
2
9
A

当您打印letter1时,您会得到9,因为letter1被分配了字符’9’。 当打印letter2时,得到A的原因是ASCII值’A’为65。这是因为java编译器将字符视为整数类型.

运算符

赋值运算符

赋值运算符是给变量赋值

1
2
int age
age = 10

赋值运算符将其右侧的值分配给其左侧的变量。在此,使用=运算符将5分配给age。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class AssignmentOperator {
public static void main(String[] args) {

int number1, number2;

// Assigning 5 to number1
number1 = 5;
System.out.println(number1);

// Assigning value of variable number2 to number1
number2 = number1;
System.out.println(number2);
}
}

算数运算符

算术运算符用于执行数学运算,例如加法,减法,乘法等。

Operator Meaning
+ 加法(也用于字符串连接)
- 减法运算符
* 乘法运算符
/ 除法运算符
% 求余运算符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class ArithmeticOperator {
public static void main(String[] args) {

double number1 = 12.5, number2 = 3.5, result;

// 加法
result = number1 + number2;
System.out.println("number1 + number2 = " + result);

// 减法
result = number1 - number2;
System.out.println("number1 - number2 = " + result);

// 乘法
result = number1 * number2;
System.out.println("number1 * number2 = " + result);

//除法
result = number1 / number2;
System.out.println("number1 / number2 = " + result);

// 求余
result = number1 % number2;
System.out.println("number1 % number2 = " + result);
}
}

输出:

1
2
3
4
5
number1 + number2 = 16.0
number1 - number2 = 9.0
number1 * number2 = 43.75
number1 / number2 = 3.5714285714285716
number1 % number2 = 2.0

add 连接字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class ArithmeticOperator {
public static void main(String[] args) {

String start, middle, end, result;

start = "Talk is cheap. ";
middle = "Show me the code. ";
end = "- Linus Torvalds";

result = start + middle + end;
System.out.println(result);
}
}
// Talk is cheap. Show me the code. - Linus Torvalds

一元运算符

一元运算符仅对一个操作数执行运算。

Operator Meaning
+ 一元加号(由于数字为正数而不使用它,因此无需使用)
- 一元减:反转表达式的符号
++ 增量运算符:将值增加1
-- 递减运算符:将值减1
! 逻辑补码运算符:反转布尔值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class UnaryOperator {
public static void main(String[] args) {

double number = 5.2, resultNumber;
boolean flag = false;

System.out.println("+number = " + +number);
// number is equal to 5.2 here.

System.out.println("-number = " + -number);
// number is equal to -5.2 here.

// ++number is equivalent to number = number + 1
System.out.println("number = " + ++number);
// number is equal to 6.2 here.

// -- number is equivalent to number = number - 1
System.out.println("number = " + --number);
// number is equal to 5.2 here.

System.out.println("!flag = " + !flag);
// flag is still false.
}
}

输出:

1
2
3
4
5
+number = 5.2
-number = -5.2
number = 6.2
number = 5.2
!flag = true

自增或自减运算符

您也可以在Java中同时使用++和-运算符作为前缀和后缀。 ++运算符将值增加1,而-运算符将值减少1。

1
2
3
4
5
int myInt = 5;
++myInt // myInt becomes 6
myInt++ // myInt becomes 7
--myInt // myInt becomes 6
myInt-- // myInt becomes 5

等于与关系运算符

等于和关系运算符确定两个操作数之间的关系。它检查操作数是否大于,小于,等于,不等于等。根据关系,它被评估为true或false。

Operator Description Example
== 等于 5 == 3 is evaluated to false
!= 不等于 5 != 3 is evaluated to true
> 大于 5 > 3 is evaluated to true
< 小于 5 < 3 is evaluated to false
>= 大于等于 5 >= 5 is evaluated to true
<= 小于等于 5 <= 5 is evaluated to true
1
2
3
4
5
6
7
8
9
10
11
12
13
class RelationalOperator {
public static void main(String[] args) {

int number1 = 5, number2 = 6;

if (number1 > number2) {
System.out.println("number1 is greater than number2.");
}
else {
System.out.println("number2 is greater than number1.");
}
}
}

输出:

1
number2 is greater than number1.

instanceof 操作符

除了关系运算符外,还有一个类型比较运算符instanceof,它将对象与指定类型进行比较。例如,

1
2
3
4
5
6
7
8
9
10
11
class instanceofOperator {
public static void main(String[] args) {

String test = "asdf";
boolean result;

result = test instanceof String;
System.out.println("Is test an object of String? " + result);
}
}
// Is test an object of String? true

逻辑运算符

逻辑运算符|| (条件OR)和&&(条件AND)对布尔表达式进行运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class LogicalOperator {
public static void main(String[] args) {

int number1 = 1, number2 = 2, number3 = 9;
boolean result;

// At least one expression needs to be true for the result to be true
result = (number1 > number2) || (number3 > number1);

// result will be true because (number1 > number2) is true
System.out.println(result);

// All expression must be true from result to be true
result = (number1 > number2) && (number3 > number1);

// result will be false because (number3 > number1) is false
System.out.println(result);
}
}
// true
// false

三元运算符

1
variable = Expression ? expression1 : expression2
1
2
3
4
5
6
7
8
9
10
11
class ConditionalOperator {
public static void main(String[] args) {

int februaryDays = 29;
String result;

result = (februaryDays == 28) ? "Not a leap year" : "Leap year";
System.out.println(result);
}
}
// Leap year

位运算符

Operator Description
~ 按位补码
<< 左移
>> 右移
>>> 无符号右移
& 位与
^ 位异或
` `

Java 基础输入和输出

输出

Java标准输出方法有:

1
2
3
System.out.println() // 输出数据,自动换行
System.out.print() // 输出数据,不自动换行
System.out.printf() // 输出数据, Tt提供字符串格式设置

System是个 class,out是一个公用的静态字段,用来接受需要输出的数据.

1
2
3
4
5
6
7
8
9
10
11
12
13
class Output {
public static void main(String[] args) {

System.out.println("1. println ");
System.out.println("2. println ");

System.out.print("1. print ");
System.out.print("2. print");
}
}
// 1. println
// 2. println
// 1. print 2. print

输入

Java提供了多种输入方式给用户使用. 这里面介绍Scanner类.

使用Scanner需要引入Java包java.util.Scanner.

import java.util.Scanner

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.Scanner;

class Input {
public static void main(String[] args) {

Scanner input = new Scanner(System.in);

System.out.print("Enter an integer: ");
int number = input.nextInt();
System.out.println("You entered " + number);

// closing the scanner object
input.close();
}

/*
* Enter an integer: 23
* You entered 23
*/

支持获取 浮点、字符串类型值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.Scanner;

class Input {
public static void main(String[] args) {

Scanner input = new Scanner(System.in);

// Getting float input
System.out.print("Enter float: ");
float myFloat = input.nextFloat();
System.out.println("Float entered = " + myFloat);

// Getting double input
System.out.print("Enter double: ");
double myDouble = input.nextDouble();
System.out.println("Double entered = " + myDouble);

// Getting String input
System.out.print("Enter text: ");
String myString = input.next();
System.out.println("Text entered = " + myString);
}
}

输出:

1
2
3
4
5
6
7
8
/*
* Enter float: 2.343
* Float entered = 2.343
* Enter double: -23.4
* Double entered = -23.4
* Enter text: Hey!
* Text entered = Hey!
*/

Java表达式、语句、代码块

表达式

Java表达式有:变量、运算符、字面量和方法调用组成.

1
2
3
4
5
6
7
int score;
score = 90;
// score = 90 是一个表达式返回给 int

Double a = 2.2, b = 3.4, result;
result = a + b - 3.4;
// a+b-3.4 是一个表达式

语句

在Java中,每个一个语句是最小执行单元.

1
2
int score = 9*5;
// 在这里,我们有一个语句。完整执行包括将整数9和5相乘,然后将结果分配给变量score

表达式语句

我们可以通过;将表达式来将表达式转换为语句.

1
2
3
4
// 表达式
number = 10
// 语句
number = 10;

声明语句

Java中声明语句,是声明一个变量:

1
Double tax = 9.5;

Java代码块

1
2
3
4
5
6
7
8
9
10
11
class Main {
public static void main(String[] args) {

String band = "Beatles";

if (band == "Beatles") { // start of block
System.out.print("Hey ");
System.out.print("Jude!");
} // end of block
}
}

代码块是用大括号{}括起来的一组语句(零个或多个).

注释

Java提供两种注释方式: 单行和多行的.

1
2
3
4
5
6
7
8
9
10
/* This is an example of  multi-line comment.
* The program prints "Hello, World!" to the standard output.
*/
class Main {
public static void main(String[] args) {
{
// prints "Hello, World!"
System.out.println("Hello, World!");
}
}

数组

声明数组

1
2
3
4
5
6
7
8
String[] array = new String[100];

// dataType[] arrayName;
// 声明一个数组
double[] data;

// 给变量赋于内存
data = new Double[10];

上面声明了长度为100的字符串类型数组.

初始化数组

1
2
3
4
5
6
7
8
9
10
//declare and initialize and array
int[] age = {12, 4, 5, 2, 5};

// declare an array
int[] age = new int[5];

// initialize array
age[0] = 12;
age[1] = 4;
age[2] = 5;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Main {
public static void main(String[] args) {

// create an array
int[] age = {12, 4, 5, 2, 5};

// access each array elements
System.out.println("Accessing Elements of Array:");
System.out.println("First Element: " + age[0]);
System.out.println("Second Element: " + age[1]);
System.out.println("Third Element: " + age[2]);
System.out.println("Fourth Element: " + age[3]);
System.out.println("Fifth Element: " + age[4]);
}
}
// Accessing Elements of Array:
// First Element: 12
// Second Element: 4
// Third Element: 5
// Fourth Element: 2
// Fifth Element: 5

遍历数组

Java中常用 forfor-each遍历数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Main {
public static void main(String[] args) {

// create an array
int[] age = {12, 4, 5};

// loop through the array
// using for loop
System.out.println("Using for Loop:");
for(int i = 0; i < age.length; i++) {
System.out.println(age[i]);
}
}
}
// Using for Loop:
// 12
// 4
// 5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Main {
public static void main(String[] args) {

// create an array
int[] age = {12, 4, 5};

// loop through the array
// using for loop
System.out.println("Using for-each Loop:");
for(int a : age) {
System.out.println(a);
}
}
}
//Using for-each Loop:
// 12
// 4
// 5

声明多个数组

1
2
3
4
double[][] matrix = {
{1.2, 4.3, 4.0},
{4.1, -1.1}
};

数组复制

直接赋值

1
2
3
4
5
6
7
8
9
10
11
12
class Main {
public static void main(String[] args) {

int [] numbers = {1, 2, 3, 4, 5, 6};
int [] positiveNumbers = numbers; // copying arrays

for (int number: positiveNumbers) {
System.out.print(number + ", ");
}
}
}
// 1,2,3,4,5,6

直接用=赋值,当修改一个变量的数据时,是会影响到引用的变量. 不建议使用该方法复制数组

遍历数组复制数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.Arrays;

class Main {
public static void main(String[] args) {

int [] source = {1, 2, 3, 4, 5, 6};
int [] destination = new int[6];

// iterate and copy elements from source to destination
for (int i = 0; i < source.length; ++i) {
destination[i] = source[i];
}

// converting array to string
System.out.println(Arrays.toString(destination));
}
}
// [1, 2, 3, 4, 5, 6]

在上面的示例中,我们使用了for循环迭代源数组的每个元素。在每次迭代中,我们都将元素从源数组复制到目标数组。

使用arraycopy()方法

在Java中,System类包含一个名为arraycopy()的方法来复制数组。与上述两种方法相比,此方法是复制数组的更好方法。

arraycopy()方法允许您将源数组的指定部分复制到目标数组。

1
arraycopy(Object src, int srcPos,Object dest, int destPos, int length)
  • src 需要copy的数组
  • srcPos 复制开始数组下标
  • dest 目标数组,将从源中复制元素
  • destPos 目标数组中的起始位置(索引)
  • length 复制元素数量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// To use Arrays.toString() method
import java.util.Arrays;

class Main {
public static void main(String[] args) {
int[] n1 = {2, 3, 12, 4, 12, -2};

int[] n3 = new int[5];

// Creating n2 array of having length of n1 array
int[] n2 = new int[n1.length];

// copying entire n1 array to n2
System.arraycopy(n1, 0, n2, 0, n1.length);
System.out.println("n2 = " + Arrays.toString(n2));

// copying elements from index 2 on n1 array
// copying element to index 1 of n3 array
// 2 elements will be copied
System.arraycopy(n1, 2, n3, 1, 2);
System.out.println("n3 = " + Arrays.toString(n3));
}
}
// n2 = [2, 3, 12, 4, 12, -2]
// n3 = [0, 12, 4, 0, 0]

使用copyOfRange()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// To use toString() and copyOfRange() method
import java.util.Arrays;

class ArraysCopy {
public static void main(String[] args) {

int[] source = {2, 3, 12, 4, 12, -2};

// copying entire source array to destination
int[] destination1 = Arrays.copyOfRange(source, 0, source.length);
System.out.println("destination1 = " + Arrays.toString(destination1));

// copying from index 2 to 5 (5 is not included)
int[] destination2 = Arrays.copyOfRange(source, 2, 5);
System.out.println("destination2 = " + Arrays.toString(destination2));
}
}
// destination1 = [2, 3, 12, 4, 12, -2]
// destination2 = [12, 4, 12]

int[] destination1 = Arrays.copyOfRange(source,index,length)将源数组复制给目标 数组变量

复制二维数组

System.arraycopy()复制二维数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.util.Arrays;

class Main {
public static void main(String[] args) {

int[][] source = {
{1, 2, 3, 4},
{5, 6},
{0, 2, 42, -4, 5}
};

int[][] destination = new int[source.length][];

for (int i = 0; i < source.length; ++i) {

// allocating space for each row of destination array
destination[i] = new int[source[i].length];
System.arraycopy(source[i], 0, destination[i], 0, destination[i].length);
}

// displaying destination array
System.out.println(Arrays.deepToString(destination));
}
}
// [[1, 2, 3, 4], [5, 6], [0, 2, 42, -4, 5]]

流程控制

if-else

if-else常见使用方式有四种:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
if(condition) {
// codes in if block
}

if(condition) {
// codes in if block
}else{
// codes in else block
}

if(condition) {
// codes in if block
} else if(otherCondition) {
// codes in else if block
}

if(condition) {
// codes in if block
} else if(otherCondition) {
// codes in else if block
} else {
// codes in else block
}

conditionotherCondition是一个 boolean表达式. 它会返回truefalse.

  • condition结果如果是 true,则执行中括号内的内容.
  • condition结果如果是false,则跳过中括号的内容.

if-else支持互相嵌套.

switch

switch 语法是在一组可供执行的方案中,确定符合条件的方案进行执行.

语法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
switch (expression) {
case valb1:
// code to be executed if
// expression is equal to value1
break;

case value2:
// code to be executed if
// expression is equal to value2
break;

...
...

default:
// default statements
}

expression将执行一次,得到的结果将和 case中声明的 value进行匹配.如果匹配成功,则执行 case后面的代码块·.

如果case中未能匹配成功,则执行default中的代码块.

switch执行流程图:

代码demo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// Java Program to check the size
// using the switch...case statement

class Main {
public static void main(String[] args) {

int number = 44;
String size;

// switch statement to check size
switch (number) {

case 29:
size = "Small";
break;

case 42:
size = "Medium";
break;

// match the value of week
case 44:
size = "Large";
break;

case 48:
size = "Extra Large";
break;

default:
size = "Unknown";
break;

}
System.out.println("Size: " + size);
}
}

// Size: Large

Java for Loop

根据条件重复执行相同代码的语法在java中常见的有3种,for循环是其中之一.

1
2
3
for (initialExpression; testExpression; updateExpression) {
// body of the loop
}
  1. initialExpression - 初始化或声明变量,只执行一次.
  2. testExpression - 执行条件判断,返回值是 boolean类型,如果返回是true则执行 for循环中括号内的代码块.
  3. updateExpression - 更新initialExpression中声明的变量值.
  4. for循环中括号内的代码块执行完成后,则再执行testExpression直到其值返回false结束for循环.

for循环执行流程:

for循环例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Main {
public static void main(String[] args) {

int sum = 0;
int n = 1000;

// for loop
for (int i = 1; i <= n; ++i) {
// body inside for loop
sum += i; // sum = sum + i
}

System.out.println("Sum = " + sum);
}
}

Java for-each Loop

for-each是 另外一种遍历数组的方式.使用了for-each循环来逐一打印数字数组的每个元素.

语法:

1
2
3
for(dataType item : array) {
...
}
  • array - 数组或集合.
  • item - 数组或集合的每一项分配的变量.
  • dataType - 数组或集合的数据类型.

for-each代码例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Calculate the sum of all elements of an array

class Main {
public static void main(String[] args) {

// an array of numbers
int[] numbers = {3, 4, 5, -5, 0, 12};
int sum = 0;

// iterating through each element of the array
for (int number: numbers) {
sum += number;
}

System.out.println("Sum = " + sum);
}
}
// 输出 Sum = 19

Java while and do…while Loop

Java while loop

whileloop是执行重复代码直到判断条件为false

1
2
3
while (testExpression) {
// body of loop
}
  • textExpression - 执行条件,返回boolean值类型.如果结果是true则执行 while中括号内的代码块.如果结果是false则跳过 while循环.

while loop 执行流程:

代码例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// Java program to find the sum of positive numbers
import java.util.Scanner;

class Main {
public static void main(String[] args) {

int sum = 0;

// create an object of Scanner class
Scanner input = new Scanner(System.in);

// take integer input from the user
System.out.println("Enter a number");
int number = input.nextInt();

// while loop continues
// until entered number is positive
while (number >= 0) {
// add only positive numbers
sum += number;

System.out.println("Enter a number");
number = input.nextInt();
}

System.out.println("Sum = " + sum);
input.close();
}
}

// 输出
// Enter a number
// 25
// Enter a number
// 9
// Enter a number
// 5
// Enter a number
// -3
// Sum = 39

Java do…while loop

do...whilewhile很类似,但不同的是 do...while会先执行一次中括号内的代码块再进行条件判断.

语法:

1
2
3
do {
// body of loop
} while(textExpression)

代码例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Java Program to display numbers from 1 to 5

import java.util.Scanner;

// Program to find the sum of natural numbers from 1 to 100.

class Main {
public static void main(String[] args) {

int i = 1, n = 5;

// do...while loop from 1 to 5
do {
System.out.println(i);
i++;
} while(i <= n);
}
}

Java break Statement

Java中的break语句立即终止循环,程序的控制移至循环后的下一条语句。

例子:

代码例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.util.Scanner;

class UserInputSum {
public static void main(String[] args) {

Double number, sum = 0.0;

// create an object of Scanner
Scanner input = new Scanner(System.in);

while (true) {
System.out.print("Enter a number: ");

// takes double input from user
number = input.nextDouble();

// if number is negative the loop terminates
if (number < 0.0) {
break;
}

sum += number;
}
System.out.println("Sum = " + sum);
}
}
// 输出
// Enter a number: 3.2
// Enter a number: 5
// Enter a number: 2.3
// Enter a number: 0
// Enter a number: -4.5
// Sum = 10.5

常用使用场景:

Java continue Statement

continue用于在数组/集合中遍历跳过本次循环.

使用场景: