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. 基础语法

1.1 JDK的安装与环境配置

1.2 idea环境配置

1.3 注释

1.4 标识符

1.5 数据类型

1.6 变量和常量

1.6.1变量

1.6.2 常量

1.7 数据类型转换

1.8 常用运算符

1.9 流程控制

1.9.1 顺序结构

1.9.2 分支结构

1.9.3 循环流程控制

1.9.3.1 while循环

1.9.3.2 for循环

1.9.3.3 循环的嵌套

1.9.3.4 跳出循环

1.10 数组

1.10.1 使用场景

1.10.2 概念解析

1.10.3 数组定义

1.10.4 数组初始化

1.10.5 数组访问

1.10.6 数组的常见操作

1.10.7 数组排序

1.10.8 二维数组

1.11 方法

1.11.1 方法的定义与调用

1.11.2 方法的参数与返回值

1.11.3 方法调用图解

1.11.4 方法的重载

1.11.5 方法的递归

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

1. 基础语法

1.1 JDK的安装与环境配置

1.2 idea环境配置

1.3 注释

1.4 标识符

1.5 数据类型

1.6 变量和常量

1.6.1变量

1.6.2 常量

1.7 数据类型转换

1.8 常用运算符

1.9 流程控制

1.9.1 顺序结构

1.9.2 分支结构

1.9.3 循环流程控制

1.9.3.1 while循环

1.9.3.2 for循环

1.9.3.3 循环的嵌套

1.9.3.4 跳出循环

1.10 数组

1.10.1 使用场景

1.10.2 概念解析

1.10.3 数组定义

1.10.4 数组初始化

1.10.5 数组访问

1.10.6 数组的常见操作

1.10.7 数组排序

1.10.8 二维数组

1.11 方法

1.11.1 方法的定义与调用

1.11.2 方法的参数与返回值

1.11.3 方法调用图解

1.11.4 方法的重载

1.11.5 方法的递归

热门文章

最新文章

相关课程

相关电子书

相关实验场景