Java基础语法

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中一般命名规范：
    包名：多单词组成时所有字母都小写：xuexi.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
    }
    

    逻辑: condition是一个boolean类型的变量, 或者一个boolean结果的表达式. 如果condition的值为true, 则代码段1执行, 否则, 代码段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
  }

逻辑: 先判断condition1, 如果condition1成立, 执行代码段1; 如果condition1不成立, 再判断condition2, 如果condition2成立, 执行代码段2, 否则执行代码段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);
    }

}