目录
**Java** 是一种面向对象的程序设计语言，可以使用这种语言编写程序，实现我们想要的一些功能。
- **两大特点：**
面向对象：类和对象的概念，语言的三大特性：封装、继承、多态；
跨平台：Java程序一次编译，在多个平台（Windows，Linux，Mac）下运行；
- **三大体系:**
J2SE: Java的标准版，其中提供了完整的Java核心API，用于标准的应用程序开发。
J2ME: Java的微型版，对Java API进行了精简，常用于移动端的开发。
J2EE: Java的企业版，用于企业级的应用服务开发，提供了一套企业级开的解决方案，用于B-S应用程序的开发。
### 1.1 JDK的安装与环境配置
Java程序的运行，需要先将.java源文件编译成.class字节码文件，然后由jvm虚拟机将这些字节码文件翻译成机器语言，然后执行相应的操作。
- **易混淆的概念**
JDK: Java Development Kit, Java开发框架，是提供给开发人员 ，开发Java程序需要用到的各种工具包，其中包含了JRE，同时提供了编译工具(javac.exe) 、打包工具(jar.exe)等内容。
JRE: Java Runtime Envrioment,提供了 Java运行时环境，其中包含了JVM。
JVM: Java Virtual Mechine, Java虚拟机, 能够运行Java程序。
- **JDK的安装**
- jdk下载安装
下载地址：https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html
- **环境变量的配置**
- 为什么要配置环境变量
因为我们需要使用bin目录下的javac和java指令来编译和运行程序, 而使用这两个程序的话, 就需要先用cd切到指定路径下才能执行, 并且参数需要写java文件所在的目录, 因此在编译和运行程序的时候非常不方便。因此需要将bin目录添加到环境变量, 这样我们就可以在任意的路径下使用javac和java指令,来对我们的程序进行编译和运行。
- 怎么配置环境变量
1，我的电脑 -> 右键 -> 属性 -> 高级系统设置 -> 环境变量
2，选择系统变量 -> Path -> 编辑
win10: 新建一个变量,将jdk下面的bin目录粘贴进去,并上移到最上方
win7/8: 将jdk下面的bin目录的路径粘贴到所有路径的最前方,然后添加一个路径分隔符;
- 怎么验证环境变量是否配置成功
新建一个DOS窗口, 输入指令 javac, 如果没有错误提示就是是成功
1,右击"我的电脑"，点击"属性"，选择"高级系统设置"；
2,选择"高级"选项卡，点击"环境变量"；
然后就会出现如下图所示的画面：
在"系统变量"中设置3项属性，JAVA_HOME，PATH，CLASSPATH(大小写无所谓),若已存在则点击"编辑"，不存在则点击"新建"。
变量设置参数如下：
变量名：JAVA_HOME
变量值：D:\tools\jdk1.8.0_77
变量名：CLASSPATH
变量值：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;
变量名：Path变量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
至此，系统环境变量配置成功。
### 1.2 idea环境配置
- idea下载，地址链接：https://www.jetbrains.com/idea/download/#section=windows
- 1、点击File -->Project Structure；
2、点击左侧标签页SDKs选项，再点击左上角“+”，选择JDK；
3、在弹出框选择JDK安装路径，点击OK即可配置成功。
下图可以看到JDK已经在IDEA中配置好了。
### 1.3 注释
注释是对代码的描述, 是开发者写给自己或者别人看的, 相当于我们记录的一些笔记, 或者备忘录。 注释部分的内容不会被编译, 因此没有语法上的要求。
注释可以分为三类:
- 单行注释: 以两个 // 开头, 后面的一行内容会被注释
- 多行注释: 以一个 /* 开头, 以一个 */ 结尾。中间所有的内容都会被注释
- 文档注释: 以 /** 开头, */ 结尾。注释内容可以被JDK提供的工具 javadoc 解析，生成相应的文档
/**
* 注释：用于解释说明程序的文字
*
* 分类：
* 单行
* 多行
*
* 作用：解释说明程序，提高程序的阅读性。
*/
//这是我的HelloWorld案例，class用于定义类。
public class HelloWorld {
/*
* 这是main方法
* main方法是程序的入口方法
* 所有程序的执行都是从main方法开始的
*/
public static void main(String[] args) {
//这是输出语句。
System.out.println("我要成为一名大数据工程师");
}
} ### 1.4 标识符
标识符就是由若干个字符组成的一个有序的序列，其中的字符可以有26个英文字母大小写，0-9 ，_或 $ 组成，
凡是自己可以起名字的地方都叫标识符。
Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
由若干个字符组成的一个有序的序列, 用来描述程序中的一个数据
- **注意**
- 只能由字母、数字、下划线和$符号组成
- 不能以数字作为开头
- 不能与关键字和保留字同名
- Java中严格区分大小写，长度无限制。
- 标识符不能包含空格。
关键字: 系统占用的, 已经被赋予了特殊含义的字符序列
保留字: 系统占用的, 暂时还没有特殊含义, 但是后续可能会用到的字符序列
- 定于类型的关键字：class,interface,byte,short,int,long,float,double,char,boolean,void;
- 定义数据类型值的关键字：true,false,null;
- 定义流程控制的关键字：if,else,switch,case,default,while,do,for,break,continue;
- 访问权限修饰符：private,protected,public;
- 定义类、函数、变量修饰符关键字：abstract,final,static,synchronized;
- 类、包相关的关键字：extends,implements，new,this,super,intanceof,package,import
- 异常处理相关关键字：try,catch,finally,throw,throws
- 其他：native,strictfp,transient,volatile,assert
- **命名规范**
- 望文知意: 应该可以从标识符的命名中看出想表述的数据含义
- 遵循驼峰命名法
- 大驼峰命名法: 所有的单词首字母都大写
- 小驼峰命名法: 首单词除外, 从第二个单词开始, 每个单词的首字母都大写
- Java中一般命名规范：
包名：多单词组成时所有字母都小写：kaikeba.com
类名、接口名：多单词组成时，所有单词的首字母大写：JavaClassName
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：varName
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
- **代码示例**
/*
* 标识符：就是用来给包，类，变量，方法等起名字的符号。
*/
public class IdentifierDemo {
public static void main(String[] args) {
//数据类型 变量名 = 初始化值;
int age = 20;
//正确写法
//int b2 = 30;
//不能以数字开头
//int 2b = 30;
//不能是关键字
//int class = 40;
}
}### 1.5 数据类型
在程序中, 我们需要操作各种各样的数据, 这些数据都有各自不同的类型。
Java中, 所有的数据可以分为两大类: **基本数据类型** 和 **引用数据类型**
引用数据类型, 又叫做引用类型。在后面课程中具体说明。
基本数据类型, 又叫做值类型, 在Java中有以下分类:
- 整型
- 就是整数, 按照占用空间大小, 分为四种
- 字节型: byte, 1byte, [-128, 127]
- 短整型: short, 2byte, [-2^15^, 2^15^-1]
- 整型: int, 4byte, [-2^31^, 2^31^-1]
- 长整型: long, 8byte, [-2^63^, 2^63^-1]
- 浮点型
- 就是小数, 按照占用空间大小, 分为两种
- 单精度浮点型: float, 4byte
- 双精度浮点型: double, 8byte
- 双精度浮点型可以比单精度浮点型精确更多的小数点后面的位数
- 布尔型
- 用来描述程序中不是对的就是错的, 不是真的就是假的数据
- boolean, 1byte
- 只有两个值: true / false
- 字符型
- 用来描述组成一个文本的最小单元
- char, 2byte
- 字符型的数据, 需要用单引号括起来, 单引号中只能有一个字符, 不能多也不能少
### 1.6 变量和常量
#### **1.6.1变量**
在程序执行的过程中, 其值可以在一定的范围内发生改变的量，代表内存中的一个存储区域，
该区域的数据可以在同一类型范围内不断变化，该区域有自己的名称（变量名）和类型（数据类型），使用变量名来访问这块区域的数据。
- 变量定义
- 数据类型 标识符;（声明变量）
- 数据类型 标识符 = 初始值;（声明并初始化）等价 于数据类型 标识符； 标识符 = 初始值
- 数据类型 标识符1, 标识符2, ...;
- 数据类型 标识符1 = 初始值, 标识符2, 标识符3 = 初始值, ...；
- **注意：**变量初始化后才能使用；Java中每个变量必须先声明，使用
- 作用：用于在内存中保存数据；
- 变量的作用域：一对{ }之间有效
- 案例代码
/*
* 变量的定义格式：
* 数据类型 变量名 = 初始化值;
*
* 基本数据类型：
* byte,short,int,long,float,double,char,boolean
*
* 注意事项：
* A:整数默认是int类型，定义long类型变量的时候，建议加L或l。
* B:浮点数默认是double类型，定义float类型变量的时候，建议加F或f。
*/
public class VariableDemo {
public static void main(String[] args) {
//byte类型的变量
byte b = 10;
System.out.println(10);
System.out.println(b);
//short类型的变量
short s = 100;
System.out.println(s);
//int类型的变量
int i = 1000;
System.out.println(i);
//long类型的变量
//long l = 10000;
//System.out.println(l);
long l = 10000000000L;
System.out.println(l);
//float类型的变量
float f = 12.34F;
System.out.println(f);
//double类型的变量
double d = 12.34;
System.out.println(d);
//char类型的变量
char ch = 'a';
System.out.println(ch);
//boolean类型的变量
boolean bb = true;
System.out.println(bb);
}
} //定义boolean类型的变量
boolean bb = false;
System.out.println(bb);
}- 注意事项
- 变量未赋值,不能直接使用；
- 变量只在它所属的范围内有效，变量在哪对大括号内，变量就属于哪对大括号；
- 一行上可以定义多个变量，但是不建议
#### **1.6.2 常量**
在程序运行的过程中, 其值不可以发生改变的量
- **常量举例：**
- 字符串常量 用双引号括起来的内容(HelloWorld”)
- 整数常量 所有整数(12,-23)
- 小数常量 所有小数(12.34)
- 字符常量 用单引号括起来的内容(‘a’,’A’,’0’)
- 布尔常量 较为特有，只有true和false
- 空常量 null(数组部分讲解)
- **常量定义**
- final 数据类型 标识符 = 初始值;
- final 数据类型 标识符; 标识符 = 初始值;
- Java允许在声明常量的时候不赋值初始值, 可以延迟赋值。但是赋值只能进行一次。
- **案例代码**
~~~java
/*
常量：在程序执行的过程中，其值不可以发生改变的量
常量分类：
A:字符串常量 "HelloWorld"
B:整数常量 12,-23
C:小数常量 12.34
D:字符常量 'a','0'
E:布尔常量 true,false
F:空常量 null
*/
public class ChangLiang {
public static void main(String[] args) {
//字符串常量
System.out.println("HelloWorld");
//整数常量
System.out.println(12);
System.out.println(-23);
//小数常量
System.out.println(12.34);
//字符常量
System.out.println('a');
System.out.println('0');
//布尔常量
System.out.println(true);
System.out.println(false);
}
}
~~~### 1.7 数据类型转换
一个变量声明完成后, 在内存中已经开辟好了空间, 这个变量的数据类型是不允许改变的。
这里说的数据类型转换, 指的是声明一个新的指定类型的变量, 将原来变量中的值拷贝到新的变量中。
数据类型转换可以分为两种:
- **自动类型转换**
- 又叫做**隐式转换**, 一般是由取值范围小的数据类型, 向取值范围大的数据类型转换
- 转换过程不需要任何额外操作
- 转换后, 没有任何精度丢失情况
- **自动类型转换案例**
~~~java
/*
*
* 隐式转换：
* byte,short,char -- int -- long -- float -- double
*
* boolean类型不参与这样的运算。
*/
public class ConversionDemo {
public static void main(String[] args) {
//定义两个int类型的变量
int a = 10;
int b = 20;
int c = a + b;
System.out.println(c);
System.out.println("-----------------");
//定义两个变量，一个int类型，一个byte类型
int aa = 10;
byte bb = 20;
System.out.println(aa+bb);
//下面这种写法报错了
//byte cc = aa+bb;
int cc = aa + bb;
System.out.println(cc);
}
}
~~~- **强制类型转换**
- 又叫做**显式转换**, 一般是由取值范围大的数据类型, 向取值范围小的数据类型转换
- 转换过程需要强制操作, 不能自动完成
- 转换后, 可能会出现精度丢失的情况
- **强制类型转换案例**
~~~java
/*
* 强制转换：
* 目标类型 变量名= (目标类型)(被转换的数据);
*
* 虽然可以做强制转换，但是不建议。因为强制转换可能会有数据的丢失。
*/
public class ConversionDemo2 {
public static void main(String[] args) {
//定义两个变量，一个int类型，一个byte类型
int a = 10;
byte b = 20;
int c = a + b;
System.out.println(c);
byte d = 30;
byte e = (byte)(a + b);
System.out.println(e);
}
}
~~~- **注意**
- byte, short, char 类型的数据在进行运算的时候, 会自动的转型为int类型浮点型转整型, 会舍去小数点后面所有的内容, 只保留整数部分
### 1.8 常用运算符
- **算术运算符**
用来做基础的算术计算, + - * / % ++ --
其中:
\+ \- \* % 和数学计算中没有区别
两个整型的数据进行除法, 结果还是整型, 会将计算的浮点结果强转成整型
自增运算符++, 用在变量前, 表示是前取变量值, 后对这个变量进行+1操作
自增运算符++, 用在变量后, 表示是先对这个变量进行+1操作, 然后再取变量值
自减同自增
- **案例代码**
~~~java
/*
* 算术运算符：
* +,-,*,/,%
*
* /和%的区别
* /：获取两个数据相除的商
* %：获取两个数据相除的余数
*
* 注意：
* 整数相除只能得到整数。要想得到小数，就必须有浮点数参与运算。
*/
public class OperatorDemo {
public static void main(String[] args) {
//定义两个int类型的变量
int a = 5;
int b = 3;
int c = b++; //C的值依然是3
int d = ++b; //d的值5
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/b);
System.out.println(a%b);
System.out.println(c);
System.out.println(d);
System.out.println("------------");
System.out.println(5/4);
System.out.println(5.0/4);
System.out.println(5/4.0);
}
}
~~~- **赋值运算符**
=: 将等号右边的值, 给左边的变量进行赋值
+=, -=, *=, /=, %=: 组合运算符, 对一个变量进行运算
- **案例代码**
~~~java
/*
* 赋值运算符：
* 基本的赋值运算符：=
* 扩展的赋值运算符：+=,-=,...
*/
public class OperatorDemo {
public static void main(String[] args) {
//定义变量
int a = 10; //把10赋值给int类型的变量a
System.out.println("a:"+a);
//扩展的赋值运算符：+=
//把运算符左边的数据和右边的数据进行运算，然后把结果赋值给左边
//a = a + 210;
a += 10;
System.out.println("a:"+a);
//short s = 1;
//s = s + 1;
//扩展的赋值运算符隐含了强制类型转换。
//a+=20
//等价于
//a =(a的数据类型)(a+20);
short s = 1;
s += 1;
System.out.println("s:"+s);
}
}
~~~- **关系运算符**
< >= <= == !=
- **案例代码**
~~~java
/*
* 关系运算符：
* ==,!=,>,>=,<,<=
* 关系运算符操作完毕的结果是boolean类型。
*
* 注意事项：
* 千万不要把==写成了=
*/
public class OperatorDemo {
public static void main(String[] args) {
//定义三个变量
int a = 10;
int b = 20;
int c = 10;
//==
System.out.println(a == b);
System.out.println(a == c);
System.out.println("------------");
//!=
System.out.println(a != b);
System.out.println(a != c);
System.out.println("------------");
//>
System.out.println(a > b);
System.out.println(a > c);
System.out.println("------------");
//>=
System.out.println(a >= b);
System.out.println(a >= c);
System.out.println("------------");
System.out.println(a == b);
System.out.println(a = b);//20,把b的值赋值给了a，并把a作为结果输出了
}
}
~~~- **逻辑运算符**
&& :
多个条件都true则true，否则false；
条件1 && 条件2 && 条件3
注意短路逻辑：如果前面的结果可以决定整体的运算结果, 后面的表达式不参与运算。
|| :
其中一个条件为true则true，否则为false
注意短路逻辑：如果前面的结果可以决定整体的运算结果, 后面的表达式不参与运算。
！：
非，非false则true，非true则false。
- **案例代码**
~~~java
/*
* 逻辑运算符：
* &&:有false则false
* ||:有true则true
* !:true则false,false则true
*/
public class OperatorDemo {
public static void main(String[] args) {
//定义变量
int a = 3;
int b = 4;
int c = 5;
//&&逻辑与
System.out.println((a>b) && (a>c)); //false && false
System.out.println((a<b) && (a>c)); //true && false
System.out.println((a>b) && (a<c)); //false && true
System.out.println((a<b) && (a<c)); //true && true
System.out.println("------------");
//||逻辑或
System.out.println((a>b) || (a>c)); //false || false
System.out.println((a<b) || (a>c)); //true || false
System.out.println((a>b) || (a<c)); //false || true
System.out.println((a<b) || (a<c)); //true || true
System.out.println("------------");
//!逻辑非
System.out.println((a>b));
System.out.println(!(a>b));
System.out.println(!!(a>b));
}
}
~~~- **三目运算符**
condition ? expression1 : expression2
condition是一个boolean类型的变量, 或者一个boolean结果的表达式. 如果condition为true, 最终整体的结果取expression1, 否则, 结果取expression2
- **案例代码**
~~~java
/*
* 三元运算符：
* 关系表达式?表达式1:表达式2;
*
* 执行流程：
* A:计算关系表达式的值，看结果是true还是false
* B:如果是true，表达式1就是结果
* 如果是false，表达式2就是结果
*/
public class OperatorDemo {
public static void main(String[] args) {
//定义两个变量
int a = 10;
int b = 20;
int c = (a>b)?a:b;
System.out.println("c:"+c);
}
}
~~~### 1.9 流程控制
程序在运行的时候, 对代码执行的先后顺序, 称作程序的执行结构. 在Java中, 程序的执行结构分为三种:
顺序结构: 代码从上往下逐行执行, 是程序执行的基本结构
分支结构: 代码执行到某一个节点遇到多个分支, 选择其中的一个分支执行, 其他的分支都不执行
循环结构: 某一个代码段需要重复的执行
程序默认采用的是顺序结构, 我们也可以通过一些语句来修改程序的执行结构, 这样的语句叫做**流程控制语句**, 按照修改的执行结构不同, 可以分为 **分支流程控制** 和 **循环流程控制**
#### 1.9.1 顺序结构
- 顺序结构案例
~~~java
/*
* 顺序结构：从上往下，依次执行
*/
public class OrderDemo {
public static void main(String[] args) {
System.out.println("开始");
System.out.println("语句A");
System.out.println("语句B");
System.out.println("语句C");
System.out.println("结束");
}
}
~~~#### 1.9.2 分支结构
- **if 语句**
- **基础语法**
~~~
if (condition) {
// 代码段1
}
或者
if (condition) {
// 代码段1
}
else {
// 代码段2
}
~~~
逻辑: condition是一个boolean类型的变量, 或者一个boolean结果的表达式. 如果condition的值为true, 则代码段1执行, 否则, 代码段2执行。
- **案例代码**
~~~java
/*
* if语句有三种格式。
*
* 格式1：
* if(关系表达式) {
* 语句体;
* }
*
* 执行流程：
* A:首先计算关系表达式的值，看是true还是false
* B:如果是true，就执行语句体
* C:如果是false，就不执行语句体
* if(关系表达式) {
* 语句体1;
* }else{
* 语句体2;
* }
*/
public class IfDemo {
public static void main(String[] args) {
//定义两个int类型的变量
int a = 10;
int b = 20;
//判断两个变量是否相等
if(a == b) {
System.out.println("a等于b");
}
//定义变量
int c = 10;
if(a == b){
System.out.println("a等于b");
}
else if(a == c) {
System.out.println("a等于c");
}
}
}
~~~
- **进阶**
~~~java
if (condition1) {
// 代码段1
}
else if (condition2) {
// 代码段2
}
else {
// 代码段3
}
~~~
逻辑: 先判断condition1, 如果condition1成立, 执行代码段1; 如果condition1不成立, 再判断condition2, 如果condition2成立, 执行代码段2, 否则执行代码段3
- **案例代码**
~~~java
public class IfDemo3 {
public static void main(String[] args) {
//根据给定的x的值，计算出y的值
int x = 5;
x = 0;
x = -5;
//定义变量y
int y;
if(x >= 3) {
y = 2*x+1;
}else if(x>=-1 && x<3) {
y = 2*x;
}else if(x<-1) {
y = 2*x-1;
}else {
y = 0;
System.out.println("不存在这样的x的值");
}
System.out.println("y:"+y);
}
}
~~~
**注意**
在if-else语句中, 如果某一个代码段中只有一句语句, 则大括号可以省略; 但是从语法的规范来说, 一般情况下, 我们是不省略的。
- **switch语句**
- **基础语法**
~~~java
switch(表达式) {
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
case 值3:
语句体3;
break;
...
default:
语句体n+1;
}
~~~
逻辑: variable是一个变量,取值类型可以是byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是String
如果表达式的值和某一个case后面的值相同了, 就会执行这个case后面的语句; 如果表达式的值没有和任意的一个case后面的值相同, 则执行default后面的语句
语句体部分可以是一条或多条语句
break表示中断，结束的意思，可以结束switch语句。
- **案例代码**
~~~java
import java.util.Scanner;
public class SwitchDemo {
public static void main(String[] args) {
// 创建键盘录入数据
Scanner sc = new Scanner(System.in);
// 给出提示
System.out.println("请输入一个整数(1-7)：");
int weekDay = sc.nextInt();
// 用switch语句实现判断
switch (weekDay) {
case 1:
System.out.println("星期一");
break;
case 2:
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;
default:
System.out.println("你输入的数据有误");
break;
}
}
}
~~~**注意**
在switch-case语句中有穿透性, 即: 如果variable的值和某一个value匹配了, 会执行从这个case开始, 一直到switch语句结束, 后面所有的代码, 且跳过后面的case匹配; 为了避免穿透, 可以使用关键字**break**来跳出switch语句。
#### 1.9.3 循环流程控制
##### 1.9.3.1 while循环
- **while语句**
~~~java
while (condition) {
// 循环体
}
~~~逻辑: 每次循环线判断condition, 如果为true, 循环体执行, 然后再判断condition; 直到condition为false, 循环结束。
~~~java
do {
// 循环体
} while (condition);
~~~逻辑: 先执行一次循环体, 然后再判断循环条件是否成立
**案例代码**
~~~java
public class WhileDemo {
public static void main(String[] args) {
//while循环实现
int x=1;
while(x<=5) {
System.out.println("HelloWorld");
x++;
}
}
}
~~~~~~java
public class DoWhileDemo {
public static void main(String[] args) {
int x=1;
do {
System.out.println("HelloWorld");
x++;
}while(x<=5);
}
}
~~~##### 1.9.3.2 for循环
- **基础语法**
~~~
for (循环起点; 循环条件; 循环步长) {
循环体
}
~~~先执行循环起点, 一般用与定义一个控制循环的变量, 或者给这个变量一个初始值
再判断循环条件是否成立, 如果循环条件成立, 执行循环体, 再执行循环步长, 然后重新判断循环条件
如果循环条件不成立, 循环结束
- **案例代码**
~~~java
public class ForDemo {
public static void main(String[] args) {
//需求：在控制台输出5次HelloWorld
//原始做法
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("----------");
//用for循环改进
for(int x=1; x<=5; x++) {
System.out.println("HelloWorld");
}
}
}
~~~- **注意事项**
关于语法省略
- for循环的小括号中由三部分组成, 这三个部分都可以省略:
- 循环起点: 变量的定义可以放在循环外
- 循环条件: 如果省略, 默认是true, 可以在循环体中控制跳出循环
- 循环步长: 可以在循环体中控制步长
关于大括号
- 如果循环体中只有一句语句, 循环体大括号可以省略; 但是出于规范, 一般我们也不省略
```java
/*
* 需求：求出1-100之间偶数和
*
* 分析：
* A:定义求和变量，初始化值是0
* B:获取1-100之间的偶数，用for循环实现
* C:拿到每一个获取的数据进行判断看是否是偶数
* 如果是偶数，就累加。
* D:输出求和变量
*/
public class ForTest3 {
public static void main(String[] args) {
//定义求和变量，初始化值是0
int sum = 0;
//获取1-100之间的偶数，用for循环实现
for(int x=1; x<=100; x++) {
//拿到每一个获取的数据进行判断看是否是偶数
if(x%2 == 0) {
//如果是偶数，就累加。
sum += x;
}
}
//输出求和变量
System.out.println("sum:"+sum);
}
}
```逻辑:
先执行循环起点, 一般用与定义一个控制循环的变量, 或者给这个变量一个初始值
再判断循环条件是否成立, 如果循环条件成立, 执行循环体, 再执行循环步长, 然后重新判断循环条件
如果循环条件不成立, 循环结束。
##### 1.9.3.3 循环的嵌套**
~~~java
/*
* 需求：在控制台打印九九乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
...
*/
public class ForForTest2 {
public static void main(String[] args) {
//先打印一个9行9列的星形(列是变化的)
for(int x=1; x<=9; x++) {
for(int y=1; y<=x; y++) {
System.out.print("*");
}
System.out.println();
}
System.out.println("------------");
/*
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
...
*/
for(int x=1; x<=9; x++) {
for(int y=1; y<=x; y++) {
//\t:转移字符，表示一个tab键的位置
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
}
~~~- break
**break**用在循环中, 表示跳出循环; 如果用在多层循环中, 只会跳出当前的一层循环；
~~~java
/*
* 如何使用：
* A:跳出单层循环
* B:跳出多层循环，用带标签的语句格式。
*/
public class BreakDemo {
public static void main(String[] args) {
//break可以用于结束当前的循环。
for(int x=1; x<=5; x++) {
if(x == 3) {
break;
}
System.out.println("HelloWorld");
}
System.out.println("-----------------------");
//如果是多层循环，break到底结束的是哪个循环呢?
//break结束的是离他最近的那个循环
//如果我要跳出外层循环，可不可以呢?
//可以。如何实现呢?
//带标签的语句：
//格式：标签名:语句
wc:for(int x=1; x<=3; x++) {
nc:for(int y=1; y<=4; y++) {
if(y == 2) {
break wc;
}
System.out.print("*");
}
System.out.println();
}
}
}
~~~- **continue**
**continue**用在循环中, 表示继续循环, 从continue开始, 后面所有的代码不执行, 直接进入下次循环；
**循环标签**
一般用在多层循环中, 可以给每一个循环都添加一个标签; 可以配合break语句, 直接结束指定的循环. 或者配合continue语句, 直接终止指定循环的执行, 立即进入下次循环；
~~~java
/*
* break和continue的区别：
* break:跳出整个循环
* continue:跳出这一次的操作，进入下一次的执行
*/
public class ContinueDemo {
public static void main(String[] args) {
for(int x=1; x<=5; x++) {
if(x == 3) {
continue;
}
System.out.println("HelloWorld"+x);
}
}
}
~~~#### 1.10.1 使用场景
数组是存储多个变量(元素)的东西(容器)
这多个变量的数据类型要一致
#### 1.10.2 概念解析
数组是一个容器，是一个用来存储指定数据类型的多个元素的容器；
数组是一个定长容器，一旦实例化完成，长度不能修改；
相关名词：
- 数组长度: 指的就是这个容器的容量, 表示这个数组中能存储多少个数据
- 元素: 指的就是数组中存储的数据
- 下标: 某一个元素在数组中的一个位置索引
- 遍历数组: 依次获取到数组中的每一个元素
#### 1.10.3 数组定义
格式：
- 数据类型[] 数组名;
- 数据类型 数组名[];
~~~java
A:int[] a; 定义一个int类型的数组，数组名是a
B:int a[]; 定义一个int类型的变量，变量名是a数组
~~~**注意：**Java中的数组必须先初始化,然后才能使用。
#### 1.10.4 数组初始化
**数组初始化：**
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
**动态初始化**：
初始化时只指定数组长度，由系统为数组分配初始值。
**注意**：
- 数组元素的类型是基本类型中的整数类型（byte、short、int 和 long），则数组元素的初始化值是 0。
- 数组元素的类型是基本类型中的浮点类型（float、double），则数组元素的初始化值是 0.0。
- 数组元素的类型是基本类型中的字符类型（char），则数组元素的初始化值是‘\u0000’。
- 数组元素的类型是基本类型中的布尔类型（boolean），则数组元素的初始化值是 false。
- 数组元素的类型是引用类型（类、接口和数组），则数组元素的初始化值是 null。
~~~java
//格式：数据类型[] 数组名 = new 数据类型[数组长度];
//数组长度其实就是数组中元素的个数。
//定义了一个int类型的数组，这个数组中可以存放3个int类型的值。
//数组元素的初始化值为0
int[] arr = new int[3];
for (int elem : arr) {
System.out.println(elem);
}
~~~
**静态初始化：**
初始化时指定数组元素，即给出初始化值，由系统决定长度;
~~~java
int[] number = new int[]{1, 2, 3, 5, 8};
int[] number = {1,2,3,5,8};
~~~#### 1.10.5 数组访问
**元素访问：**
通过下标来访问
数组中元素的下标是从0开始的
数组中元素的下标范围: [0, 数组.length - 1]
**注意:**
在访问数组中元素的时候, 注意下标的范围, 不要越界!!!
~~~java
public class ArrayDemo {
public static void main(String[] args) {
int[] arr = {10，20，30};
System.out.println("获取第一个元素："+arr[0]);
System.out.println("获取最后一个元素："+arr[arr.length-1]);
System.out.println("获取下标为3的元素："+arr[3]);
}
}
~~~**遍历数组:**
- 使用循环遍历下标的方式
```java
int[] array = {1, 2, 3};
for (int index = 0; index < array.length; index++) {
System.out.println(array[index]);
}
```- 使用增强for循环
```java
int[] array = {1, 2, 3};
for (int ele : array) {
System.out.println(ele);
}
```#### 1.10.6 数组的常见操作
~~~java
//求一组数据的最大值、最小值、均值等
public class Example{
public static void main(String[] args) {
int score[] = { 67, 89, 87, 69, 90, 100, 75, 90 }; // 初始化数组
int max = 0; // 定义变量保存到最大值
int min = 0; // 定义变量保存到最小值
int sum = 0;
float count = 0.0;
max = min = score[0]; // 把第1个元素的内容赋值给max和min
for (int x = 0; x < score.length; x++) { // 循环求岀最大和最小
if (score[x] > max) {
max = score[x];
}
if (score[x] < min) {
min = score[x];
}
sum = sum+score[x];
count = count+1;
}
System.out.println("最高成绩：" + max);
System.out.println("最低成绩：" + min);
System.out.println("平均成绩：" + sum/count);
}
}
~~~#### 1.10.7 数组排序
**选择排序**
固定一个下标, 然后用这个下标对应的元素依次和后面每一个下标的元素进行比较
```java
int[] array = {1, 3, 5, 7, 9, 0, 8, 6, 4, 2};
for (int index = 0; index < array.length - 1; index++) {
for (int compare = index + 1; compare < array.length; compare++) {
if (array[index] < array[compare]) {
int temp = array[index];
array[index] = array[compare];
array[compare] = temp;
}
}
}
```**冒泡排序**
依次比较数组中两个相邻的元素
```java
int[] array = {1, 3, 5, 7, 9, 0, 8, 6, 4, 2};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j] < array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
```#### 1.10.8 二维数组
**二维数组定义的内部逻辑**
二维数组被看作数组的数组，即二维数组为一个特殊的一维数组，其每个元素又是一个一维数组。Java 并不直接支持二维数组，但是允许定义数组元素是一维数组的一维数组，以达到同样的效果。
**二维数组的定义**
```java
type arrayName[][]; // 数据类型 数组名[][];
int arr[][];
```
或
```java
type[][] arrayName; // 数据类型[][] 数组名;
int[][] arr
```**初始化二维数组**
二维数组可以初始化，和一维数组一样，可以通过 3 种方式来指定元素的初始值。这 3 种方式的语法如下：
```
type[][] arrayName = new type[][]{值 1,值 2,值 3,…,值 n}; // 在定义时初始化
type[][] arrayName = new type[size1][size2]; // 给定空间，在赋值
type[][] arrayName = new type[size][]; // 数组第二维长度为空，可变化
```使用第一种方式声明 int 类型的二维数组，然后初始化该二维数组。代码如下：
```
int[][] temp = new int[][]{{1,2},{3,4}};
```上述代码创建了一个二行二列的二维数组 temp，并对数组中的元素进行了初始化。
二维数组内存结构
使用第二种方式声明 int 类型的二维数组，然后初始化该二维数组。代码如下：
```
int[][] temp = new int[2][2];
```
使用第三种方式声明 int 类型的二维数组，并且初始化数组。代码如下：
```
int[][] temp = new int[2][];
```
**获取单个元素**
在上部分使用的前 2 种方式创建并初始化了一个二行二列的 int 类型数组 temp。当需要获取二维数组中元素的值时，也可以使用下标来表示。语法如下：
```
arrayName[i-1][j-1];
```
其中，arrayName 表示数组名称，i 表示数组的行数，j 表示数组的列数。例如，要获取第二行第二列元素的值，应该使用 temp[1][1]来表示。这是由于数组的下标起始值为 0，因此行和列的下标需要减 1。
通过下标获取 class_score 数组中第二行第二列元素的值与第四行第一列元素的值。代码如下：
```
public static void main(String[] args) { double[][] class_score = {{10.0,99,99},{100,98,97},{100,100,99.5},{99.5,99,98.5}}; System.out.println("第二行第二列元素的值："+class_score[1][1]); System.out.println("第四行第一列元素的值："+class_score[3][0]);}
```
执行上述代码，输出结果如下：
```
第二行第二列元素的值：98.0
第四行第一列元素的值：99.5
```
**获取全部元素**
在一维数组中直接使用数组的 length 属性获取数组元素的个数。而在二维数组中，直接使用 length 属性获取的是数组的行数，在指定的索引后加上 length（如 array[0].length）表示的是该行拥有多少个元素，即列数。
如果要获取二维数组中的全部元素，最简单、最常用的办法就是使用 for 语句。在一维数组全部输出时，我们使用一层 for 循环，而二维数组要想全部输出，则使用嵌套 for 循环（2 层 for 循环）。
使用 for 循环语句遍历 double 类型的 class_score 数组的元素，并输出每一行每一列元素的值。代码如下：
```java
public static void main(String[] args)
{
double[][] class_score = { { 100, 99, 99 }, { 100, 98, 97 }, { 100, 100, 99.5 }, { 99.5, 99, 98.5 } };
for (int i = 0; i < class_score.length; i++)
{ // 遍历行
for (int j = 0; j < class_score[i].length; j++)
{
System.out.println("class_score[" + i + "][" + j + "]=" + class_score[i][j]);
}
}}
```上述代码使用嵌套 for 循环语句输出二维数组。在输出二维数组时，第一个 for 循环语句表示以行进行循环，第二个 for 循环语句表示以列进行循环，这样就实现了获取二维数组中每个元素的值的功能。
**获取整行元素**
除了获取单个元素和全部元素之外，还可以单独获取二维数组的某一行中所有元素的值，或者二维数组中某一列元素的值。获取指定行的元素时，需要将行数固定，然后只遍历该行中的全部列即可。
编写一个案例，接收用户在控制台输入的行数，然后获取该行中所有元素的值。代码如下：
~~~java
public static void main(String[] args) {
double[][] class_score = { { 100, 99, 99 }, { 100, 98, 97 }, { 100, 100, 99.5 }, { 99.5, 99, 98.5 } };
Scanner scan = new Scanner(System.in);
System.out.println("当前数组只有" + class_score.length + "行，您想查看第几行的元素？请输入："); int number = scan.nextInt();
for (int j = 0; j < class_score[number - 1].length; j++)
{
System.out.println("第" + number + "行的第[" + j + "]个元素的值是："
+ class_score[number - 1][j]); }}
~~~**获取整列元素**
获取指定列的元素与获取指定行的元素相似，保持列不变，遍历每一行的该列即可。
编写一个案例，接收用户在控制台中输入的列数，然后获取二维数组中所有行中该列的值。代码如下：
~~~java
public static void main(String[] args) {
double[][] class_score = { { 100, 99, 99 }, { 100, 98, 97 }, { 100, 100, 99.5 }, { 99.5, 99, 98.5 } };
Scanner scan = new Scanner(System.in);
System.out.println("您要获取哪一列的值？请输入：");
int number = scan.nextInt();
for (int i = 0; i < class_score.length; i++) {
System.out.println("第 " + (i + 1) + " 行的第[" + number + "]个元素的值是" + class_score[i][number]); }}
~~~### 1.11 方法
#### 1.11.1 方法的定义与调用
- 方法的定义语法
```java
[访问权限修饰符] [其他的修饰符] 返回值类型 方法名([参数列表]) {
// 方法体
}
```
- 修饰符 目前记住 public static
- 返回值类型 用于限定返回值的数据类型
- 方法名 一个名字，为了方便我们调用方法
- 参数类型 用于接收调用方法时传入的数据的类型
- 参数名 用于接收调用方法时传入的数据的变量
- 方法体 完成功能的代码
- return 结束方法，把返回值带给调用者
- 方法的调用
- 方法中的代码存放在方法区, 默认不会执行, 如果需要执行的话, 需要将方法压栈. 体现出的形式就是调用方法
- 调用方法直接使用方法的名字即可
- 方法的执行顺序依照在栈中的顺序执行
- 方法调用的本质就是在方法调用处，使用传入的参数，插入执行方法的代码
~~~java
public class MethodDemo {
public static void main(String[] args) {
//方法调用
int result = sum(10,20)
System.out.println("result:"+result);
}
/*
* 需求：求两个数据之和的案例
*/
public static int sum(int a,int b) {
int c = a + b;
return c;
}
}
~~~#### 1.11.2 方法的参数与返回值
- 参数
- 参数, 其实就是定义在参数列表中的变量, 我们可以在方法体中直接使用这个变量
- 有参数的方法, 在调用的时候必须给每一个参数赋值
- 返回值
- 返回值, 是一个程序运行的结构, 配合return关键字一起使用
- return关键字: 表示返回一个值, 并结束方法;
- return的返回值, 一定要和方法声明部分的返回值类型相匹配
- return也可以用在void返回值类型的方法中, 表示结束方法
- 如果方法体中有分支结构, 需要保证每一个分支上都有结果返回
#### 1.11.3 方法调用图解
#### 1.11.4 方法的重载
如果一个类中的不同方法, 满足以下两点要求, 他们之间的关系就是重载
- 方法名相同
- 参数不同(数量不同, 类型不同)
方法重载特点
- 与返回值类型无关，只看方法名和参数列表
- 在调用时，虚拟机通过参数列表的不同来区分同名方法
~~~java
/*
* 方法重载：在同一个类中，出现了方法名相同的情况。
*
* 方法重载的特点：
* 方法名相同，参数列表不同。方法重载与返回值无关。
*
* 参数列表不同：
* 参数的个数不同。
* 参数对应的数据类型不同。
*
* 注意事项：
* 在调用方法的时候，java虚拟机会根据方法名及参数列表的不同来区分方法。
*/
public class MethodDemo {
public static void main(String[] args) {
//定义两个变量
int a = 10;
int b = 20;
//求和
int result = sum(a,b);
System.out.println("result:"+result);
//定义变量
int c = 30;
//int result2 = sum2(a,b,c);
int result2 = sum(a,b,c);
System.out.println("result2:"+result2);
}
/*
public static int sum(int x,int y) {
return x + y;
}
*/
public static float sum(float a,float b) {
return a + b;
}
//求三个数据的和
/*
public static int sum2(int a,int b,int c) {
return a + b + c;
}
*/
public static int sum(int a,int b,int c) {
return a + b + c;
}
//求两个数据的和
public static int sum(int a,int b) {
/*
int c = a + b;
return c;
*/
return a + b;
}
}
~~~#### 1.11.5 方法的递归
递归, 就是方法调用自己, 或者方法之间的循环调用; 在使用递归的时候一定要找到递归的出口, 否则循环调用自己的话, 会出现异常 StackOverlowException
~~~java
public class Factor {
public static int getFactorial(int n) {
if (n >= 0) {
if (n == 0) {
System.out.println(n + "!=1");
return 1;
} else {
System.out.println(n);
int temp = n * getFactorial(n - 1);
System.out.println(n + "!=" + temp);
return temp;
}
}
return -1;
}
public static void main(String[] args) {
getFactorial(4);
}
}
~~~相关文章：
javaSE（2）面向对象
javaSE（3）常用类
javaSE（4）异常
javaSE（5）IO流
javaSE（6）多线程
javaSE（7）网络编程