1. 基础语法-阿里云开发者社区

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¹⁵, 2¹⁵-1]
整型: int, 4byte, [-2³¹, 2³¹-1]
长整型: long, 8byte, [-2⁶³, 2⁶³-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允许在声明常量的时候不赋值初始值, 可以延迟赋值。但是赋值只能进行一次。

案例代码

/*
  常量：在程序执行的过程中，其值不可以发生改变的量
  常量分类：
    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 数据类型转换

一个变量声明完成后, 在内存中已经开辟好了空间, 这个变量的数据类型是不允许改变的。

这里说的数据类型转换, 指的是声明一个新的指定类型的变量, 将原来变量中的值拷贝到新的变量中。

数据类型转换可以分为两种:

自动类型转换

又叫做隐式转换, 一般是由取值范围小的数据类型, 向取值范围大的数据类型转换
转换过程不需要任何额外操作
转换后, 没有任何精度丢失情况

自动类型转换案例

/*
 * 
 * 隐式转换：
 *    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);
  }
}

强制类型转换

又叫做显式转换, 一般是由取值范围大的数据类型, 向取值范围小的数据类型转换
转换过程需要强制操作, 不能自动完成

转换后, 可能会出现精度丢失的情况
强制类型转换案例

/*
 * 强制转换：
 *    目标类型 变量名= (目标类型)(被转换的数据);
 * 
 *    虽然可以做强制转换，但是不建议。因为强制转换可能会有数据的丢失。
 */
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操作, 然后再取变量值

自减同自增

案例代码

/*
 * 算术运算符：
 *    +,-,*,/,%
 * 
 *    /和%的区别
 *      /：获取两个数据相除的商
 *      %：获取两个数据相除的余数
 * 
 * 注意：
 *    整数相除只能得到整数。要想得到小数，就必须有浮点数参与运算。
 */
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);
  }
}

赋值运算符

=: 将等号右边的值, 给左边的变量进行赋值

+=, -=, *=, /=, %=: 组合运算符, 对一个变量进行运算

案例代码

/*
 * 赋值运算符：
 *    基本的赋值运算符：=
 *    扩展的赋值运算符：+=,-=,...
 */
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);
  }
}

关系运算符

< >= <= == !=

案例代码

/*
 * 关系运算符：
 *    ==,!=,>,>=,<,<=
 *    关系运算符操作完毕的结果是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。

案例代码

/*
 * 逻辑运算符：
 * &&:有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

案例代码

/*
 * 三元运算符：
 *    关系表达式?表达式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 顺序结构

顺序结构案例

/*
 * 顺序结构：从上往下，依次执行
 */
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
}

案例代码

/*
 * 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");
    }
  }
}

进阶

if (condition1) {
    // 代码段1
}
else if (condition2) {
    // 代码段2
}
else {
    // 代码段3
}

案例代码

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

基础语法

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语句。

案例代码

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

while (condition) {
    // 循环体
}

逻辑: 每次循环线判断condition, 如果为true, 循环体执行, 然后再判断condition; 直到condition为false, 循环结束。

do {
    // 循环体
} while (condition);

逻辑: 先执行一次循环体, 然后再判断循环条件是否成立

案例代码

public class WhileDemo {
  public static void main(String[] args) {
    //while循环实现
    int x=1;
    while(x<=5) {
      System.out.println("HelloWorld");
      x++;
    }
  }
}

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 (循环起点; 循环条件; 循环步长) {
    循环体
}

先执行循环起点, 一般用与定义一个控制循环的变量, 或者给这个变量一个初始值
再判断循环条件是否成立, 如果循环条件成立, 执行循环体, 再执行循环步长, 然后重新判断循环条件
如果循环条件不成立, 循环结束

案例代码

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, 可以在循环体中控制跳出循环
循环步长: 可以在循环体中控制步长

关于大括号

如果循环体中只有一句语句, 循环体大括号可以省略; 但是出于规范, 一般我们也不省略

/*
 * 需求：求出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 循环的嵌套

/*
 * 需求：在控制台打印九九乘法表
    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();
    }
  }
}

1.9.3.4 跳出循环

break

break用在循环中, 表示跳出循环; 如果用在多层循环中, 只会跳出当前的一层循环；

/*
 * 如何使用：
 *    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语句, 直接终止指定循环的执行, 立即进入下次循环；

/*
 * 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.10.1 使用场景

数组是存储多个变量(元素)的东西(容器)

这多个变量的数据类型要一致

1.10.2 概念解析

数组是一个容器，是一个用来存储指定数据类型的多个元素的容器；

数组是一个定长容器，一旦实例化完成，长度不能修改；

1.10.3 数组定义

格式：

数据类型[] 数组名;
数据类型数组名[];

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。

//格式：数据类型[] 数组名 = new 数据类型[数组长度];
//数组长度其实就是数组中元素的个数。
//定义了一个int类型的数组，这个数组中可以存放3个int类型的值。
//数组元素的初始化值为0
int[] arr = new int[3];
for (int elem : arr) {
    System.out.println(elem);
}

静态初始化：

初始化时指定数组元素，即给出初始化值，由系统决定长度;

int[] number = new int[]{1, 2, 3, 5, 8};
int[] number = {1,2,3,5,8};

1.10.5 数组访问

元素访问：

通过下标来访问

数组中元素的下标是从0开始的

数组中元素的下标范围: [0, 数组.length - 1]

注意:

在访问数组中元素的时候, 注意下标的范围, 不要越界!!!

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

遍历数组:

使用循环遍历下标的方式

int[] array = {1, 2, 3};
for (int index = 0; index < array.length; index++) {
    System.out.println(array[index]);
}

使用增强for循环

int[] array = {1, 2, 3};
for (int ele : array) {
    System.out.println(ele);
}

1.10.6 数组的常见操作

//求一组数据的最大值、最小值、均值等
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 数组排序

选择排序

固定一个下标, 然后用这个下标对应的元素依次和后面每一个下标的元素进行比较

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

冒泡排序

依次比较数组中两个相邻的元素

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 并不直接支持二维数组，但是允许定义数组元素是一维数组的一维数组，以达到同样的效果。

二维数组的定义

type arrayName[][];    // 数据类型 数组名[][];
int arr[][];

或

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，并对数组中的元素进行了初始化。图 1 所示为该数组的内存结构。

图1 二维数组内存结构

使用第二种方式声明 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 数组的元素，并输出每一行每一列元素的值。代码如下：

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 循环语句表示以列进行循环，这样就实现了获取二维数组中每个元素的值的功能。

获取整行元素

除了获取单个元素和全部元素之外，还可以单独获取二维数组的某一行中所有元素的值，或者二维数组中某一列元素的值。获取指定行的元素时，需要将行数固定，然后只遍历该行中的全部列即可。

编写一个案例，接收用户在控制台输入的行数，然后获取该行中所有元素的值。代码如下：

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

获取整列元素

获取指定列的元素与获取指定行的元素相似，保持列不变，遍历每一行的该列即可。

编写一个案例，接收用户在控制台中输入的列数，然后获取二维数组中所有行中该列的值。代码如下：

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 方法的定义与调用

方法的定义语法

[访问权限修饰符] [其他的修饰符] 返回值类型 方法名([参数列表]) {
    // 方法体
}

修饰符目前记住 public static
返回值类型用于限定返回值的数据类型
方法名一个名字，为了方便我们调用方法
参数类型用于接收调用方法时传入的数据的类型
参数名用于接收调用方法时传入的数据的变量
方法体完成功能的代码
return 结束方法，把返回值带给调用者

方法的调用

方法中的代码存放在方法区, 默认不会执行, 如果需要执行的话, 需要将方法压栈. 体现出的形式就是调用方法
调用方法直接使用方法的名字即可
方法的执行顺序依照在栈中的顺序执行
方法调用的本质就是在方法调用处，使用传入的参数，插入执行方法的代码

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虚拟机会根据方法名及参数列表的不同来区分方法。
 */
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

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

1. 基础语法