郝明明的小文章

第4章 Java语言基础
Java作为一门高级的计算机编程语言，在实际工作中得到广泛使用，如：JavaWeb开发、Android应用开发、大数据开发等。本章主要涉及Java语言的基础编程知识，为大家进行其他知识的学习打下语言的基础。
4.1 认识Java
计算机在现在生活中已经及其普遍，如同人与人之间需要语言进行交流一样，人与计算机之间也要语言来进行沟通，以达到更好使用计算机的目的，这样的语言就称之为“计算机语言”。使用计算机语言与计算机进行沟通的过程就是通过编程来实现，故而计算机语言又被称为“编程语言”，今天我们认识众多编程语言之一：Java编程语言。
4.1.1 Java简介
Java语言是由SUN（Stanford University NetWork）公司的Patrick Naughton和Janes Gosling带领的工程小组出于设计一种小型的计算机语言的目的发展而来。目的是为了更好的在像有线电视转换盒这样的一类设备上进行编程，该类设备的特点CPU处理能力、内存等资源都比较有限，并且CPU产自多个生产厂家，这就需要语言屏蔽掉平台的差异。
在1991年，Java语言创建的伊始并不是这个名字，Janes Gosling把他命名为Oak（老橡树），后来发现改名字商标已被其他语言占用，才更名为Java。
任何一件事的成功总是波折的，第一个Java项目“FirstPerson”并未得到关注，以失败告终。随着万维网的快速发展，直达1994年，很多人都在使用名为“Mosaic”的web浏览器，这一年的中期，SUN公司人员意识到这个机会，于是Janes Gosling决定用Java开发一个新的Web浏览器。1995年5月23日的SunWorld上得到展示，引发狂热到今天。
1996年，SUN发布了Java的第1个版本，但是这个Java1.0并不适合在实际开发中使用。
1997年，发布Java 1.1。
1998年，JavaOne会议的头号新闻是即将发布Java 1.2版，在1998年12月Java1.2发布三天后，SUN公司将其更名为“Java 2标准版软件开发工具箱1.2版”，即：”标准版” J2SE。除了标准版之外，SUN还推出了两个其他版本：一个用于手机等嵌入式设备的“微型版”,即：J2ME；另一个是用于服务器端处理的“企业版”，即：J2EE。1.3（2000年）和1.4（2002年）版本对最初的Java 2做出了巨大改进。
Java版本号的变更，Java1.5是自Java1.1以来，做出重大变更的一个版本。在2004年JavaOne会议上将Java1.5的版本号升级为5.0，称为Java5.0。
版本6（没有后缀.0）于2006年发布。
2009年，SUN（Stanford University NetWork）公司被Oracle收购。
2011年，Oraclae发布了新版本Java 7。
2014年，发布Java 8。
最新的Java版本已经到了Java11。
Java个版本的名称以及发布时间如下表：

版本名称发行日期
JDK 1.0 Oak (橡树) 1996-01-23
JDK 1.1 none（无） 1997-02-19
JDK 1.1.4 Sparkler（宝石） 1997-09-12
JDK 1.1.5 Pumpkin（南瓜） 1997-12-13
JDK 1.1.6 Abigail（阿比盖尔–女子名） 1998-04-24
JDK 1.1.7 Brutus（布鲁图–古罗马政治家和将军） 1998-09-28
JDK 1.1.8 Chelsea（切尔西–城市名） 1999-04-08
J2SE 1.2 Playground（运动场） 1998-12-04
J2SE 1.2.1 none（无） 1999-03-30
J2SE 1.2.2 Cricket（蟋蟀） 1999-07-08
J2SE 1.3 Kestrel（美洲红隼） 2000-05-08
J2SE 1.3.1 Ladybird（瓢虫） 2001-05-17
J2SE 1.4.0 Merlin（灰背隼） 2002-02-13
J2SE 1.4.1 grasshopper（蚱蜢） 2002-09-16
J2SE 1.4.2 Mantis（螳螂） 2003-06-26
Java SE 5.0 (1.5.0) Tiger（老虎） 2004-09-30
Java SE 6.0 (1.6.0) Mustang（野马） 2006-04
Java SE 7.0 (1.7.0) Dolphin（海豚） 2011-07-28
Java SE 8.0 (1.8.0) Spider（蜘蛛） 2014-03-18
Java SE 9.0 none（无） 2017-09-21
Java SE 10.0 none（无） 2018-03-21
Java SE 11.0 none（无） 2018-09-25

在长久的发展过程中Java语言形成了不同的三个分支：
JavaSE
Java SE是Java Platform Standard Edition的简写，称为Java平台标准版，用于开发和部署桌面、服务器以及嵌入式设备和实时环境中的Java程序。JavaSE包括开发JavaWeb的基础类库，同时也是JavaME与JavaEE的基础版。
JavaME
JavaME是Java Platform Micro Edition的简称，称为Java微版，它为移动设备提供了基于Java环境开发和应用的平台。JavaME分为两个分支，一类面向小型移动设备CLDC(Connected Limmited Device Profile)，一类面向功能更强大的移动设备如智能手机、机顶盒设备CDC(Connected Device Profile CDC)。
JavaEE
JavaEE是简化企业解决方案的开发、部署、管理等相关负责问题的体系结构，JavaEE不仅巩固了标准版中的许多优点，例如：“一处编写、处处执行”的特性、方便存取数据库的JDBC操作API、能够在Internet应用中保护数据的安全模式，同事还提供了Java Servlet API、JSP、XML等技术的全面支持，最终目的是为了让企业开发者大幅度缩短投放市场时间。
JavaEE体系结构提供了满足高可用性、高可靠性以及扩展性的应用需求，通过提供统一的开发平台，JavaEE降低了开发多层应用的费用好复杂性，同时提供对现有程序的支持。
在本书的后续章节中，我们主要围绕着Java的基础部分，JavaSE进行讲解包含Java编程的语言基础、面向对象编程思想、Java的异常体系、Java的高级API。
4.1.2 Java平台的特点
Java的跨平台性
跨平台性指的是不受计算机的硬件设施以及操作系统的限制，可以在不同的硬件系统和操作系统之间进行无障碍的工作。
在C语言的编程过程中，我们依赖于当前的硬件及操作系统，比如：硬件（X86芯片、ARM芯片）、操作系统（Linux、Windows）存在很大差异，故而对于同一个功能，不同硬件和系统中对C语言的具体实现是不同的。也就是说C语言与基础环境之间是一个依赖或者绑定关系。
Java语言则不同，无论在何种硬件还是系统上，我们对于代码的编写都是一致的，不要考虑硬件及系统的差异，在一台Windows电脑上编写的程序完全可以拷贝到一台Linux电脑上不需要任何更改的去执行，而且这两个系统还可能基于的是完全不同的硬件（Intel芯片、ARM芯片）。Java语言对于硬件或系统是不存在依赖的，也就是它可以横跨多个平台来完成工作。
Java的面向对象编程
在日常生活、学习过程中，人对事物的认知都是存在一个整体性的。比如：这里有一个桌子，一般不会表述为这里有桌腿、桌面、抽屉。这个时候人的思维中天然的将桌腿、桌面、抽屉作为了一个整体考虑。这也正是Java语言考虑和解决问题的角度，将某一类事物看做一个整体，而不是分立的几个部分。在Java中使用Java类表示一类事物的整体，这种处理问题的角度称为“面向对象”，利用这种思想进行编程就是“面向对象编程”。
Java的简单性
事情的难易都是相对而言的，Java相对于C、C++这些语言来说去除了很多复杂的操作不好理解的理论、容易混淆的特性，例如：内存分配、头文件、指针、结构体、单元、运算符重载、虚拟基础类。使得Java代码编写更加简单、更严谨、更简洁。
Java的安全性
Java语言进行编译的时候，会对语法、语句、语义等进行检查，最终生成Java类的字节码文件。Java运行的时候，在类的字节码的加载过程中会对字节码文件进行校验，通过后才可以运行。如果Java类应用到网络中，还会有相关权限的设置，用来保证用户在访问过程中的安全性。
Java的多线程
线程是现代编程语言设计中必不可少的一个特性，Java也不例外，Java提供了Thread、Runnable用来完成多线程操作。代码实现简单，并能有效提高对于系统资源的利用程度以及程序的运行效率。
4.1.3 Java开发环境的搭建
Java开发环境指的是为Java程序编写和运行提供的基础工具，存在以下几个工具需要大家进行区分：
JVM
JVM是Java Virtual Machine的缩写，称为Java虚拟机，JVM是一种用于计算设备的规范，他是在硬件设备上虚拟出来的计算机，通过在计算机上模拟各种计算功能来实现。Java语言有一个非常重要的特性就是“跨平台性”。Java虚拟机正式实现这一特点的关键。一般的高级编程语言如果要在不同的平台上运行的话，至少需要编译成不同的目标代码。而引入Java虚拟机之后，Java语言在不同平台上运行不需要重新编译，可以做到一次编译，处处执行。Java语言使用Java虚拟机屏蔽了与具体平台相关的信息，使得Java语言编译后只生成在Java虚拟机上运行的目标代码（字节码），字节码可以不加修改的在各个平台的Java虚拟机上运行，Java虚拟机在解释执行Java字节码时，将其转换为不同平台的机器指令去执行，从而达到“一处编译，处处执行”。
JRE
JRE是Java Runtime Environment的缩写，称为Java运行环境，是运行过Java程序所必须的环境的集合。JRE自带的基础类库主要是JRE路径下的lib\rt.jar。JRE是由ClassLoader负责查找和加载程序引用到的类库，对于基础类库ClassLoader会自动到rt.jar中进行自动加载，对于其他的类库，ClassLoader在当前目录以及环境变量的CLASSPATH指定的路径中搜索。

JDK
JDK是Java Development Kits的缩写，称为Java语言开发工具包，JDK是整个Java的核心，包括了Java运行环境、Java基础类库、Java工具。最终流的JDK是由SUN公司开发的JDK，除此之外，还有很多公司和组织都开发了属于自己的JDK，如：IBM公司开发的JDK，BEA公司的Jrocket，还有GNU组织开发的JDK等等。这些自己开发的JDK都是为了满足自己的一些需求，提高某方面的性能。JDK是构建在Java平台之上的应用程序、Applet、组件的开发环境。它不提供具体的开发软件，主要提供的是Java开发必须的类库和Java语言规范。
JDK是最完正的一个工具包，其中包含了JRE、JVM，是进行Java程序开发的必备环境。JRE是Java运行的最基础环境，包括JVM以及类库，如果只是运行Java程序只需要JRE即可。
现在SUN公司已经被Oracle收购，我们需要到Oracle的官网上去下载相关的JDK，并搭建好Java开发的基础环境。
第一步：访问Oracle官网，www.oracle.com

第二步：在Menu中找到Developers下的Java

第三步：在打开的页面中找到Java Standard Edition，下的Download

第四步：进入下载界面

选择Java SE 8，点击其中的JDK DownLoad进行下载

第五步：同意用户协议，根据自己PC的系统版本，选择对应的软件进行下载，这里选择下载的是Windows x64。

第六步：下载完成之后在下载木下出现相应的可运行程序文件，jdk-8u211-windows-x64.exe
第七步：在Windows只需要双击jdk-8u211-windows-x64.exe即可运行该软件，并根据提示进行安装。
第八步：进行系统环境变量的配置操作，右击我的电脑，选择属性，在属性界面的左侧，选择高级系统设置

在系统环境变量中添加JAVA_HOME变量，值为JDK的安装路径截止到jdk1.8.0_211的文件夹。修改系统环境变量Path的值，在一开始添加“ %JAVA_HOME%\bin; ”与其他系统环境变量使用英文分号隔开，保存并退出。
第九步：进入Windows下命令行界面，可以在开始位置点击运行，输入cmd命令，回车，进入命令行界面。输入命令 java -version 用来查看当前JDK的版本，如果提示版本，表示JDK安装成功，就可以进行后续程序的编写了。这里安装的JDK版本如下：

这里对JDK的安装后的目录进行一下介绍

bin目录是Java开发工具的存放目录，我们后面需要使用的编译工具javac.exe、运行工具java.exe都在这个目录下。
include目录是Java环境需要使用的本地方法的编译文件存放位置。
jre目录就是Java的运行时环境。
lib目录是Java语言所需要的标准类库存放的位置。
src.zip是当前Java标准库的源代码文件。
4.14 第一个Java程序
作为一门编程语言，我首先尝试一下，怎么让他运行起来并看到运行的结果，对于Java程序来说我们编程的步骤主要为：
1、创建一个文件并命名，后缀名为.java
2、在创建的文件中别写需要的代码
3、使用javac命令对编写好的Java源代码文件进行编译，编译后会出现以.class为后缀名的文件，称为Java的字节码文件
4、在命令行中使用Java命令运行上面的编译出来的字节码文件，并在控制台上查看运行结果。
代码：
/**

当前Java文件用来演示Java程序的HelloWorld，让大家了解Java程序从编写到最后执行的整个过程。

*/
public class HelloWorld
{
//程序的入口，程序从这里开始
public static void main(String[] args)
{
//像屏幕中输出一个字符串HelloWorld
System.out.println( “HelloWorld” );
}
}
进入命令行终端运行代码看结果

代码的注释：
单行注释：在Java中使用符号“//”来表示单行注释，其作用范围仅限一行
多行注释：在Java中使用符号“/”开头，符号“/”结尾，来表示多行注释，其作用范围是两个符号括起来的部分
文档注释：在Java中使用符号“/**”开头，符号“*/”结尾，来表示文档注释，其作用范围是两个符号括起来的部分

注意事项：
1、执行 javac 源程序文件名.java 的时候，报错找不到文件。
a、文件真的不存在
b、文件名写错了
c、由于文件扩展名隐藏导致的文件识别错误，在文件的设置中将显示文件扩展名这一项勾选。 First.java.txt
2、编译时出现提示“非法字符” ，注意只要出现这个提示仅因为一个原因：中英文字符注意程序代码中一些常用的符号：括号：（）() 【】 [ ] { } { } “ ” “”
3、关键字写错class—Class System—system String—string main–mian
4、括号缺失，在Java中括号都是成对出现的{ } [ ] ( ) ，养成良好的书写习惯，出现括号时，先将完整括号写出来，再写括号中间内容。
5、类名格式有问题，Java中支持名称使用中文，但是不建议，必须使用全英文
6、main—mian main方法的名称写错了，在javac编译时时不报错的，在编译过程中仅仅检查语法错误，public static void mian(String[] args) 这可以作为Java程序的一个方法，但是不是main方法，编译时虽然通过，但是在程序执行过程中会报错，找不多程序入口。
main方法是程序的入口。
7、Java源程序发生变化时，需要重新编译执行。
8、程序的缩进与空格问题。（格式美观，关键字之间，具有含义的字符片段之间）
4.2变量和运算符
4.2.1 Java程序结构
作为一个编程语言，Java具有一定的程序结构，来起到规范开发的目的，在Java程序中主要的结构包含哪些信息。下面使用一个简单的程序讲述一下程序的基础结构。该程序的作用是从键盘录入一些信息。
结构一
/**
文档注释
当前代码用来表述Java程序的主体结构

/
/
多行注释
导入java.util包中的Scanner类，Scanner的作用是可以从键盘
录入需要的信息
*/
import java.util.Scanner;

//类的声明
public class ScannerTest
{
//程序入口
public static void main(String[] args)
{

 String recMsg = enterMsg();System.out.println( "从键盘录入的信息为：" + recMsg);
}//该方法完成从键盘录入一个字符串并返回
public static String enterMsg()
{Scanner sc = new Scanner(System.in);String msg = sc.next();return msg;
}

}

Java类是Java编程的基本单位，在一个Java程序中我们需要包含的部分有：
1、import java.util.Scanner 用来导入编程过程中需要的API
2、public class ScannerTest{ } 类的声明，所有的代码都在大括号中完成
3、public static void main(String[ ] args) { } 主方法，程序的入口
4、public static String enterMsg() { } 自定义方法，用户根据需要自己编写的方法

结构二

编写程序入口的类Test.java
/**
当前的类使用到了多个类共同完成，当前的Test类作为
整个程序的起始类
*/
public class Test
{

//程序的入口方法
public static void main(String[] args)
{//创建类的实例对象MyUtil mUtil = new MyUtil();//通过实例对象调用自定义的方法完成录入操作String result = mUtil.enterMsg();//将录入的结果输出到屏幕上System.out.println( "输入的内容为：" + result);
}

}

编写工具类MyUtil.java
import java.util.Scanner;
/**

当前这个类作为一个工具类，用于从键盘录入一个字符串

/
public class MyUtil
{
/*

 完成从键盘录入一个字符串，并将其作为返回值，返回给方法的调用者*/
public String enterMsg()
{//创建Scanner类的实例Scanner sc = new Scanner( System.in );//通过Scanner类的实例调用next(),该方法可以用来获取键盘录入的信息String msg = sc.next();//将录入的内容返回return msg;}

}

对于一个Java程序来说，根据其业务的需要，我们需要将不同的功能进行拆分，划分为不同的Java类，共同完成程序的操作。
1、Test.java类只作为程序的入口，程序从这里执行
2、MyUtil.java类中包含的是自定义的方法，完成的从键盘录入信息并返回的功能

结构三

public class Student {

//学号
private String studentId;
//姓名
private String stuName;
//年龄
private int stuAge;
//性别
private String stuSex;
//手机号
private String phone;
//地址
private String address;//无参构造方法
public Student() {super();
}//有参构造方法
public Student(String studentId, String stuName, int stuAge, String stuSex, String phone, String address) {super();this.studentId = studentId;this.stuName = stuName;this.stuAge = stuAge;this.stuSex = stuSex;this.phone = phone;this.address = address;
}//设置学号方法
public String getStudentId() {return studentId;
}
//获取学号方法
public void setStudentId(String studentId) {this.studentId = studentId;
}
public String getStuName() {return stuName;
}
public void setStuName(String stuName) {this.stuName = stuName;
}
public int getStuAge() {return stuAge;
}
public void setStuAge(int stuAge) {this.stuAge = stuAge;
}
public String getStuSex() {return stuSex;
}
public void setStuSex(String stuSex) {this.stuSex = stuSex;
}
public String getPhone() {return phone;
}
public void setPhone(String phone) {this.phone = phone;
}
public String getAddress() {return address;
}
public void setAddress(String address) {this.address = address;
}//该方法将Student的实例对象转变为字符串输出
@Override
public String toString() {return "Student [studentId=" + studentId + ", stuName=" + stuName + ", stuAge=" + stuAge + ", stuSex=" + stuSex+ ", phone=" + phone + ", address=" + address + "]";
}
public void study()
{System.out.println( "欢迎大家进行JavaSE的学习" );
}

}
在上面的代码中，我们编写一个Java类，用来表示学生这个事物的相关信息信息，并命名为Student.java，其中代表的是：
1、成员变量，用来表示事物的基本属性特征
2、构造方法，分为有参构造、无参构造，用于进行实例的创建
3、set、get的方法，用来给成员变量进行赋值
4、toString()方法主要是讲类的实例转变为字符串
5、study()方法，用来表示事物具有的基本功能作用
4.2.2标识符
在Java编程过程中，我们需要根据需要定义一些名字，如：包名、类名、方法名、变量名、常量名等，用来区别代码中的不同部分，这些符号称为标识符。
标识符的组成
Java中命名标识符主要主要包括26个英文字母大、小写、美元符（$）、下划线(_)，并且在命名时数字不可以作为名称的开头，不可以与Java提供的关键字重复。
标识符命名规则
在表示表示标识符的命名规则中，除了数字不可以开头、不可以与Java官方关键字重复之外，还有一个更重要的规则就是命名的名字要见名知意。名字要具有一定的意义，不要是毫无意义的字母组合，这样不方便其他人阅读代码。
除了命名的基础规则之外我们在命名Java标识符的时候可以使用一定命名方法，比如：驼峰命名法。
包名：对于Java中的包名，我们一般选择将字母全部小写，多层包之间使用“.”分割，比如：java.util、java.io、java.net、java.lang等。
类名：当类名为一个单词时，我们将这个单词的首字母大写，当类名由多个单词组成是我们将每个单词首字母多大写。比如：HelloWorld、PrintNum、MyUtil、Scanner等。此外还需要注意对于自定义的Java类的类名不要与Java官方提供的JavaAPI的类名重复。
方法名：当方法名由一个单词构成时，这个单词全部小写，当方法名由多个单词组成时，第一个单词小写，从第二个单词开始首字母大写。比如：main、doJob、getSum、nextInt等。
变量名：当变量名由一个单词构成时，这个单词全部小写，当变量名由多个单词组成时，第一个单词小写，从第二个单词开始首字母大写。比如：num、firstNum、result等。
常量名：当常量名是一个单词时，这个单词所有字母全部大写，如果常量名包含多个单词时，每个单词字母都要大写，并且每个单词之间使用下划线分割。比如：ERROR_TYPE_OF_NET、THE_CODE_OF_EXCEPTION等。
Java中的关键字
关键字是由Java语言提供的具有特定含义的单词，关键字全部为小写字母，下面将常用的关键字按照其不同的作用进行了划分。
1、用于定义数据类型的关键字
class interface byte short Int
long float double char boolean
void
2、用于表示数据类型值的关键字
true false null
3、用于定义流程控制的关键字
if else switch case default
while for do break continue
return
4、用于定义访问权限的关键字
private protected public
5、用于定义类、函数、变量修饰符的关键字
abstract final static synchronized
6、用于表示类与类之间关系的关键字
extends implements
7、用于定义建立实例、引用实例、判断实例的关键字
new this super instance of
8、用于异常处理的关键字
try catch finally throw throws
9、用于包操作的关键字
package import
10、其他修饰符关键字
native strictfp transient volatitle assert
goto const（常量修饰符）
注意在标识符的命名过程中不要与Java提供的这些关键字重复。
4.2.3变量
变量主要指的是在程序运行过程中其值可以根据不同情况发生变化、并且一直存储同一种数据类型的量。从内存角度来看，变量就是在内从中一块内存存储区域，为了标识这一块地址我们给他取一个名字也就是变量名，变量的值不断发生变化就是对应的内存区域的存储内容不断发生变化。
变量的定义
对于Java来说，需要按照一定的格式来进行变量的定义操作，才可以正常使用变量，变量的定义格式为：
数据类型变量名;
其中变量名作为标识符，需要符合标识符的命名规范。这里我们举几个简单的例子，表示记性变量的定义操作。
int num; 表示定义了一个int类型的变量，名称为num。
double myScore; 表示定义了一个double类型的变量，名称为myScore。
boolean result; 表示定义了一个Boolean类型的变量，名称为result。
变量的赋值
对于变量来说定义变量之后需要给变量进行合理的赋值，需要注意变量的数据类型和有效范文。变量赋值的格式为：
变量名 = 值;
在数学中“=”表示相等的含义，但在Java中其表示的作用是赋值，即将“=”右侧的值赋给左侧的变量。如果在java中想要表示相等的概念需要使用“==”。
在平时的编程过程中，变量的定义与变量的赋值操作可以一起完成，其基本格式为：
数据类型变量名 = 值;
int num = 10; 表示定义了一个整数类型变量，名称为num，并赋值为10。
double myScore = 89.5; 表示定义了一个小数类型变量，名称为myScore，并赋值为89.5。
变量的使用
在完成变量的定义以及赋值操作之后，在编程时我们会对变量进行使用，比如进行算术运算、比较运算、打印输出等。
变量的作用范围
在Java编程过程中，我们会使用大量的变量来在程序中表示实际问题中的数据，但是对于这些变量是有其作用范围的。根据其作用范围的不同我们可以分为全局变量与局部变量。全局变量隶属于Java类所有，其作用是在整个Java类中都有效，局部变量主要是在方法体中，其作用范围是在当前方法内部。
常量
相对于变量的不断变化来说，Java中存在一些不会变化的量称为常量，其实上面的变量的赋值操作int num = 10; 就是将常量10赋值给了变量num。对于常量我们可以进行一些分类：
1、整数常量，主要对应的就是整数的数字
2、实数常量，在Java中使用浮点型表示实数
3、字符常量：用单引号括起来的单个字符
4、字符串常量：用双引号括起来的多个字符
5、布尔常量：只有两个数值true、false
6、空常量：数值只有一个null
4.2.4 数据类型
在Java编程过程中，我们解决实际生活、工作中的问题时，我们需要将问题中与数据相关的信息表示到代码中，比如，现在有一个班级的考试成绩，想要计算出该班级学生各科成绩的平均值，我们需要做的处理算术运算外，我们还需要确定合适数据类型来表示这些数据。对于Java来说，根据解决问题的不同方向可以将Java的数据类型分为量大分支，基本数据类型、引用数据类型。
基本数据类型
Java的基本数据类型主要包括四大类，分别为整数类型、浮点数类型、字符类型、布尔类型。
整数类型
整数类型对应于数学中的整数，包括正数、负数、零，对于整数类型Java还进行了细致的划分，分别为byte类型、short类型、int类型、long类型。这四种类型都是整数类型，其区别在于各自占用的内存空间不同，能表示id整数范围不同。其各自占用内存大小以及范围大小如下表：
类型存储需求取值范围
int 4字节 -2147483648 ~~ +2147483647
short 2字节 -32768 ~~ +32767
long 8字节 -9223372036854775808 ~~ +9223372036854775807
byte 1字节 -128 ~~ +127

Java中的整数都是有符号的，存在正、负之分。对于Java的整数来说其十进制的数字是通过直接转换为二进制来表示到内存中的。其中各个整数类型的二进制的最高位表示符号位，其中0表示正、1表示负，其他二进制位作为有效位来存储整数的数字。我们以byte类型为例展示一下内存中整数是如何存储的。
byte占用8bit，其中最高位为符号位，其余7位用来存储数据，你们其可以存储的有效数据范围是：
0111 1111 八位二进制可以表示的最大正数 +127
0000 0000 八位二进制可以表示的最小整数 +0
1000 0000 八位二进制位可以表示的最大负数 -0
1111 1111 八位二进制位可以表示的最小负数 -127
从上的二进制中可以看到0000 0000 与 1000 0000 均表示数字0，在计算机中将1000 0000表示为-128，这也是为什么byte的范围为-128 ~~ +127的原因。其的整数类型同样按照这样的原理表示到内存中。
浮点数类型
浮点数主要是小数，在Java中浮点数类型主要分为两类单精度浮点型float与双精度浮点型double。对于浮点数类型来说其在内存中占用的空间大小以及表示的范围如下表：
类型存储需求取值范围
float 4字节大约±3.40282347E+38F（有效位数为6—7位）
double 8字节大约±1.79769313486231570E+308（有效位数15位）

对于浮点数类型来说，在内存中不是直接接十进制转换为二进制来表示的，其需要先将浮点数转换为科学计算法的形式，然后存储小数部分以及幂指数部分。

字符类型
字符类型char指的是单个字符，包括中文汉字、英文字母、各种符号等，其占用内存大小为2个字节。在Java中字符类型必须使用单引号括起来，比如：’A’、’中’、’!’等。
布尔类型
布尔类型boolean主要包括两个值真（true）、假（false），其主要用来具有比较性操作的语句的结果，比如两个整数变量a、b进行比较大小，其结果只可能存在两种情况，a>b为真或者为假。
基本数据类型转换
在进行数据的运算过程中，所有的数据类型必须统一才能运算，遇到多个数据不统一的情况下，需要进行数据类型转换。Java中的数据类型转换主要分为隐式转换与强制转换。
隐式转换
Java中的隐式转换主要发生在当参与运算的数据范围存在大小差异，一般会将byte、short、char这三个数据类型会首先转换成为int类型再进行计算以及float类型转换为double类型再进行计算。这个过程是由Java语言自动完成的不需要认为的控制操作。其规律就是在同一种数据类型中范围小的数据类型自动向范围大的数据类型转换从而达到与大的数据类型一致后再进行计算。
强制转换
对于强制类型转换来说不是Java语言自动完成的过程，是在编写代码时通过固定的语法格式来完成的，强制类型转换的格式：
数据类型A 变量a =（数据类型A）变量b；
强制转换一般发生在将大范围的数据类型的值，赋值给小范围的数据类型时，这个时候一般会出现损失精度的情况。比如：将一个double类型的值赋值给int类型的变量，这个时候数值只会保留整数部分，出现损失精度的情况。这个时候不建议直接使用强制类型转换，在编程中选择合适的数据类型更为重要。
在使用数据类型进行变量定义的时候，如果直接给定一个整数10，其默认是四种整数类型的int类型，也就是说平时用的整数数字在Java中默认都为int类型。这里解释一下当定义一个整数变量发生的事情，比如：byte num = 100;在Java中这一行代码会发生哪些操作呢？
1、首先由于整数都默认是int类型，需要先检查100是否在int的有效范围内
2、当100处于int有效范围内时，检查byte的有效范围是否可以容纳100，如果可以则进行赋值操作
3、如果给定的数值超出了byte的范围，如果强制进行赋值操作，会发生数据类型强制转换，此时会出现错误数据，比如：byte num = (byte)300;
4、这是还有一个情况，就是long类型，当定义一个变量为long类型时，如果给定的值超出了int范围，语句在检查时就会报错，所以当定义long类型变量时需要添加一个后缀，long num = 10000L;
相对于整数默认类型时int，浮点数的默认类型为double，代码中书写的小数比如2.35都是默认为double类型，这个时候如果定义float变量float num = 3.14，就会出现出现错误提示，原因是3.14为double类型，赋值给float会损失精度，但我们可以知道float完全有能力可以表示3.14，这时候在写代码需要注意需要加上后缀，float num = 3.15F; 当定义一个double类型变量时，我们也加上一个后缀，double num = 2.456D;。
引用数据类型
在Java中基本数据类型主要用来表示基础的数字、单个字符、true、false等数据，除此之外比如我们要完成一个关于学生的管理系统，涉及选课、考试、评分、课程安排等诸多功能，这个时候，里面的课表、试卷、学生、老师这些都是程序中需要使用到的数据，这些数据贯穿在整个程序的处理过程中，并且这些数据不能使用简单的数字、字符就可以表示出来，比如想要表示一个学生数据，基本要包括：学号、姓名、年龄、专业、联系方式、家庭住址、班级等诸多信息，这些信息组合在一起才能表示学生这一个数据。在Java中我们把向学生这种类似的数据的数据类型称为引用数据类型，使用Java类来表示。
在Java中String是我常用的引用数据类型，其表示字符串，还有数组也是引用数据类型，在Java的API中提供了大量的Java类，比如Scanner(具有键盘录入功能)、Math（数学运算相关的类）、Date（时间类）等，再有就是类似于学生、教师、班级等需要使用Java类来表示，这些Java类都是引用数据类型。
4.2.5 运算符
运算符指的是在编程过程中，用来完成具体的运算操作需要使用的符号，运算符将多个需要操作的变量连接在一起形成表达式，根据运算符具有的不同功能作用可以将其按照作用进行分组讨论。
算术运算符
算术运算符主要作用是完成数学运算操作，主要有：
加法运算符（+）、减法运算符（-）、乘法运算符（*）、除法运算符（/）、取余运算符（%）、自加运算符（++）、自减运算符（–），此外加法与减法还分别代表正、负
其中我们需要注意：对于取余运算符（%），其余数的符号是与左侧的变量的符号相同的，对于自加运算符（++）、自减运算符（–）其在变量的右侧，如：i++、i–，表示先使用该变量i，再完成加法或减法操作，在变量的左边，如：++i、–i，表示先进行自加或者自减运算后再使用变量i。我们使用代码展示一下运算符的使用，代码如下：
public class ArithmeticOperationTest
{
public static void main(String[] args)
{
//加法运算符
int a = 10;
int b = 20;
int c = a + b;
System.out.println( “a+b的和：” + c );

 //减法运算符int d = a-b;System.out.println( "a-b的差：" + d );//乘法运算符int e = a*b;System.out.println( "a*b的积：" + e );//除法运算符double f = a/b;System.out.println( "a/b的商：" + f );//取余运算符int num1 = 10;int num2 = 3;int num3 = num1%num2;System.out.println( "num1对num2取余为：" + num3 );int num4 = -10;int num5 = 3;int num6 = num4%num5;System.out.println( "num4对num5取余为：" + num6 );int num7 = 10;int num8 = -3;int num9 = num7%num8;System.out.println( "num7对num8取余为：" + num9 );//自增运算符int i = 3;System.out.println( "i == " + (i++) );System.out.println( "i == " + i );int j = 3;System.out.println( "i == " + (++j) );System.out.println( "i == " + j );//自减运算符int m = 3;System.out.println( "m == " + (m--) );System.out.println( "m == " + m );int n = 3;System.out.println( "n == " + (--n) );System.out.println( "n == " + n );}

}
代码的运行结果如图：

赋值运算符
当我们定义变量的时候我们需要给变量进行赋值，以及进行一些其他操作时，我们也需要使用到赋值操作，与赋值操作相关的运算符有：
赋值运算符（=），将符号右侧的常量值，变量的值或者运算式的值赋值给左侧变量
加法赋值（+=），符号左侧的变量与符号右侧的值相加再赋值给左侧变量
减法赋值（-=），符号左侧的变量与符号右侧的值相减再赋值给左侧变量
乘法赋值（*=），符号左侧的变量与符号右侧的值相乘再赋值给左侧变量
除法赋值（/=），符号左侧的变量与符号右侧的值相除再赋值给左侧变量
取余赋值（%=），符号左侧的变量对符号右侧的值取余数再赋值给左侧变量
我们使用代码演示一下各个运算符的使用，代码如下：
public class AssignmentTest
{
public static void main(String[] args)
{

 //赋值运算符int num1 = 100;System.out.println( "num1 == " + num1 );//加法赋值int num2 = 10;num2 = num2 + 3;System.out.println( "num2 == " + num2 );int num3 = 10;num3 += 3;System.out.println( "num3 == " + num3 );//减法赋值int num4 = 10;num4 = num4 - 3;System.out.println( "num4 == " + num4 );int num5 = 10;num5 -= 3;System.out.println( "num5 == " + num5 );//乘法赋值int num6 = 10;num6 = num6 * 3;System.out.println( "num6 == " + num6 );int num7 = 10;num7 *= 3;System.out.println( "num7 == " + num7 );//除法赋值int num8 = 10;num8 = num8 / 2;System.out.println( "num8 == " + num8 );int num9 = 10;num9 /= 2;System.out.println( "num9 == " + num9 );//取余赋值int num10 = 10;num10 = num10 % 3;System.out.println( "num10 == " + num10 );int num11 = 10;num11 %= 3;System.out.println( "num11 == " + num11 );}

}
代码运行结果如图：

比较运算符
当我们在编程过程中涉及到比较两个变量的操作时，我们需要使用比较运算符，常用的比较运算符有：
大于（>）、小于（<）、等于（==）、大于等于（>=）、小于等于（<=）、不等于（!=）
我们通过代码演示演示一下比较运算符的使用，代码如下：
public class CompareTest
{

public static void main(String[] args)
{int a = 10;int b = 20;//大于boolean result1 = a > b;System.out.println( "a > b : " + result1 );//小于boolean result2 = a < b;System.out.println( "a < b : " + result2 );//等于boolean result3 = a == b;System.out.println( "a == b : " + result3 );//大于等于boolean result4 = a >= b;System.out.println( "a >= b : " + result4 );//小于等于boolean result5 = a <= b;System.out.println( "a <= b : " + result5 );//不等于boolean result6 = a != b;System.out.println( "a != b : " + result6 );}

}
代码运行结果如图：

逻辑运算符
在编程中逻辑运算符主要用来判断多个逻辑语句共同作用时，其结果为何的操作，常用的逻辑运算符有：
逻辑与（&），运算符左侧与右侧的内容均为true时，结果才是true
逻辑或（|），运算符左侧与右侧的内容存在一个true，结果则为true
逻辑非（！），逻辑非表示取反，true取反为false，false取反为true
逻辑异或（^），运算符左侧与右侧的内容相同时为true
逻辑双与（&&）
逻辑双或（||）
我们使用代码演示逻辑运算符的使用，代码如下：
public class LogicTest
{

public static void main(String[] args)
{int a = 10;int b = 20;int c = 30;int d = 25;//逻辑与boolean result1 = (a>b) & (c>d);System.out.println( "(a>b) & (c>d) : " + result1 );//逻辑或boolean result2 = (a>b) | (c>d);System.out.println( "(a>b) | (c>d) : " + result2 );//逻辑非boolean result3 = !(a>b);System.out.println( "!(a>b) : " + result3 );//逻辑异或boolean result4 = (a>b) ^ (c>d);System.out.println( "(a>b) ^ (c>d) : " + result4 );//逻辑双与boolean result5 = (a>b) && (c>d);System.out.println( "(a>b) && (c>d) : " + result5 );//逻辑双或boolean result6 = (a>b) || (c>d);System.out.println( "(a>b) || (c>d) : " + result6 );}

}
代码运行结果如图：

对于逻辑与和逻辑双与都是并且的概念，只有在左右两侧均为true时，结果才会为true，但是当左侧已经确定为false时，右侧并不需要继续运算，这个时候，如果使用逻辑与左右两侧都会进行运算，如果使用逻辑双与则只运算左侧发现其为false，那么右侧运算将不会执行。
对于逻辑或和逻辑双或的不同与上面类似，当运算符的左侧为true时，整个表达式即为true，右侧部分不需要继续运算。逻辑双或可以在这种情况下节省运算步骤。
位运算符
计算机中数据是以二进制的形式表示在内存中的，我们可以直接使用运算符操作二进制，这些运算符称为位运算符，常用的位运算符有：
左移运算符（<<），二进制位向左侧移动，在右侧出现的空位补0，被移除的高位丢弃
右移运算符（>>），二进制位向右侧移动，但是Java都是有符号数，当最高位是0，右
移后空出的高位补充0，当最高位是1，右移后空出的高位补充1
无符号右移运算符（>>>），不考虑符号位，最高位无论是0或1，移动后空位都补0
与运算符（&），当运算符左右两侧均为二进制的1时，结果为1，否则为0
或运算符（|），当运算符左右两侧有一侧为二进制的1时，结果为1，否则为0
非运算符（~），当二进制位为1时，非操作之后为0，当二进制位为0时，非操作之后
为1
异或运算符（^），当运算符左右两侧均为二进制的1时，结果为1，否则为0
下面使用代码演示位运算符的基本用法，代码如下：
public class BitTest
{

public static void main(String[] args)
{int a = 1;//在内存中1的二进制//0000 0000 0000 0000 0000 0000 0000 0001int b = 2;//在内存中2的二进制//0000 0000 0000 0000 0000 0000 0000 0010//与System.out.println( "a&b == " + (a&b) );//或System.out.println( "a|b == " + (a|b) );//非System.out.println( "~a == " + (~a) );//异或System.out.println( "a^b == " + (a^b) );//左移动运算符a = a<<3;System.out.println( "a<<3 == " + a );//右移动运算符a = a>>3;System.out.println( "a>>3 == " + a );}

}
代码运行的结果如图：

条件运算符
条件运算符是根据不同条件执行不同部分的一种运算符，其基本格式为：
(判断条件)?代码1:代码2；当判断条件成立时，执行代码1，当判断条件不成立时，执行代码2，该运算符的结果取决于后面代码1或者代码2中执行的那个操作得到的结果，我们使用代码演示一下其使用，代码如下：
public class ConditionTest
{

public static void main(String[] args)
{int a = 10;int b = 20;int result = (a>b)?(a++):(b++);System.out.println( "result == " + result);System.out.println( "a == " + a );System.out.println( "b == " + b );}

}
代码执行结果如图：

拼接运算符
在Java中，“+”不仅仅具有加法运算的作用，还可以完成字符串的拼接操作，在上面的示例代码中我们已经多次使用“+”来完成字符的拼接操作。这里需要注意一个问题，当我们想要拼接的字符串中包含某些计算时，最好将这些计算式子用括号括起来，否则会出现错误结果。代码演示如下：
public class StrTest
{
public static void main(String[] args)
{
int a = 10;
int b = 20;

 System.out.println( "两者相加的和为：" + a+b );System.out.println( "两者相加的和为：" + (a+b) );}

}
代码运行结果如图：

可以看到上面的代码中，第一次输出时，由于没有将计算式子”a+b”使用括号括起来，a与b的值均被当做字符串的一部分表示出来，而不是进行了数学运算。
除了根据运算符具有的作用可以将运算符按照上面的分类进行区分外，我们还可以按照运算符可以操作的数据的个数来进行分类，其中有单元运算符，主要包括逻辑非、位操作的非，三元运算符主要就是条件运算符，其他的运算符基本为双元运算符。
运算符优先级
在进行运算的过程中，各个运算符存在一定的运算先后顺序，当一个计算式中包含多个运算符时，优先级高的会先执行，同一级别的运算符按照由左向右的顺序依次执行，在下面的表格中，我们将常用的运算符按照优先级由高到低的顺序陈列出来，以供参考，表格如下所示：
优先级描述运算符
1 括号 ()、[]
2 正负号 +、-
3 自增自减，非 ++、–、!
4 乘除，取余、/、%
5 加减 +、-
6 移位运算 <<、>>、>>>
7 大小关系 >、>=、<、<=
8 相等关系 ==、!=
9 按位与 &
10 按位异或 ^
11 按位或 |
12 逻辑与 &&
13 逻辑或 ||
14 条件运算 ?:
15 赋值运算 =、+=、-=、=、/=、%=
16 位赋值运算 &=、|=、<<=、>>=、>>>=
4.2.6 表达式
在Java开发过程中，我们需要根据具体的需求编写不同的程序代码，在进行代码编写的过程中需要通过一条条的语句来完成，这样具有表示一定含义的编程语句，称为表达式。表达式主要包含几个部分，表达式的结果部分，表达式的运算部分，一条语句通过Java中的运算符将不同的变量以及常量的数据连接在一起，并进行运算符相关的运算操作，从而得到需要的结果。根据使用的运算符的不同我们可以划分不同类型的表达式。
赋值表达式，主要指的是使用赋值运算符进行操作的代码语句，这样的语句整体被称为赋值表达式。比如：int a = 10 表示定义了一个变量名称为a，并将其赋值为常数10，通常被称为赋值表达式，int b = a 表示定义了一个变量名称为b，并将变量a的值获取出来赋值给变量b，同样也被称为赋值表达式。
算术表达式，主要是指使用算术运算符执行操作的程序语句，这样的语句被称为算术表达式。比如 int result = a + b 表示将两个变量a与b的值获取出来，完成加法操作，然后将求得的结果赋值给定义好的变量result，这样的语句被称为算术表达式，同样适用了其他算术运算符的语句也被称为算术表达式。
比较表达式，主要指的是通过比较运算符执行相关操作的语句，这样的语句被称为比较表达式，对于比较表达式来说，其结果都为boolean类型的值。比如：有这样的一条语句boolean result = 10 > 20 通过比较运算符来连接完成，其结果只可能存在两种情况，这样的语句称为比较表达式。
根据代码语句使用不同的运算符进行连接变量或者常量分别被称为对应的表达式，比如：逻辑表达式、位运算表达式、条件表达式等等。对于编程来说，正是通过一条条的表达式才使得程序具有了完成的含义，从而完成对应的问题解决，编程实现。
在Java编程过程中，表达式的书写可以根据需要结合不同的运算符来连接需要操作的数据来完成，但是表达式必须放置在Java类的声明的大括号内，或者是类中的方法的括号内，其他位置是不能随意放置的。
public class ScoreTest
{
public static void main(String[] args)
{
//赋值表达式
int score = 85;
//使用逻辑运算符连接的两个比较表达式
if( score<0 || score > 100 )
{
System.out.println( “这个成绩值：” + score + " 不合法" );
}
else
{
//比较表达式
if(score < 60)
{
System.out.println( “这个成绩值：” + score + " 不及格" );
}
else
{
//比较表达式
if(score < 80)
{
System.out.println( “这个成绩值：” + score + " 良好" );
}
else
{
if(score < 90)
{
System.out.println( “这个成绩值：” + score + " 优秀" );
}
else
{
System.out.println( “这个成绩值：” + score + " 极好" );
}
}
}
}

}
public class SumTest
{

public static void main(String[] args)
{//赋值表达式int sum = 0;//一下语句的三个部分分别对应//赋值表达式   比较表达式   算术表达式for(int i = 1 ; i <= 100 ; i++){//算术表达式sum = sum + i;}System.out.println( "1-100的和为：" + sum);}

}
4.3流程控制
编程使用对于工作生活中的问题使用计算机语言进行解决的，在各种编程语言中想要更好的表述程序的逻辑，离不开对于程序的运行的相关控制操作。这些控制操作与大家平时处理问题的思路是一致的，我们平时处理一件事主要有一下基础逻辑思路，顺序逻辑、选择逻辑、循环逻辑。平时处理问题的逻辑都是在三个基础逻辑的基础上进行复杂变化而已。顺序逻辑比较好理解，就是按照先后顺序处理即可，对于选择逻辑、循环逻辑，在编程语言中我们需要使用对应的语句格式进行完成。
4.3.1 条件语句
基础条件语句
对于条件语句也叫选择语句，有一个关键字if，表示如果的意思，面对某个问题的出现的结果，进行选择操作。基础的条件语句格式为：
if(判断条件)
{
当判断条件成立时执行这里的代码
}
else
{
当判断条件不成立时执行这里的语句
}
这里我们使用这个语句完成一个简单的比较操作，对于两个这个数进行比较，并输出较大的一个数。
/**
在当前代码中完成基础的条件语句操作
*/
public class ChoiceTest
{
public static void main(String[] args)
{
int num1 = 10;
int num2 = 20;

 // num1 > num2 使用比较运算符“>”进行的比较操作if(num1 > num2){System.out.println( "较大的数为：" + num1 );}else{System.out.println( "较大的数为：" + num2 );}
}

}
程序的运行结果如图：

只有if的条件语句
对于上面的条件语句来说，可以只有if的部分，没有else的部分，这样的格式是完全可以的，当进行一些选择性操作时，如果主要关心条件成立的情况，而对条件不成立的情况不需要操作时，可以只使用if部分，格式为：
if(判断条件)
{
当判断条件成立时执行这里的代码
}
条件语句的嵌套
当我们需要完成的操作涉及多个条件时，而且各个条件具有一定的层次关系，这个时候可以使用条件嵌套的格式来完成，基础格式：
if(判断条件)
{
if(判断条件)
{
当判断条件成立时执行这里的代码
}
else
{
当判断条件不成立时执行这里的语句
}
}
else
{
if(判断条件)
{
当判断条件成立时执行这里的代码
}
else
{
当判断条件不成立时执行这里的语句
}
}
当然这种格式的嵌套可以出现多层，根据具体处理的问题的条件层次而有所区分。
举一个例子，现在有一个学生成绩score，按照成绩的不同等级进行划分，判断该成绩的等级是哪一个，成绩的等级分别为低于60位不及格，60与80之间为良好，80与90之间为优秀，90以上为极好，成绩介于0到100之间，下面使用代码完成这个操作，判断某个成绩处于哪个等级水平。
/**
当前类完成的是关于成绩的等级区分操作

*/
public class ScoreTest
{
public static void main(String[] args)
{
//定义一个变量用来保存成绩值
int score = 85;

 if( score<0 || score > 100 ){System.out.println( "这个成绩值：" + score + " 不合法" );}else{if(score < 60){System.out.println( "这个成绩值：" + score + " 不及格" );}else{if(score < 80){System.out.println( "这个成绩值：" + score + " 良好" );}else{if(score < 90){System.out.println( "这个成绩值：" + score + " 优秀" );}else{System.out.println( "这个成绩值：" + score + " 极好" );}}}}}

}
对于上面的代码运行结果如下图

对于上面的逻辑操作可以看到对于具有多层条件关系的时候，if嵌套的层次会比较复杂，容易出现错误，这里我们提供一种格式，来减少嵌套的层次。
if(判断条件一)
{
条件一成立时这行这里的代码
}
else if(判断条件二)
{
条件二成立时这行这里的代码
}
else if(判断条件三)
{
条件三成立时这行这里的代码
}
else
{
上述条件都不成成立时这行这里的代码
}
对于这种结构来说，其中else if 可以存在一到多个，使用这种结构，我们重写编写一下关于成绩判断的程序代码，代码如下：
public class ScoreTest
{

public static void main(String[] args)
{//定义一个变量保存成绩值int score = 85;if(score < 0 || score > 100){System.out.println( "成绩值:" + score + " 不在合法范围内" );}else if(score >= 0 && score < 60){System.out.println( "成绩:" + score + " 不及格" );}else if(score >= 60 && score < 80){System.out.println( "成绩:" + score + " 良好" );}else if(score >= 80 && score < 90){System.out.println( "成绩:" + score + " 优秀" );}else{System.out.println( "成绩:" + score + " 极好" );}
}

}
代码运行的结果如下：

switch语句
对于多个条件的选择操作，我们除了上面的if语句之外，还有switch语句，也可以完成多种选择的选取操作，其基本格式为：
switch(变量名)
{
case 常量一:
当变量中的值与常量值一匹配时执行这里
break;
case 常量二:
当变量中的值与常量值二匹配时执行这里
break;
case 常量三:
当变量中的值与常量值三匹配时执行这里
break;
case 常量四:
当变量中的值与常量值四匹配时执行这里
break;
default:
当变量中的值与以上的所有常量值都不匹配时执行这里
break;
}
对于上面的格式中的case可以存在一到多个，根据具体的实际情况而定，下面使用一段代码来熟悉一下上的格式，这里完成一个选择题的A、B、C、D的选择操作，代码如下：
public class ChoiceWork
{

public static void main(String[] args)
{//定义一个变量存储某个选项值String choice = "A";switch(choice){case "A":System.out.println( "选择了A选项" );break;case "B":System.out.println( "选择了B选项" );break;case "C":System.out.println( "选择了C选项" );break;case "D":System.out.println( "选择了D选项" );break;default:System.out.println( "您的选项存在错误" );break;}
}

}
代码的运行结果如图：

注意在switch语句中的括号内的变量的类型主要为byte、short、int、char，在Java7之后引入了对应String类型的支持。下面我们总结一下switch语句的执行顺序以及注意事项。
switch后的表达式得到结果后，会直接奔向对应的case，并执行后面的代码，如果各个case都没有匹配，那么执行default，
注意：
1、缺少break，break可以省略吗？
当default位于所有的case之后的时候可以省略。
case中的break可以省略但是结果可能不对，建议不省略。
2、没有default
default可以省略，在十分确认该switch中出去其他的case以外没有任何其他情况时，可以省略，但是不建议省略。此处的default相当于else可以防止意外！
3、default一定在最后面吗？
在代码编写过程中，default的位置并不一定必须在所有的case分支之后，但是当default在某个case之前时，不能省略break，否则程序运行结果不正常。
4、switch遇到break或者执行到switch结尾后结束！

4.3.2 循环语句
在编程过程中如果涉及到循环的逻辑，我们需要使用循环语句来完成相关操作，在Java中提供了多种循环语句的形式。
for循环语句
在这个循环语句中for是其关键字，其基本格式为：
for(循环的初始条件; 循环的判断条件; 循环的增量)
{
循环体，当判断条件满足时，执行这里的代码
}
对于for循环来说，其执行的顺序是，先要执行循环的初始条件，再执行循环的判断条件，当判断条件满足时执行循环体，然后再执行循环的增量，重新执行判断条件，成立时执行循环体，依次往后执行，直到不满足判断条件。
下面通过for循环语句，完成一个求解1-100的和程序，代码如下：
public class SumTest
{

public static void main(String[] args)
{//定义一个变量用来存储求得的和int sum = 0;for(int i = 1 ; i <= 100 ; i++){//进行求和操作sum = sum + i;}System.out.println( "1-100的和为：" + sum);}

}
程序的运行结果如图：

借助于上1-100的求和程序，我们解析一下for的运行过程
初始条件 i的值判断条件循环体增量 i的值 sum的值
int i = 1 i = 1 i<=100满足 sum=sum+i i++ i=2 sum=1
i = 2 i<=100满足 sum=sum+i i++ i=3 sum=3
i = 3 i<=100满足 sum=sum+i i++ i=4 sum=6
i = 4 i<=100满足 sum=sum+i i++ i=5 sum=10
……
i =99 i<=100满足 sum=sum+i i++ i=100 sum=4950
i =100 i<=100满足 sum=sum+i i++ i=101 sum=5050
i =101 i<=100不满足
此时循环停止，最终sum值为5050，i的值为101，在这个过程中初始条件只执行一次。
while循环
以while为关键字的一种循环逻辑，其基础格式为：
循环初始条件；
While(循环判断条件)
{
循环体，判断条件满足时，执行的代码
循环增量
}
对于使用for循环可以完成的操作，while循环同样可以完成，现在我们使用while循环的格式完成上面求1-100和的程序，代码如下：
public class SumTest
{

public static void main(String[] args)
{//定义一个变量用来存储得到的和int sum = 0;//定义循环的初始条件int i = 0;while(i <= 100){sum += i;}System.out.println( "1-100的和为：" + sum );
}

}
代码的执行结果如图：

对于while循环代码执行的过程与for循环的执行过程是一样的，首先需要执行循环初始条件，并且只执行一次，然后进行循环条件的判断操作，当条件满足时，执行循环体里面的代码，直到判断条件不满足时，整个循环结束，将计算得到的结果输出。
do…while循环
其基础格式为
循环初始条件
do
{
需要执行的代码
循环增量
}while(循环判断条件);
对于do…while循环来说存在一个特殊情况，那就是在循环判断条件满足时与循环判断条件不满足时，其代码执行存在差异，下面我们用代码来比较一下两种情况的区别，我们使用do…while循环向，屏幕中输出五次字符串“HelloWorld”，代码如下：
public class PrintStr
{
public static void main(String[] args)
{

 //定义循环初始条件int i = 1;do{System.out.println( "HelloWorld" );i++;}while (i <= 5);
}

}
上面程序的运行结果如下图所示：

但是当我们的循环判断条件一开始就不满足时，会怎样呢？上面的代码循环初始条件为int i=1，满足判断条件i<=5，当我们将初始条件更改为int i = 6时，会是怎样的结果呢？
public class PrintStr
{
public static void main(String[] args)
{

 //定义循环初始条件//int i = 1;//将循环初始条件更改为6int i = 6;do{System.out.println( "HelloWorld" );i++;}while (i <= 5);
}

}
上面的代码运行结果如下图：

从上图的执行结果可以看到一个问题，当循环的初始条件不满足循环判断条件时，do…while循环执行了一次循环体中的代码。
do…while与while的对比
这里对do…while循环与while循环进行一个对比，在循环判断条件都满足时，二者是相同的没有什么区别，但是当循环的判断条件不满足时，前者要比后者多执行一些循环体的代码逻辑。
for与while的对比
现在有一个问题需要使用编程来解决，这里有一张纸张，其厚度为1mm，假设其可以无限折叠，问经过多少次折叠之后其厚度超过1m，对于这个程序来说，我们知道一个衡量标准就是厚度为1m，对于具体需要多少次我们是不知道的，对比一下for循环与while循环的话会发现，for循环的格式中的判断条件更适合于循环次数明确的操作，while循环在只知道循环终止条件，对循环次数不明确时更为适用。下面使用while循环完成上面的题目。代码如下：
public class FoldTest
{

public static void main(String[] args)
{//定义一个变量用来表示纸张的厚度为1mmint page = 1;//定义一个变量用来保存折叠的次数int count = 0;//当折叠后的纸张厚度小于1000mm时，继续执行循环while(page <= 1000){page = 2*page;count++;}System.out.println( "总计折叠了：" + count + "次" );System.out.println( "折叠后的纸张厚度为：" + page );
}

}
代码运行结果如下如：

我们再举一个例子，现在我们需要从键盘上录入多个数字，循环进行当录入的数字大于10的时候我们停止录入的操作，并将最后一次录入的数字输出到屏幕上，同样这里也是一个循环的过程，但是对于该循环来说具体录入多少次之后出现大于10的数字是不确定的，这个时候更加适合使用while循环进行操作，代码如下：
//从键盘录入数字的操作需要依赖java平台提供的API-Scanner
import java.util.Scanner;

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

 //定义一个变量用来存储从键盘录入的数字int num = 0;//创建Scanner类的实例Scanner sc = new Scanner(System.in);while(num <= 10){System.out.println( "请继续录入一个数字" );num = sc.nextInt();}System.out.println( "录入的大于10的数字为：" + num );}

}
代码运行的结果如图：

通过上面示例，我们可以看到，当循环次数不明确时，while循环更加适合用来完成相关的代码编写。
break关键字
break作为一个关键字，其主要作用于循环操作，当循环逻辑中出现break操作时，此循环会立即停止，不再执行，我们用代码演示它的作用，我们使用for循环循环地向屏幕输出1-5的数字，看一下在有break与没有break的区别。代码如下：
public class PrintNum
{
public static void main(String[] args)
{
for(int i = 1 ; i <= 5 ; i++)
{
System.out.println(i);
}
}
}
运行结果如图：

如果我们将代码修改一下，加上break会出现什么样的效果呢，修改后的代码如下：
public class PrintNum
{
public static void main(String[] args)
{
for(int i = 1 ; i <= 5 ; i++)
{
if(i == 3)
{
break;
}
System.out.println(i);
}
}
}
代码运行结果如图：

通过前后两个代码的对比，我们可以发现，当代码中出现break操作时，循环被强制停止了，在第二个代码中加入了一个条件语句，当i==3时，执行break。
continue关键字
continue同样具有结束循环的作用，但是与break可以结束整个循环不同，continue的作用是结束并跳过当前正在执行这一次循环，继续后面的循环操作。我们同样以上面向屏幕输出数字的例子来看一下continue的作用，代码如下：
public class PrintNum
{
public static void main(String[] args)
{
for(int i = 1 ; i <= 5 ; i++)
{
if(i == 3)
{
//break;
continue;
}
System.out.println(i);
}
}
}
代码运行结果如图：

从上面的代码的运行结果可以看到，当i==3的时候，循环跳过了这次操作，继续执行了后面的循环操作。
循环嵌套
循环嵌套的结构指的是，在一个循环的循环体部分包含另外一个循环，这种结构用于具有嵌套逻辑的问题的解决。比如，我们现在需要输出一个图形，这个图形由“”组成，并且要求每次只能输出一个“”，如果要完成如下图形的输出，代码怎么来写呢?

我们需要分析一下：
上面的图形，是一个3行7列的一个图形，想要将其输出到屏幕上，我们的过程是这样的
第一行：******* 换行
第二行：******* 换行
第三行：******* 换行
从上的一个过程中可以看到，对于多行的输出我们需要多次操作，是循环的，在一行内分为两个部分的操作，第一部分是输出7个“*”这也是一个循环的过程，并且在循环后还要换行。代码如下：
public class PrintRectangle
{

public static void main(String[] args)
{//外层循环用来控制行的输出for(int i = 1 ; i <= 3 ; i++){//使用循环控制输出7个*for(int j = 1 ; j <= 7 ; j++){//该语句的作用是只向屏幕输出一个"*"但不换行System.out.print("*");}//7个* 输出之后，进行换行System.out.println();}}

}
代码运行结果如图：

我们再用一个例子来感受一下，循环嵌套的逻辑结构，完成如下图形的输出

我们需要将上述的图形输出到屏幕上，我们想对其进行简单分析
第一行：输出4个空格输出1个* 换行
第二行：输出3个空格输出2个* 换行
第三行：输出2个空格输出3个* 换行
第四行：输出1个空格输出4个* 换行
第五行：输出0个空格输出5个* 换行
通过上面的过程解释，我们可以看到与矩形的输出类似，该图形的输出，也是一个嵌套的操作，多行的输出是一个循环的逻辑，在同一行内，先要循环输出空格，在循环输出*，再换行。代码如下：
public class PrintTriangle
{

public static void main(String[] args)
{//循环控制行的输出操作for(int i = 0 ; i < 5 ; i++){//循环控制输出空格for(int j = 4 ; j > i ; j--){System.out.print(" ");}//循环控制输出*for(int k = 0 ; k <= i ; k++){System.out.print("*");}System.out.println();}}

}
代码运行结果如图：

相对于前面的矩形的输出，当前这个三角形的输出，其逻辑稍微复杂了一些，在外层大循环中嵌套了两个并列的小循环。
循环嵌套中的break与continue
对于上面使用的break与continue两个Java关键字，当其出现在循环嵌套中的时候，那他们对循环的影响又是怎么样的呢，我们可以使用代码查看一下其效果，我们可以按照行与列的形式输出数字，每一行依次输出1-8的数字，输出三行，然后我们在循环中加入break与continue来看一下其效果是怎样的。代码如下：
public class PrintNum
{

public static void main(String[] args)
{//循环控制行数的输出操作for(int i = 1 ; i <= 3 ; i++){System.out.print( "第"+ i +"行： " );//在每一行中循环输出1-8个数字for(int j = 1 ; j <= 8 ; j++){System.out.print(j);}//完成一行的输出之后进行换行System.out.println();}
}

}
代码运行效果如图：

可以看到上面的代码完成了输出三行数字，并且每一行的数字都是1-8，下面我们再上面的代码中加入break，来看一下break关键字对于循环嵌套的影响。我们先在内部的循环中加入break，代码如下：
public class PrintNum
{

public static void main(String[] args)
{//循环控制行数的输出操作for(int i = 1 ; i <= 3 ; i++){System.out.print("第"+i+"行： ");//在每一行中循环输出1-8个数字for(int j = 1 ; j <= 8 ; j++){if(j == 3){break;}System.out.print(j);}//完成一行的输出之后进行换行System.out.println();}
}

}
代码执行效果如图：

我们再将break加入到外层循环中，看一下会发生什么，代码如下：
public class PrintNum
{

public static void main(String[] args)
{//循环控制行数的输出操作for(int i = 1 ; i <= 3 ; i++){if(i == 3){break;}System.out.print( "第"+ i +"行： " );//在每一行中循环输出1-8个数字for(int j = 1 ; j <= 8 ; j++){System.out.print(j);}//完成一行的输出之后进行换行System.out.println();}
}

}
代码运行效果如图：

通过上面的两个实验，我们可以得到总结，break具有结束整个循环的作用，但是其作用的范围只能是其所处于的那层循环中，不会对所有循环都产生影响。同样的方式我们可以看一下continue关键字对于循环嵌套的影响，当continue处于内层循环时，代码如下：
public class PrintNum
{

public static void main(String[] args)
{//循环控制行数的输出操作for(int i = 1 ; i <= 3 ; i++){System.out.print("第"+i+"行： ");//在每一行中循环输出1-8个数字for(int j = 1 ; j <= 8 ; j++){if(j == 2){continue;}System.out.print(j);}//完成一行的输出之后进行换行System.out.println();}
}

}
代码运行结果如图：

当continue处于外层循环时，代码如下：
public class PrintNum
{

public static void main(String[] args)
{//循环控制行数的输出操作for(int i = 1 ; i <= 3 ; i++){if(i == 2){continue;}System.out.print("第"+i+"行： ");//在每一行中循环输出1-8个数字for(int j = 1 ; j <= 8 ; j++){System.out.print(j);}//完成一行的输出之后进行换行System.out.println();}
}

}
代码运行效果如图：

循环语句与条件语句的结合
对于编程语言来说，循环语句与条件语句，同样可以结合使用，根据所要解决的问题不同，我们需要使用不同语句的组合来完成编程的基础逻辑。比如现在需要同时求出1-100中奇数和、偶数和这两个结果，那我们就需要使用循环语句与条件语句的配合来完成，代码如下：
public class SumJob
{
public static void main(String[] args)
{

 //定义一个变量用来存储奇数和int sum1 = 0;//定义一个变量用来存储偶数和int sum2 = 0;for(int i = 1 ; i <= 100 ; i++){//当被2整数时，为偶数if(i % 2 == 0){sum2 += i;}else{sum1 += i;}}System.out.println( "奇数和为：" + sum1 );System.out.println( "偶数和为：" + sum2 );
}

}
代码运行结果如图：

循环语句与条件语句是编程逻辑的基础，在实际编程过程中，我们需要根据具体的需求自由的选择语句的组合使用，这需要一定的练习和积累。
4.4数组
4.4.1 一维数组
在进行Java编程的过程中，我们可以将单个的数据存储到变量中，通过变量来完成代码运行过程中的载体，但是当需要同时处理多个变量时，之前的变量就不足以满足需求了，这个时候我们需要一个新的可以在程序运行中存储多个数据的工具，这个工具就是数组。数组可以理解为存储多个数据的一个集合体，其中的每个数据成为一个数组元素。
数组的定义
对于数组来说我们需要先进行定义，才可以使用它，定义一个数组的基本格式为：
数据类型[ ] 数组变量名 = new 数据类型[数组长度];
分别解释一下各个部分的作用：
数据类型指的是对于数组来说会存储多个数据，这些数据所属的数据类型，在同一个数组内只能存储同一类型的数据。
[ ]中括号作为数组的一个标志，可以说只要看到中括号([ ])，那就是一个数组，但是只有中括号是不足以表示数组的，需要前面的数据类型的配合，所以在上面的格式中，一开始的：“数据类型[ ]”是一个整体，不要将其分隔开，其表示的意思就是存储某种数据类型的数据的数组。
数组变量名，这里与前面的变量的定义格式相同，前面的变量定义格式为：数据类型变量名 = 值; 变量名是自定义的一个名称用来表示某个变量，这里的数组变量名也是同样的作用，表示自定义一个名称代表当前的数组。
new，这是一个Java的关键字，表示新创建一个数组并对其进行初始化。
数组长度表示对于当前数组可以存储的数据的个数，长度为整数个。
数组的其他定义方式
在Java中关于数组的定义方式除了new关键字之外，可以在定义数组的时候直接给数组赋值的方式来定义数组。基本格式为：数据类型[ ] 数组变量名 = {数值1,数值2,数值3……}，在这种格式中，数组的长度取决于大括号中的数据个数，根据大括号中数据的个数初始数组的长度，并按照从0号索引开始一次赋值各个数据。我们使用代码看一下上面不同的数组定义形式：
public class ArrayDemo
{
public static void main(String[] args)
{

 //方式一：int[] nums = new int[5];nums[0] = 21;nums[1] = 22;nums[2] = 23;nums[3] = 24;nums[4] = 25;for(int i = 0 ; i<5 ; i++){System.out.println( "数组元素为：" + nums[i] );}System.out.println();System.out.println("==================");System.out.println();//方式二：int[] nums1 = {11,12,13,14,15};for(int i = 0 ; i<5 ; i++){System.out.println( "数组元素为：" + nums1[i] );}}

}
代码运行结果如图

数组的索引与赋值
数组定义后，我们需要对其进行赋值操作，对于数组来说存在一个索引的概念，也就是对存储在数组中多个数据的一个编号，这个编号从0开始，称为索引，也就是说如果定义一个数组其长度为10的话，其索引方位是0-9。我们可以使用索引代表数组中的某个具体的元素。
比如，int nums = new int[10]; 表示定义一个存储int类型的数组，其名称为nums，长度为10，那么nums[0] 表示数组的第一个元素，也就是0号索引对应的数据。
数组的遍历
我们将数据存储到数组中，当我们需要将数组中的数据逐一获取出来时，这个逐一获取的过程称之为数组的遍历。对于数组的遍历操作我们可以借助其索引存在的变化规律使用for循环来完成，假设定义一个数组的长度为10，那么其索引的范围是0-9，正好可以与for循环中的初始条件、判断条件对应。我们使用代码演示一下数组的操作，代码如下：
public class ArrayTest
{
public static void main(String[] args)
{

 //定义一个存储int类型数据的数组，其长度为10int[] nums = new int[10];//对于数组中的元素进行依次赋值nums[0] = 80;nums[1] = 81;nums[2] = 82;nums[3] = 83;nums[4] = 84;nums[5] = 85;nums[6] = 86;nums[7] = 87;nums[8] = 88;nums[9] = 89;//使用for循环根据其索引的变化规律进行数组的遍历for(int i = 0 ; i < 10 ; i++){System.out.println( "第"+ (i+1) + "个元素为：" + nums[i] );}}

}
代码执行效果如图：

数组的初始值
在进行数据的定义时，完成定义操作，并未进行赋值的时候，数组中各个元素是存在默认值的，我们可以是用代码检验一下不同数据类型的数组的默认值是什么，代码如下：
public class ArrayTest
{
public static void main(String[] args)
{

 //定义一个存储byte类型的数组byte[] nums1 = new byte[3];//直接输出数组元素的值System.out.println( nums1[0] );System.out.println( nums1[1] );System.out.println( nums1[2] );System.out.println("=================");//定义一个存储short类型的数组short[] nums2 = new short[3];//直接输出数组元素的值System.out.println( nums2[0] );System.out.println( nums2[1] );System.out.println( nums2[2] );System.out.println("=================");//定义一个存储int类型的数组int[] nums3 = new int[3];//直接输出数组元素的值System.out.println( nums3[0] );System.out.println( nums3[1] );System.out.println( nums3[2] );System.out.println("=================");//定义一个存储short类型的数组long[] nums4 = new long[3];//直接输出数组元素的值System.out.println( nums4[0] );System.out.println( nums4[1] );System.out.println( nums4[2] );System.out.println("=================");//定义一个存储float类型的数组float[] nums5 = new float[3];//直接输出数组元素的值System.out.println( nums5[0] );System.out.println( nums5[1] );System.out.println( nums5[2] );System.out.println("=================");//定义一个存储double类型的数组double[] nums6 = new double[3];//直接输出数组元素的值System.out.println( nums6[0] );System.out.println( nums6[1] );System.out.println( nums6[2] );System.out.println("=================");//定义一个存储char类型的数组char[] nums7 = new char[3];//直接输出数组元素的值System.out.println( "数据是" + nums7[0] + "这些" );System.out.println( "数据是" + nums7[1] + "这些" );System.out.println( "数据是" + nums7[2] + "这些" );System.out.println("=================");//定义一个存储boolean类型的数组boolean[] nums8 = new boolean[3];//直接输出数组元素的值System.out.println( nums8[0] );System.out.println( nums8[1] );System.out.println( nums8[2] );}

}
代码运行结果如图：

通过上面的实验结果可以看到，对于整数类型来说，数组中元素的默认值都是0，对于浮点数类型来说，数组中元素的默认值都是0.0，对于字符类型来说，数组中元素的默认是是空格，对于布尔类型来说，数组中元素的默认值都是false。
数组的应用
在编程过程中，我们经常需要使用到数组进行操作，下面我们使用代码完成一个简单的成绩管理操作，其中对数组进行了使用。具体逻辑是我们从键盘上录入十个人的名字，再录入十个人的成绩，将成绩与名字一一对应输出，并完成所有学生成绩的求和操作，代码如下所示：
import java.util.Scanner;

public class ScoreTest
{

public static void main(String[] args)
{//定义一个变量表示录入信息的总个数int count = 10;//根据count的值定义一个相应长度的数组用来存储名字String[] names = new String[count];//使用Java的API，具有从键盘录入信息的功能Scanner nameSc = new Scanner( System.in );for(int i = 0 ; i < count ; i++){System.out.println("请录入第"+(i+1)+"个名字");//通过next()方法完成，从键盘录入字符串的操作String name = nameSc.next();//将录入的名字存入提前准备的数组中names[i] = name;}System.out.println("===============");//根据count值定义一个数组，用来存储录入的成绩值double[] scores = new double[count];//使用API，完成键盘录入成绩Scanner scoreSc = new Scanner(System.in);for(int i = 0 ; i < count ; i++){System.out.println( "请录入第" + (i+1) + "个成绩" );//通过nextDouble()方法完成录入一个小数double score = scoreSc.nextDouble();//将录入的成绩值，保存到数组中scores[i] = score;}System.out.println("===============");//进行姓名与成绩的匹配输出，默认第一个录入的名字与第一个录入的成绩对应for(int i = 0 ; i < count ; i++){System.out.println( "名字：" + names[i] + "--成绩为：" + scores[i] );}System.out.println("===============");//定义一个变量用来存储成绩的和double sum = 0.0D;for(int i = 0 ; i < count ; i++){sum = sum + scores[i];}System.out.println( "所有人成绩和为：" + sum );}

}
代码的运行结果如图：

4.4.2 多维数组
对于一维数组来说，主要表示的是一个数据的线性关系，也就是各个数据之间按照一定的顺序依次存储下来就可以了，如果我们需要表示具有更复杂情况的数据时，比如班级的人员座次表，这个时候就会发现，把所有的人员名字依次的存储到一个一维数组中的时候就失去了彼此的位置关系，从座次的特征上我们可以看到其实一个包含行以及列两个维度的概念，那么我们可以使用二维数组的方式来将数据存储下来。形象的理解的话，二维数组就是一个表格可以从行与列两个角度来看待数据的不同位置关系，以及存储操作。
二维数组的定义
数据类型[][] 数组变量名称 = new 数据类型[行数][列数];
分别解释一下各个部分的含义，
数据类型表示的就是数组中存储的数据对应的类型，在一个数组中只能存储同一类型的多个数据，两组中括号分别表示的是数组的两个维度，前面的中括号表示的是数组的行数，后面的括号表示的是数组中一行的列数，数组变量名称就是代表当前定义数组的变量，new表示的是创建操作，Java中对于引用数据来说需要通过new来完成创建以及初始化操作，行数以及列数，分别表示数组在行与列上的初始大小，整个数组可以存储的元素的个数是行数与列数的乘积。
二维数组的定义方式
除去直接使用new关键字来进行数组的定义之外，我们也可以不直接指定数组的行数与列数，而是根据赋值时具体的数据来进行自动定义。
格式为：
数据类型[][] 数组变量名 = {
{数值1, 数值1, 数值1…… },
{数值1, 数值1, 数值1…… },
{数值1, 数值1, 数值1…… }
……
};
可以将二维数组看作为每个元素都是一个一维数组的一维数组，通过赋值号右侧的数据直接进行数组的初始化。我们通过代码看一下，二维数组的不同定义方式
public class Test {

//程序的入口
public static void main(String[] args)
{//定义了一个数组，用来存储两行三列的数据，数据的类型为字符串String[][] names = new String[2][3]; names[0][0] = "张三";names[0][1] = "李四";names[0][2] = "王五";names[1][0] = "赵六";names[1][1] = "孙七";names[1][2] = "钱八";for( int i = 0 ; i < 2 ; i++ ){for( int j = 0 ; j < 3 ; j++ ){System.out.print( names[i][j]+"\t" );}System.out.println();}System.out.println();System.out.println("===================");System.out.println();//定义二维数组，根据赋值号右侧的数据进行初始化String[][] namename = {{"张三","李四","王五"},{"赵六","孙七","钱八"}};for( int i = 0 ; i < 2 ; i++ ){for( int j = 0 ; j < 3 ; j++ ){System.out.print( namename[i][j]+"\t" );}System.out.println();}
}

}
代码的运行结果如图：

数组的索引与赋值
对于二维数组来说，同样存在着索引的概念，但是只通过一个数值不能完全确定二维数组的某个数据，对于二维数组的索引需要从两个方面来进行表示，一个是行一个是列，并且对应的索引值都是从0开始的，到对应的行数以及列数分别减一结束。在二维数组中通过行索引与列索引来共同确定具体的某个元素，比如：names1表示的是行索引为1，列索引为2的那个元素，也就是第二行，第三列的那个元素。

二维数组的遍历操作
对于二维数组来说，我们需要从两个维度来考虑元素的获取，分别为行和列，在进行数组的操作过程中，需要使用到循环嵌套的逻辑才能将二维数组的各个元素获取出来。当然也可直接将所有的元素输出，达到遍历的目的。

public class Test {

//程序的入口
public static void main(String[] args)
{//定义了一个数组，用来存储两行三列的数据，数据的类型为字符串String[][] names = new String[2][3]; names[0][0] = "张三";names[0][1] = "李四";names[0][2] = "王五";names[1][0] = "赵六";names[1][1] = "孙七";names[1][2] = "钱八";//依次获取二维数组中各个位置的元素值System.out.println(names[0][0]);System.out.println(names[0][1]);System.out.println(names[0][2]);System.out.println(names[1][0]);System.out.println(names[1][1]);System.out.println(names[1][2]);System.out.println();System.out.println("===================");System.out.println();//嵌套循环的方式来获取各个索引对应的值//外层循环控制行索引的变化for( int i = 0 ; i < 2 ; i++ ){//内层循环控制列索引的变化for( int j = 0 ; j < 3 ; j++ ){System.out.print( names[i][j]+"\t" );}System.out.println();}}

}
代码的运行效果如图：

二维数组的应用
数学中的乘法口诀表大家应当很熟悉，想在有这样的一个需求，将乘法口诀表中的各个计算式作为字符串，存入到二维数组中，当指定某两个数相乘的运算时，直接从对应的二维数组中将计算式获取出来，并输出到屏幕上。代码如下
public class Test {

//程序的入口
public static void main(String[] args)
{//定义一个二维数组，并初始化其行与列分别为10，用来存储乘法表达式String[][] statements = new String[10][10];//表示乘法式子的前一个数for(int i = 1; i <= 9 ; i++){//表示乘法式子的后一个数for(int j = 1; j <= i ; j++){//通过字符串拼接得到计算式String statement = i+"*"+j+"="+(i*j)+"\t";System.out.print(statement);//将计算式存储到数组对应的索引位置statements[i][j] = statement;}System.out.println();}System.out.println();System.out.println("==========================");System.out.println();System.out.println( "5与3的乘法计算式："+statements[5][3] );System.out.println( "8与6的乘法计算式："+statements[8][6] );System.out.println( "9与7的乘法计算式："+statements[9][7] );}

}
代码的执行效果如图：

在多维数组中我们比较常用的主要是二维数组，主要可以用来很好的标识二维的数据信息，当然也可以存在三维、四维等更多维度的数据信息，同样可以定义更多维度的数组，依次按照一维数组到二维数组的演变即可。
4.5方法定义与调用
在Java编程过程中我们可以看到有一个程序入口的main方法，该方法的作用是作为程序的开始，我们一个Java类的代码运行从程序入口开始。当我们编写大量代码的时候，比如有些代码完成的是进行数学操作，比如求和、求平均、排序等，有些代码完成的操作是向屏幕中输出一些图形，这个时候就会出现很多代码混合在一起，不利于管理和查看，针对这种问题，我们可以使用自定义方法来进行解决。
4.5.1 方法定义
自定义方法格式
在Java中自定义方法作为一个独立功能个体，是将相关的一系列的操作代码集中在一起从而完成某项功能，其需要遵循的格式为：
修饰符返回值的数据类型方法名称(形式参数列表)
{
方法体代码
}
下面我们分别解释一下各个部分的作用：
修饰符，指的是Java官方规定对于方法的使用有一定限制作用的关键字，比如：public、private、protected、static等
返回值的数据类型，指的是当前的方法主体代码执行完成后，产生的结果是否需要返回到调用该方法的位置，如果不需要返回回去，这个选择void即可，如果需要返回回去，那么需要根据具体的返回什么数据，来确定其对应的数据类型，包括：整数类型(byte、short、int、long)、浮点数类型（float、double）、字符类型（char）、布尔类型（boolean）、数组类型等。
方法名称，是当前方法的一个代表，使我们自定义的一个标识符，符合标识符的命名规则，由26个英文字母大小写、数字0-9、美元符号$、下划线_，并且数字不能开头，不可以与Java提供的关键字重复、符合驼峰命名法，如果名称为一个单词全部小写，如果名称为多个单词，第一个单词小写，从第二个单词开始首字母大写，一定要见名知意。
形式参数列表，指的是进行方法体编写时，对于其中的代码存在的一些未知信息，比如当要定义一个方法用来求两个整数的和时，这个时候代码中是不确定这两个整数具体是什么的，需要在方法使用的时候传递过来，这个时候需要在形式参数上标识好对应的参数。形式参数列表可以是零到多个参数的组合，其格式可以表示为：
参数1，参数2，参数3，参数4 ……
数据类型1 变量名1，数据类型2 变量名2，数据类型3 变量名3 ……
方法体，指的就是根据不同的需求编写的代码
自定义方法事例
下面我们根据不同的需求来完成自定义方法：
需求一：
自定义一个方法，用来完成一个整数是否为素数的判断，素数指的是除去1与本身以外不具有其他因子的数字。代码学下：
public class PrimeNumberTest
{
//程序的入口
public static void main(String[] args)
{

 int num = 87;checkNum(num);}/**
需求：完成一个功能判断任意一个整数是否为素数分析：素数是指只有1与数字本身作为因子，而不存在其他因子的整数对于上述功能我们需要使用自定义方法来完成，那么根据自定义方法的基本格式，我们先确定其各个部分的内容修饰符  返回值的数据类型  方法名称(形式参数列表){方法体}修饰符：因为方法定义之后需要在main方法使用，这里选择public static返回值的数据类型：这里可以不需要返回值，直接将判断的结果输出到屏幕上方法名：checkNum形式参数列表：需要有一个参数，用来确定判断哪个数字方法体：根据素数的基本含义，我们可以稍微转化一下，不存在除了1与本身之外的其他因子，也就是除了1与本身之外其他数字都不可以整除*/public static void checkNum(int num)
{//这里对于0与负数不讨论素数的概念if(num <= 0){System.out.println( num + "不是素数" );return;}if(num == 1){System.out.println( num + "不是素数" );return;}//整数2是素数if(num == 2){System.out.println( num + "是素数" );return;}//除去上面的特殊数字之后，我们使用下面的逻辑进行判断for(int i = 2; i < num ; i++){//只要存在一次整除操作，那么该一定为素数if(num % i == 0){System.out.println( num + "不是素数" );break;}else{//当num一直不能被其他数字整除时则为素数if(i == num-1){System.out.println( num + "是素数" );}}}
}

}
代码运行结果如图：

需求二：
使用自定义方法完成求解任意两个整数n与m之间所有整数的和。代码如下：
public class SumTest
{
//程序入口
public static void main(String[] args)
{

 //定义两个变量分别表示需要求和的数据范围的两个边界int left = 10;int right = 20;int mySum = getSum(left,right);System.out.println( left + "--" + right + "之间的整数的和为：" + mySum );}/**需求：求解任意两个整数之间所有整数的和分析：求解两个数之间的所有整数的和，对于求和来说可以通过循环来完成此外需要确定好两个整数的边界，使用自定义方法我们需要遵循其基本格式修饰符    返回值的数据类型   方法名称(形式参数列表){方法体}修饰符：同样由于需要在main方法中使用该方法，修饰符为public static返回值的数据类型：我们可以将求得的和，返回给调用该方法的位置方法名称：getSum形式参数列表: 对于需要进行求和操作的两个数的边界，需要明确，参数存在两个int m, int n方法体：主要通过循环操作完成求和*/
public static int getSum(int m , int n)
{//定义一个变量用来存储求得的和int sum = 0;//将循环的初始条件设置为数字的左边界，判断条件就是到达右边界结束for(int i = m ; i <= n ; i++){sum = sum + i;}//将最终求得的和，进行返回return sum;
}

}
代码运行结果如图：

对于上面的两个需求，我们使用自定义方法来完成其功能达到了程序的目的，对于其中的返回值数据类型的存在与否我们需要进一步确定，对于上面的两个程序来说，我们既可以将结果返回回去，也可以直接进行屏幕输出。下面我们通过完成下面的这个需求，来再次讨论一下自定义方法使用。
需求三：
通过自定义方法来实现，从键盘录入多个人的名字、录入多个成绩，并将名字与成绩匹配输出到屏幕上，对所有人的成绩记性求和，求平均值。代码如下：
import java.util.Scanner;

public class ScoreListTest
{
/**

需求：从键盘上录入多人的姓名，录入多人的成绩，将姓名与成绩匹配输出求所有成绩的和，平均值分析：对于上面的需求来说，我们使用自定义方法来完成，需要进行功能的拆分，根据需要完成的步骤，我们将其拆分为如下几个自定义方法自定义方法一：录入多人姓名自定义方法二：录入多人成绩自定义方法三：姓名与成绩匹配输出自定义方法四：成绩求和自定义方法五：求平均成绩*/public static void main(String[] args)
{//定义一个变量，表示需要录入信息的总个数int count = 5;//录入多人名字String[] myNames = enterNames(count);//录入多人成绩double[] myScores = enterScores(count);//进行姓名与成绩匹配输出matchNameAndScore(myNames,myScores,count);//成绩求和double mySum = sumOfScore(myScores,count);//成绩求平均avgOfScore(mySum,count);}/**需求：通过自定义方法完成多人名字的录入分析：我们逐一确定一下自定义方法各个部分的内容是什么修饰符   返回值的数据类型   方法名称(形式参数列表){方法体}修饰符：由于该方法需要在main方法中使用，修饰符选择public static返回值的数据类型：此时的返回值是不能为void的，因为当前这个方法完成的功能是进行多个名字的录入，并且这些名字在后续的代码中需要继续使用，需要返回给main方法以方便其再次调用其他方法，这里根据需求选择返回值的数据类型为String[]，因为录入的多个名字都要返回方法名称：enterNames形式参数列表：具体录入多少人的名字是不确定，需要提供形式参数int count方法体：作为方法功能的主体，需要使用循环逻辑、数组操作、Scanner等*/
public static String[] enterNames(int count)
{//准备一个空的容器，用来保存多个名字，容器大小为形式参数指定的长度String[] names = new String[count];//通过Java的API-Scanner完成录入操作，需要先创建该类的实例Scanner nameSc = new Scanner(System.in);for(int i = 0 ; i < count ; i++){System.out.println( "请录入第" + (i+1) + "个人的名字" );//执行录入操作，得到一个字符串String name = nameSc.next();//将录入的名字保存到数组中names[i] = name;}//完成整个循环操作之后，将所有的名字返回return names;
}/**需求：通过自定义方法完成多人成绩录入分析：我们同样逐一确定一下自定义方法各个部分的具体内容修饰符：该方法会在main方法中直接使用，所以修饰符选择public static返回值的数据类型：当前方法完成录入成绩的操作之后，同样需要返回，在后续的代码操作中需要使用该方法的结果，返回值的数据类型确定为double[]方法名称：enterScores形式参数列表：对于需要录入的具体数量不确定，需要指定参数 int count方法体：涉及循环逻辑、Scanner、数组操作*/
public static double[] enterScores(int count)
{//定义一个数组用来存储录入的成绩，数组长度由形式参数指定double[] scores = new double[count];//创建Scanner的实例，用来进行键盘录入Scanner scoreSc = new Scanner(System.in);//循环逻辑进行多个成绩录入for(int i = 0 ; i < count ; i++){System.out.println( "请录入第" + (i+1) + "个人的成绩" );//从键盘录入一个成绩double score = scoreSc.nextDouble();//将录入的成绩存储到数组中scores[i] = score;}//将录入后的多个成绩进行返回return scores;
}/**需求：将录入的多个名字与成绩进行匹配输出分析：这里利用数组索引具有的特点，将代表名字与代表成绩的数组进行一一对应两个数组中索引相同的称为一条信息确定一下自定义方法的各个部分修饰符：public static返回值的数据类型：由于是将信息直接进行输出到屏幕上，不需要返回值，选择void方法名称：matchNameAndScore形式参数列表：这里是要将名字与成绩进行匹配，参数中需要指定这两个信息此外对于数组中存在的数据个数也是需要指定的*/
public static void matchNameAndScore(String[] names, double[] scores, int count)
{//使用循环将多个名字与成绩的信息输出for(int i = 0 ; i < count ; i++){System.out.println( "姓名：" + names[i] + "--成绩：" + scores[i] );}}/**需求：对所有的成绩进行求和分析：成绩保存在数组中，需要将所有的数组元素依次相加，得到总成绩和自定义方法的各个部分如下：修饰符：public static返回值的数据类型：对于成绩进行求和之后，还需要求平均成绩，需要返回，确定为double方法名称:sumOfScore形式参数列表：存储了所有成绩的数组，数组中元素的个数方法体：通过数组的遍历操作，将所有的值获取并进行加法运算*/
public static double sumOfScore(double[] scores, int count)
{//定义一个变量存储所有成绩的和double sum = 0.0D;//循环变量整个数组，逐个进行加法操作for(int i = 0 ; i < count ; i++){sum = sum + scores[i];}//将求得的成绩和进行返回return sum;
}/**需求：求解成绩的平均值分析：在求得的和的基础上进行平均值的求解操作自定义方法各个部分修饰符：public static返回值的数据类型：这一步操作是所有执行程序的最后，可以直接输出平均值方法名称：avgOfScore形式参数列表：成绩的和，总人数*/
public static void avgOfScore(double sum, int count)
{double avg = sum/count;System.out.println( "平均成绩为：" + avg );
}

}
代码运行结果如图：

从上面的这些事例中我们可以看到，对于自定义方法来说，我们需要根据不同的需求进行具体的分析与确定，从而更好的完成自定方法的编写与使用。
自定义方法作用
在Java编程过程中，自定义方法可以将不同的逻辑操作进行合理划分，达到代码的有效管理，同时减少相同功能需要多次实现时的复用性问题。使用自定义方法完成的功能可以在需要的时候通过调用这个方法来直接完成这个功能的使用。下一节我们讲解方法调用需要注意的问题。
4.5.2 方法调用
在Java编程过程中，当按照自定义方法的规则以及自定义方法基础格式完成方法的定义之后，我们需要使用自定义的这些方法，这个过程成为自定义方法的调用。自定义方法调用根据方法所处的位置具有不同情况，主要包括，当方法在同一个类中的时候方法的调用，当方法在不同类的时候方法调用。
同类的方法调用
当自定义的方法完成定义过程之后，如果要在当前类进行调用，我们一般使用直接调用的方式，其基本格式为：方法名称(实际参数列表); 此外当自定义的方法存在返回值时，需要在调用方法的时候接收返回值数据，格式为：数据类型变量名 = 方法名称(实际参数列表); 对于Java代码来说存在一个程序的入口，自定义的方法需要在入口处进行调用才能执行，根据不同的逻辑需要也存在自定义方法的嵌套调用。
举一个例子：
public class UseFunctionTest
{

//程序入口
public static void main(String[] args)
{//直接调用有返回值的方法//定义两个实际参数int num1 = 10;int num2 = 20;int mySum = getSum(num1,num2);System.out.println( "两个数的和为：" + mySum );//直接调用没有返回值的方法printStr();//求两个数的平均值getAvg(num1,num2);}//定义一个方法，用来求解两个整数的和，并返回
public static int getSum(int a, int b)
{int sum = a+b;return sum;
}//定义一个方法用来向屏幕输出一个字符串"HelloWorld"
public static void printStr()
{System.out.println( "HelloWorld" );
}//定义一个方法用来求两个数的平均值，并直接输出到屏幕上
public static void getAvg(int m, int n)
{int sum = getSum(m,n);int avg = sum/2;System.out.println( "两个数的平均值为：" + avg );
}

}
代码的执行效果如图：

对于Java来说，main方法使用静态static修饰，如果方法需要在main方法中直接调用那么这个方法也需要使用static进行修饰，也就是说如果一个方法是静态static修饰的那么在其方法体内被直接调用的方法也需要是使用static修饰的。对于修饰符我们再第5章会详细讲解。
不同类的方法调用
在Java编程中，我们会编写多个Java类，对于不同类的自定义方法我们需要通过方法调用才能执行其功能，对于不同Java类的方法使用，我们也需要遵循一定的格式规范。
调用不同类中的非static修饰方法
/**

当前类作为一个工具类，在其中规划了几个功能

*/
public class MyUtil
{

//功能一：
//完成整数求和的操作
public int getSum(int num1 , int num2)
{int sum = num1 + num2;return sum;
}//功能二：
//完成整数的平均值计算
public void getAvg(int num1, int num2)
{int sum = getSum(num1,num2);int avg = sum/2;System.out.println( "平均值为：" + avg );
}

}
/**

当前Java类作为程序的入口，在该类中只有程序的入口方法

*/
public class Test
{

//程序入口
public static void main(String[] args)
{//调用MyUtil类的求和功能，计算两个整数的和int a = 10;int b = 20;//创建MyUtil类的实例MyUtil mu = new MyUtil();//通过类的实例调用求和功能int sum = mu.getSum(a,b);System.out.println( "两个整数的和为：" + sum );//通过类的实例调用求平均值功能mu.getAvg(a,b);}

}
注意，当前Java自定义的方法位于多个Java类中，进行编译操作时，只需要对具有程序入口的类进行编译即可，在执行运行操作时，也只需要执行具有程序入口的类。
上面的代码运行结果如图：

调用不同类中static修饰的方法
/**

当前类作为一个绘图工具，主要完成一些图形绘制

*/
public class DrawUtil
{

//功能一：
//根据指定的长与宽，绘制矩形public static void drawSquareness(int m, int n)
{//控制行数的输出for(int i = 1 ; i < m ; i++){//控制一行内多个"*"的输出for(int j = 1; j < n ; j++){System.out.print("*");}//"*"完成输出之后，进行换行System.out.println();}
}//功能二：
//根据指定的行数，输出三角形
public static void drawTriangle(int m)
{//控制行的输出for(int i = 1; i < m ; i++){//每行的"*"个数一次递增for(int j = 1 ; j <= i ; j++){System.out.print("*");}//换行System.out.println();}
}

}
/**
当前类作为程序的入口类

*/
public class Test
{

//程序入口
public static void main(String[] args)
{//使用DrawUtil提供的矩形绘制功能DrawUtil.drawSquareness(5,8);//使用DrawUtil提供的三角形绘制功能DrawUtil.drawTriangle(7);}

}
代码的运行结果如图：

自定义方法无论在哪个类中都可以通过方法调用最终将功能串联在一起，大家需要根据各自的需要进行不同形式的选择，从而达到解决问题的目的。
4.5.3 方法重载
在Java的编程编程过程中，Java类作为一个基本的单位来出现，在同一个Java类中根据不同的编程逻辑需要，会定义多个自定义的方法，用来将处理同一系列操作的代码封装在一起，对于具有相同功能的不同情况来说，我们需要进行区分。比如：定义一个求和的方法，来完成两个整数的和，三个整数的和，一个整数与一个小数的和，两个小数与一个整数的和等等这些操作都是极其相近的，都是想要完成求和操作，去过我们定义方法，需要给他们每一个需求都定义一个对应的方法，这个时候就会存在一个问题，对于方法名的命名，在命名的过程中具有见名知意的方法名最好的就是sum，但是这么多需求都是需要进行求和操作，这个时候如果定义其他方法名来表示，难免会出现表达上的差误。在Java中提供了针对同一功能系列的多种情况的时候，方法定义的规范和指导意见，那就是方法重载。
方法重载是指，在同一个Java类中，多个方法之间的一种关系，其基本的规则为，在同一个Java类中，不同的自定义方法之间，方法名称相同，方法的形式参数不同，形式参数不同又从两个层面来区分，一个是两个方法的形式参数个数不同，一个是两个方法的形式参数对应位置的数据类型不同，方法重载与方法的返回值无关，与方法的修饰符也无关。根据这种规则，我们就可以很好的解决同一系列的功能中各个功能分支的区别了。
下面我们通过代码来展示一下，方法重载是怎么实现的
代码展示形式参数的个数不同

public class Test {

//程序入口
public static void main(String[] args)
{//求两个整数的和getSum(10,20);//求三个整数的和getSum(10,20,30);//求四个整数的和int result = getSum(10,20,30,40);System.out.println( "四个整数的和为："+result );
}//自定义方法用来完成两个整数的求和操作
public static void getSum(int a, int b)
{int result = a+b;System.out.println ( "两个整数的和为："+result );}//自定义方法用来完成三个整数的求和操作
private static void getSum(int a, int b, int c)
{int result = a+b+c;System.out.println ( "三个个整数的和为："+result );
}//自定义方法用来完成四个整数的求和操作，并将结果返回
private static int getSum(int a, int b, int c, int d)
{int result = a+b+c+d;return result;
}

}
代码运行效果如图：

对于上面的代码向我们展示了在同一个类中可以存在多个同名的自定义方法，但是需要各个方法之间的形式参数个数不同，与返回值以及修饰符是没有关系的，下面我们在通过代码看一下在形式参数列表中对应位置参数的数据类型的不同，构成的方法重载关系。
代码如下：
public class Demo {

//程序入口
public static void main(String[] args)
{//求两个整数的和getSum(10,20);//求两个小数的和getSum(1.2,2.3);//求整数与小数的和getSum(10,2.5);//求整数与小数的和getSum(2.5,10);
}//自定义方法用来完成两个整数的和
public static void getSum(int a, int b)
{int result = a+b;System.out.println( "两个整数的和为："+result );
}//自定义方法用来完成两个小数的和
public static void getSum(double a, double b)
{double result = a+b;System.out.println( "两个小数的和为："+result );
}//自定义方法来完成整数与小数的求和
public static void getSum(int a, double b)
{double result = a+b;System.out.println( "整数与小数的和为："+result );
}//自定义方法来完成整数与小数的求和
public static void getSum(double a, int b)
{double result = a+b;System.out.println( "整数与小数的和为："+result );
}

}
代码的运行结果如图：

上面的代码中我们可以看到，对于同一个方法名称的多个方法之间，即使参数的个数相同，但是其编写的先后位置不同，也是构成重载的，通过上面的代码我们验证了方法重载另外一项要求，那就是形式参数列表的参数对应位置的数据类型不同也是构成重载关系的。
方法重载主要应用在对于某一项功能存在各种不同分支情况时，可以使用方法重载进行区分，从而使得代码管理更加清晰，代码简洁。在方法使用的时候只需要根据各自的分支情况直接使用即可，没必须要记忆大量的方法名称。

在上面的求和操作过程中，当我们需要求和的数据时同一类的多个数据时，我们可以使用可变形式参数的方式来解决，否则就会出现，为两个数求和、三个数求和、四个数求和、五个数求和等等每种情况都编写一个自定义方法的尴尬，虽然方法重载是可以支持的，但是这样会显得代码很臃肿。对于可变形式参数的方法定义，指的是当定义方法的形式参数列表中存在多个相同类型的参数时，我们可以使用”…”来表示，从而节省代码书写的量。比如我们想要完成两个、三个、四个、五个整数和的运算时，没必须要编写多个自定义方法，只需要定义一个即可。代码如下：

public class Test {

//程序入口
public static void main(String[] args)
{//求两个整数的和getSum(10,20);//求三个整数的和getSum(10,20,30);//求四个整数的和getSum(10,20,30,40);}//自定义方法，形式参数使用可变长形式
public static void getSum(int ... nums)
{//获取参数的实际个数int count = nums.length;//定义变量存储数值的和int sum = 0;//遍历多个参数的值，并以此求和for(int i = 0 ; i < count ; i++){sum += nums[i];}System.out.println( count+"个整数的和为："+sum);}

}
代码的运行结果如图：

通过代码我们可以看到通过可边长的形式参数方法的定义，可以满足我们对于浮动个数的数据的求和操作。而且我们通过代码可以知道，对于可变长的各个参数实际是保存到了一个数组中。除了这种形式之外，可变长的形式参数还支持多个类型，当我们要求的是求解一个小数与多个整数的和，那可变长参数方法定义如下：
public class Test {

//程序入口
public static void main(String[] args)
{//求两个整数的和getSum(10,20);//求三个整数的和getSum(10,20,30);//求四个整数的和getSum(10,20,30,40);//一个小数与多个整数的和getSum(1.4,10,20,30,40,50);}//自定义方法，形式参数使用可变长形式
public static void getSum(double d,int ... nums)
{//获取参数的实际个数int count = nums.length;//定义变量存储数值的和double sum = 0;sum = sum + d;//遍历多个参数的值，并以此求和for(int i = 0 ; i < count ; i++){sum += nums[i];}System.out.println( "小数与"+count+"个整数的和为："+sum);}//自定义方法，形式参数使用可变长形式
public static void getSum(int ... nums)
{//获取参数的实际个数int count = nums.length;//定义变量存储数值的和int sum = 0;//遍历多个参数的值，并以此求和for(int i = 0 ; i < count ; i++){sum += nums[i];}System.out.println( count+"个整数的和为："+sum);}

}
代码的运行效果如图：

在形式参数中的各个参数的数据类型不一致时，一定要将可变长的部分放到形式参数列表的尾部，否则会出现匹配方法错误的情况。在上面的代码中，求多个整数的和的方法与求一个小数与多个整数的和的方法，他们彼此之间同样也是构成方法重载关系。方法重在需要根据实际的情况去灵活使用。

欢迎使用Markdown编辑器

你好！这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。

新的改变

我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：

全新的界面设计 ，将会带来全新的写作体验；
在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示；
增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示；
全新的 KaTeX数学公式 语法；
增加了支持甘特图的mermaid语法¹ 功能；
增加了 多屏幕编辑 Markdown文章功能；
增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能，功能按钮位于编辑区域与预览区域中间；
增加了 检查列表 功能。

功能快捷键

撤销：Ctrl/Command + Z
重做：Ctrl/Command + Y
加粗：Ctrl/Command + B
斜体：Ctrl/Command + I
标题：Ctrl/Command + Shift + H
无序列表：Ctrl/Command + Shift + U
有序列表：Ctrl/Command + Shift + O
检查列表：Ctrl/Command + Shift + C
插入代码：Ctrl/Command + Shift + K
插入链接：Ctrl/Command + Shift + L
插入图片：Ctrl/Command + Shift + G

合理的创建标题，有助于目录的生成

直接输入1次#，并按下space后，将生成1级标题。
输入2次#，并按下space后，将生成2级标题。
以此类推，我们支持6级标题。有助于使用TOC语法后生成一个完美的目录。

如何改变文本的样式

强调文本 强调文本

加粗文本 加粗文本

标记文本

删除文本

引用文本

H₂O is是液体。

2¹⁰ 运算结果是 1024.

插入链接与图片

链接: link.

图片:

带尺寸的图片:

居中的图片:

居中并且带尺寸的图片:

当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。

如何插入一段漂亮的代码片

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

生成一个适合你的列表

项目
- 项目
  - 项目

项目1
项目2
项目3

计划任务
完成任务

创建一个表格

一个简单的表格是这么创建的：

项目	Value
电脑	$1600
手机	$12
导管	$1

设定内容居中、居左、居右

使用:---------:居中
使用:----------居左
使用----------:居右

第一列	第二列	第三列
第一列文本居中	第二列文本居右	第三列文本居左

SmartyPants

SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如：

TYPE	ASCII	HTML
Single backticks	`'Isn't this fun?'`	‘Isn’t this fun?’
Quotes	`"Isn't this fun?"`	“Isn’t this fun?”
Dashes	`-- is en-dash, --- is em-dash`	– is en-dash, — is em-dash

创建一个自定义列表

Markdown: Text-to-HTML conversion tool
Authors: John; Luke

如何创建一个注脚

一个具有注脚的文本。²

注释也是必不可少的

Markdown将文本转换为 HTML。

KaTeX数学公式

您可以使用渲染LaTeX数学表达式 KaTeX:

Gamma公式展示 Γ(n)=(n−1)!∀n∈N\Gamma(n) = (n-1)!\quad\forall n\in\mathbb NΓ(n)=(n−1)!∀n∈N 是通过欧拉积分

Γ(z)=∫0∞tz−1e−tdt .\Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,. Γ(z)=∫0∞tz−1e−tdt.

你可以找到更多关于的信息 LaTeX 数学表达式here.

新的甘特图功能，丰富你的文章

Mon 06Mon 13Mon 20已完成进行中计划一计划二现有任务Adding GANTT diagram functionality to mermaid

关于 甘特图 语法，参考这儿,

UML 图表

可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图：:

张三李四王五你好！李四, 最近怎么样?你最近怎么样，王五？我很好，谢谢!我很好，谢谢!李四想了很长时间,文字太长了不适合放在一行.打量着王五...很好... 王五, 你怎么样?张三李四王五

这将产生一个流程图。:

链接

长方形

圆

圆角长方形

菱形

关于 Mermaid 语法，参考这儿,

FLowchart流程图

我们依旧会支持flowchart的流程图：

Created with Raphaël 2.2.0开始我的操作确认？结束yesno

关于 Flowchart流程图 语法，参考这儿.

导出与导入

导出

如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ，生成一个.md文件或者.html文件进行本地保存。

导入

如果你想加载一篇你写过的.md文件，在上方工具栏可以选择导入功能进行对应扩展名的文件导入，
继续你的创作。

mermaid语法说明 ↩︎
注脚的解释 ↩︎

Java编程基础小总结相关推荐

Java大神推荐，java编程基础必备（必看）
在没有以前的操作习惯的错误情况下,反而容易接受新知识,所以不要因为自己对java一无所知而自卑,相反,这是菜鸟们的优势,但是如何才能从一个菜鸟历练成大神呢,当然是需要学习了,不学习就想成为大神,就是在 ...
第二章java编程基础测试题_Java编程基础测试题分享
单选题:(每道题目2分) 1. 下列哪个声明是错误的?(B) A. int i=10; B. float f=1.1; //float f=1.1f C. double d=34.4; D. byte ...
Java编程基础 - 泛型
Java编程基础 - 泛型 [导读] . 什么是泛型一般传统而言,泛型允许程序员在强类型语言中编写代码时使用一些以后才指定的类型,在实例化时作为参数指明这些类型. 编程技术发展至今很多语言,尤其是强 ...
实验一 Java编程基础
面向对象--Java实验报告实验一:Java基础编程实验一 Java编程基础 <center> <strong>姓名:</strong> <u>XX ...
Java实验01 Java编程基础（猜数字游戏、随机点名器）
实验一 Java编程基础实验1-1 随机点名器一.实验描述 1. 任务描述编写一个随机点名的程序,使其能够在全班同学中随机点中某一名同学的名字.随机点名器具备3个功能,包括存储全班同学姓名.总览 ...
java中的常用名词,Java编程基础常见英语词汇
Java编程基础常见英语词汇 Java编程基础中常见英语的词汇有哪些呢?这些都是学Java编程需要运用到的,下面内容由小编为大家介绍Java编程基础常见英语词汇,供大家参考! Java编程基础常见英语 ...
java编程基础学习需要多久的时间
Java是当前世界颇为流行的编程语言之一,很多想学习java的人都会听过一句话,先学好java基础,在考虑是自学还是培训学习,同时新的问题出现了,java基础包括什么,需要学习多久呢,对于小白来说,想 ...
进击！！第二章 JAVA编程基础
第二章 JAVA编程基础目标: 掌握java的基本语法,常量,变量,流程控制语句,方法以及数组运用java运算符的使用了解java代码的基本格式 2.1java 的基本语法 1. 代码的基本格式 ...
《21天学通Java（第7版）》—— 第2章 Java编程基础 2.1 语句和表达式
本节书摘来异步社区<21天学通Java(第7版)>一书中的第2章,第2.1节,作者: [美]Rogers Cadenhead(罗格斯卡登海德),更多章节内容可以访问云栖社区"异 ...

Java编程基础小总结

欢迎使用Markdown编辑器

新的改变

功能快捷键

合理的创建标题，有助于目录的生成

如何改变文本的样式

插入链接与图片

如何插入一段漂亮的代码片

生成一个适合你的列表

创建一个表格

设定内容居中、居左、居右

SmartyPants

创建一个自定义列表

如何创建一个注脚

注释也是必不可少的

KaTeX数学公式

新的甘特图功能，丰富你的文章

UML 图表

FLowchart流程图

导出与导入

导出

导入

Java编程基础小总结相关推荐

最新文章

热门文章