Java学习

java语言概述

Java是sun公司开发的一门编程语言,目前被Oracle公司收购，编程语言就是用来编写软件的。

 Java的应用

• 开发QQ、迅雷程序(桌面应用软件)
• 淘宝、京东(互联网应用软件)
• 安卓应用程序

 Java的擅长

• 互联网：电商、P2P等等
• 企业级应用：ERP、CRM、BOS、OA等等

Java语言平台

• JavaSE（标准版）部分,JavaSE并不能开发大型项目。
• JavaEE（企业版）部分,学习完JavaEE部分就可以开发各种大型项目了。

java语言开发环境

JDK是Java开发环境，官网 http://www.oracle.com/cn/index.html

JDK的安装

傻瓜式安装，双击安装程序，然后一路next即可，安装的推荐方式：

• 安装路径不要有中文或者特殊符号如空格等。
• 所有和开发相关的软件最好安装目录统一。
• 当提示安装JRE时，可以选择不安装。建议还是安装上。

 验证安装是否成功，通过DOS命令，切换到JDK安装的bin目录下。比如 D:\develop\Java\jdk1.7.0_72\bin，然后分别输入javac和java，如果正常显示一些内容，说明安装成功。

配置环境变量

环境变量的作用：由于javac和java命令只能在固定的目录下才能执行，而我们写的代码如果都和javac及java命令放在相同的目录中的话，会显得很乱”，为了让Java的bin目录下的javac命令可以在任意目录下执行，就得配置环境变量。

具体安装参考：JAVA开发环境的搭建（配置JAVA开发环境）

JDK和JRE以及跨平台

JDK与JRE的关系

• JDK：Java Development Kit ，Java语言的开发工具包，提供了Java语言的开发工具，它里面包含了JRE，同时也就包含了JVM（Java虚拟机）。
• JRE：Java Runtime Environment，它是Java运行环境，如果你不需要开发只需要运行Java程序，那么你可以安装JRE。例如程序员开发出的程序最终卖给了用户，用户不用开发，只需要运行程序，所以用户在电脑上安装JRE即可。它包含了Java虚拟机，也就是JVM，同时还包含了Java语言运行需要的核心类库。

跨平台特性：平台指的是操作系统 （Windows，Linux，Mac）。只需在相应的平台上安装Java虚拟机，就可以运行Java程序。

使用IntelliJ IDEA打印Hello World

第一步：创建新项目

第二步：选择jdk，然后next

第三步：选择Hello World模板，然后Next

 

第四步：输入项目名称，然后Finish

第五步：运行

第六步：查看结果

Java代码的编写执行过程

源文件：编写Java源文件（我们也称之为源代码文件），它的扩展名为.java；

编译：然后通过编译器把源文件编译成字节码文件，字节码文件扩展名为.class；

运行：最后使用解释器来运行字节码文件。

CentOS7下Java8安装

1、到https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html找到jdk-8u221-linux-x64.tar.gz的下载地址，需要登录。

2、打开终端，使用 wget命令下载。比如：wget https://download.oracle.com/otn/java/jdk/8u221-b11/230deb18db3e4014bb8e3e8324f81b43/jdk-8u221-linux-x64.tar.gz?AuthParam=1569641530_05c699a00ac2afe0c0dde7cc5784e4d5

3、解压，tar -xzvf jdk-8u221-linux-x64.tar.gz?AuthParam=1569641530_05c699a00ac2afe0c0dde7cc5784e4d5

4、移动到/usr/local目录下，mv jdk-8u221-linux-x64.tar.gz?AuthParam=1569641530_05c699a00ac2afe0c0dde7cc5784e4d5 /opt/usr

5、切换到opt目录下，cd /opt/usr

6、改名为java8，mv jdk-8u221-linux-x64.tar.gz?AuthParam=1569641530_05c699a00ac2afe0c0dde7cc5784e4d5 java8

7、配置环境变量，vi /etc/profile,在文件后面追加以下代码：

JAVA_HOME=/usr/local/java8
JRE_HOME=/usr/local/java8/jre
PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin
CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib
export JAVA_HOME JRE_HOME PATH CLASSPATH

8、执行source /etc/profile命令使配置生效，到这一步就算安装完成了，使用java -version查看安装是否成功。

注释

注释用来解释和说明程序的文字，注释是不会被执行的.

单行注释

//这是一条单行注释 
public int i;

多行注释

/* 这是
* 一段注释，
* 它跨越了多个行
*/ 
public void f() {}
}

文档注释 

/** The first Thinking in Java example program.
* Lists system information on current machine.
* @author Bruce Eckel
* @author http://www.BruceEckel.com
* @version 1.0
*/
public class Property {
/** Sole entry point to class & application
* @param args array of string arguments
* @return No return value
* @exception exceptions No exceptions thrown
*/
public static void main(String[] args) {
System.out.println(new Date());
Properties p = System.getProperties();
p.list(System.out);
System.out.println("--- Memory Usage:");
Runtime rt = Runtime.getRuntime();
System.out.println("Total Memory = "
+ rt.totalMemory()
+ " Free Memory = "
+ rt.freeMemory());
}59
}

对于单行和多行注释，被注释的文字，不会被JVM解释执行；对于文档注释，可以被JDK提供的工具javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档；单行注释可以嵌套使用，多行注释不能嵌套使用。

关键字

是被Java语言赋予特殊含义，具有专门用途的单词，比如class，int，double均为Java已经预设好的;

组成关键字的字母全部小写 ,注意String不是关键字;

goto与const是Java中的保留字，即没有赋予特殊含义却仍被Java占用的单词;

标识符

就是给类,接口,方法,变量等起名字时使用的字符序列,组成规则只能包含下面的内容,不能有其它内容:

•  英文大小写字母
• 数字字符
•  $和_

注意事项

• 数字不能开头
• 不可以使用关键字
• 严格区分大小写，不限制长度
• 起名时，尽量见名知意

标识符中常见的命名规则

• 包名：多单词组成时所有字母均小写，使用.连接.比如：aaa.bbb.ccc
• 类名&接口名：大驼峰式。比如：AaaBbbCcc
• 变量名&方法名：小驼峰式。比如：aaaBbbCcc
• 常量名：多单词组成是所有字母均大写，使用_连接。比如：AAA_BBB_CCC

数据类型

为什么有数据类型？

Java是强类型语言，对于每一种数据都定义了明确的具体数据类型，变量必须要有明确的类型，什么类型的变量装载什么类型的数据。

数据类型的分类

基本数据类型

基本数据类型是Java语言中内置的类型，分别是整数类型、小数类型、字符类型、布尔类型。

这四类基本类型是最简单、最基础的类型。

• 整数(byte、short、int、long)，默认的整数类型是int类型，long类型需添加"L"后缀。
• 小数(float、double)、字符类型(char)，默认的浮点类型是double类型。在Java中所有没有后缀以及使用“D”后缀（小写也可以，但建议使用大写）的小数都是double类型；float类型常量必须添加“F”后缀
• 字符类型（char）
• 布尔类型(boolean)

引用数据类型

引用数据类型是强大的数据类型，它是基于基本数据类型创建的。JavaSE中提供了一个超级类库，类库中包含了近万种引用数据类型。比如：数组、类、接口。

常量

常量就是不变的数据量, 在程序执行的过程中其值不可以发生改变

常量分类

整数类型

• 十进制表示方式：正常数字，如 13、25等
• 二进制表示方式：以0b(0B)开头，如0b1011 、0B1001
• 十六进制表示方式：以0x(0X)开头，数字以0-9及A-F组成  如0x23A2、0xa、0x10
• 八进制表示方式：以0开头，如01、07、0721

小数类型，如1.0、-3.15、3.168等

布尔类型， true、false

字符类型，字符必须使用’’ 包裹，并且其中只能且仅能包含一个字符。如'a'，'A', '0', '家'

字符串类型，一种引用类型，字符串必须使用""包裹，其中可以包含0~N个字符。如"我爱Java"，"0123"，""，"null"

在程序中输出Java中的常量

public class Main {
    public static void main(String[] args) {
        //输出整数 十进制
        System.out.println(50);//50
        //输出整数，二进制, 数字开头0B
        System.out.println(0B11);//3
        //输出整数，八进制，数字开头0
        System.out.println(051);//41
        //输出整数，十六进制，数组开头0X  0-9 A-F
        System.out.println(0XE);//14
        //输出浮点数据
        System.out.println(5.0);//5.0
        //输出布尔数据，只有2个值，true，false 关键字
        System.out.println(true);//true
        System.out.println(false);//false
        //输出字符常量，单引号包裹，只能写1个字符
        System.out.println('a');//a
        //输出字符串常量，双引号包裹，可以写0-n个字符
        System.out.println("HelloWorld");//HelloWorld
    }
}

变量

什么是变量?

变量是一个内存中的小盒子（小容器），容器是什么？生活中也有很多容器，例如水杯是容器，用来装载水；你家里的大衣柜是容器，用来装载衣裤；饭盒是容器，用来装载饭菜。

那么变量是装载什么的呢？答案是数据！结论：变量是内存中装载数据的小盒子，你只能用它来存数据和取数据。

定义变量

数据类型  变量名  =  数据值；
int         a    =  100;

变量使用的注意事项

变量定义后可以不赋值，使用时再赋值。不赋值不能使用。

int x;
x = 20; //为x赋值20

变量使用时有作用域的限制。

public static void main(String[] args) {
    int x = 20;
    {
        int y = 20;
    }
    System.out.println(x);//读取x变量中的值，再打印
    System.out.println(y);//读取y变量中的值失败，失败原因，找不到y变量，因为超出了y变量作用范围，所以不能使用y变量
}

变量不可以重复定义。

public static void main(String[] args){
      int x = 10;
      double x = 5.5;//编译失败，变量重复定义
}

数据类型转换

不同类型的变量可以在一起运算，但要先进行类型转换再运算。

• 范围小的数据类型值（如byte），可以直接转换为范围大的数据类型值（如int）；
• 范围大的数据类型值（如int），不可以直接转换为范围小的数据类型值（如byte）

数据范围从小到大依次列出：byte -> short -> int -> long -> float -> double

两种方式的数据类型转换

自动类型转换：表示范围小的数据类型转换成范围大的数据类型。格式：

范围大的数据类型 变量 = 范围小的数据类型值；
比如：double d = 1000; 

强制类型转换：表示范围大的数据类型转换成范围小的数据类型

范围小的数据类型  变量 = (范围小的数据类型) 范围大的数据类型值;
比如：int  i = (int)6.718;   //i的值为6

运算符

算数运算符

加号（ +）、减号和负号（ -）、乘号（ *）、除号（ /）、取模（%）、自增（++）、自减（--）以及等号（ =）的用法与其他所有编程语言都是类似的 。

++,--运算符后置时，先使用变量a原有值参与运算操作，运算操作完成后，变量a的值自增1或者自减1。

l ++，--运算符前置时，先将变量a的值自增1或者自减1，然后使用更新后的新值参与运算操作。

赋值运算符

赋值（=）、加后赋值（+=）、减后赋值（-=）、乘后赋值（*=）、整除后赋值（/=）取模后赋值（%=）的用法与其他所有编程语言都是类似的 。

关系运算符

等于（==）  不等于（!=） 小于（<） 大于（>）  小于等于（<=） 大于等于（>=）的用法与其他所有编程语言都是类似的 。

逻辑运算符

与（&&）、或（||）、非（!）的用法与其他所有编程语言都是类似的 。

短路：当使用与或者或时，只要能判断出结果则后边的部分就不再判断。

三元运算符

(条件表达式)？表达式1：表达式2；

int n = (3>2 && 4>6) ? 100 : 200;
//逻辑运算后的结果为false，运算结果为表达式2的值200,然后将结果200赋值给了变量n

商场库存清单案例

案例输出结果如下：

案例需求分析

观察清单后，可将清单分解为三个部分（清单顶部、清单中部、清单底部）

清单顶部为固定的数据，直接打印即可
清单中部为商品，为变化的数据，需要记录商品信息后，打印，经过观察，我们确定一项商品应该有如下几个属性：

• 品牌型号: 即商品名称，String型
• 尺寸：物品大小，double型
• 价格：物品单价，double型
• 配置：这一项为每种商品的配置信息，String型
• 库存数：这一项为每种商品的库存个数，int型

清单底部包含了统计操作，需经过计算后，打印，我们发现两个单独的可变化量：

• 总库存数：所有商品总个数，int型
• 库存商品总金额：所有商品金额，double型

public class Main {
    public static void main(String[] args) {
        //苹果笔记本电脑
        String macBrand = "MacBookAir";
        double macSize = 13.3;
        double macPrice = 6988.88;
        int macCount = 5;

        //联想Thinkpad笔记本电脑
        String thinkpadBrand = "ThinkpadT450";
        double thinkpadSize = 14.0;
        double thinkpadPrice = 5999.99;
        int thinkpadCount = 10;

        //华硕ASUS笔记本电脑
        String ASUSBrand = "ASUS-FL5800";
        double ASUSSize = 15.6;
        double ASUSPrice = 4999.50;
        int ASUSCount = 18;
        //统计所有库存商品数量与金额
        //统计库存总个数、库存总金额
        int totalCount = macCount + thinkpadCount + ASUSCount;
        double totalMoney = (macCount * macPrice) + (thinkpadCount * thinkpadPrice) + (ASUSCount * ASUSPrice);
        //打印库存清单顶部信息
        System.out.println("------------------------------商城库存清单-----------------------------");
        System.out.println("品牌型号    尺寸    价格    库存数");
        //打印库存清单中部信息
        System.out.println(macBrand + "    " + macSize + "    " + macPrice + "    " + macCount);
        System.out.println(thinkpadBrand + "    " + thinkpadSize + "    " + thinkpadPrice + "    " + thinkpadCount);
        System.out.println(ASUSBrand + "    " + ASUSSize + "    " + ASUSPrice + "    "+ASUSCount);
        //打印库存清单底部信息
        System.out.println("-----------------------------------------------------------------------");
        System.out.println("总库存数：" + totalCount);
        System.out.println("库存商品总金额：" + totalMoney);
    }
}

 

Scanner类

Scanner类属于引用数据类型，先了解下引用数据类型。

引用数据类型的使用

与定义基本数据类型变量不同，引用数据类型的变量定义及赋值有一个相对固定的步骤或格式。

数据类型  变量名  =  new 数据类型();

每种引用数据类型都有其功能，我们可以调用该类型实例使用其功能。

变量名.方法名();

Scanner类

Scanner类可以完成用户键盘录入，获取到录入的数据。

Scanner使用步骤：

导包： import java.util.Scanner; 

创建对象实例：Scanner sc = new Scanner(System.in); 

调用方法：

int  i = sc.nextInt(); 用来接收控制台录入的数字

String s = sc.next(); 用来接收控制台录入的字符串

了解完Scanner类，我们编写代码来使用下它：ScannerDemo01.java

import java.util.Scanner;
public class ScannerDemo01 {
    public static void main(String[] args) {
        //创建Scanner引用类型的变量
        Scanner sc = new Scanner(System.in);
        //获取数字
        System.out.println("请输入一个数字");
        int n = sc.nextInt();
        System.out.println("n的值为" + n);
        //获取字符串
        String str = sc.next();
        System.out.println("str的值为" + str);

    }
}

运行结果如下图所示:

 

 随机数类Random

用来产生随机数的类Random，它也属于引用数据类型。

这个Random类，它可以产生多种数据类型的随机数，在这里主要介绍生成整数与小数的方式。

方法简介

public int nextInt(int maxValue) 产生[0,maxValue)范围的随机整数，包含0，不包含maxValue；

public double nextDouble()  产生[0,1)范围的随机小数，包含0.0，不包含1.0。

 Random使用方式:

import导包： java.util.Random  

创建实例格式 ：Random 变量名 = new Random(); 

接下来，通过一段代码，学习下Random类的使用，RandomDemo.java

import java.util.Random;
public class RandomDemo {
    public static void main(String[] args) {
        // 创建Random类的实例
        Random r = new Random();
        // 得到0-100范围内的随机整数，将产生的随机整数赋值给i变量
        int i = r.nextInt(100);
        //得到0.0-1.0范围内的随机小数，将产生的随机小数赋值给d变量
        double d = r.nextDouble();
        System.out.println(i);
        System.out.println(d);
    }
}

运行结果如下图所示：

 

流程控制语句

选择结构if

 if语句

if语句是指如果满足某种条件，就进行某种处理。

在Java中，if语句的具体语法格式如下：

if (条件语句){

执行语句;

……

}

上述格式中，判断条件是一个布尔值，当判断条件为true时，{}中的执行语句才会执行。

接下来通过一段代码，学习一下if语句的具体用法，IfDemo01.java 

//定义了一个变量x，其初始值为5。在if语句的判断条件中判断x的值是否小于10，很明显条件成立，{}中的语句会被执行，变量x的值将进行自增。从运行结果可以看出，x的值已由原来的5变成了6。
public class IfDemo01 {
    public static void main(String[] args) {
        int x = 5;
        if (x < 10) {
            x++;
        }
        System.out.println("x=" + x);//x=6
    }
}

if…else语句

if…else语句是指如果满足某种条件，就进行某种处理，否则就进行另一种处理。if…else语句具体语法格式如下：

if (判断条件){
    执行语句1
    ……
}else{
    执行语句2
    ……
}

上述格式中，判断条件是一个布尔值。当判断条件为true时，if后面{}中的执行语句1会执行。当判断条件为false时，else后面{}中的执行语句2会执行。

接下来通过一段代码，来实现判断奇偶数的程序，IfDemo02.java

public class IfDemo02 {
    public static void main(String[] args) {
        int num = 19;
        if (num % 2 == 0) {
        // 判断条件成立，num被2整除
            System.out.println("num是一个偶数");
        } else {
            System.out.println("num是一个奇数");
        }
    }
}
//num是一个奇数

上述代码中，变量num的值为19，模以2的结果为1，不等于0，判断条件不成立。因此会执行else后面{}中的语句，打印“num是一个奇数”。

if…else if…else语句

if…else if…else语句用于对多个条件进行判断，进行多种不同的处理。if…else if…else语句具体语法格式如下：

if (判断条件1) {
　　执行语句1
} else if (判断条件2) {
　　执行语句2
}
...
else if (判断条件n) {
　　执行语句n
} else {
　　执行语句n+1
}

上述格式中，判断条件是一个布尔值。当判断条件1为true时，if后面{}中的执行语句1会执行。当判断条件1为false时，会继续执行判断条件2，如果为true则执行语句2，以此类推，如果所有的判断条件都为false，则意味着所有条件均未满足，else后面{}中的执行语句n+1会执行。

接下来通过一段代码，来实现对学生考试成绩进行等级划分的程序，IfDemo03.java

public class IfDemo03 {
    public static void main(String[] args) {
        int grade = 75; // 定义学生成绩
        if (grade > 80) {
        // 满足条件 grade > 80
            System.out.println("该成绩的等级为优");
        } else if (grade > 70) {
        // 不满足条件 grade > 80 ，但满足条件 grade > 70
            System.out.println("该成绩的等级为良");
        } else if (grade > 60) {
        // 不满足条件 grade > 70 ，但满足条件 grade > 60
            System.out.println("该成绩的等级为中");
        } else {
        // 不满足条件 grade > 60
            System.out.println("该成绩的等级为差");
        }
    }
}
//该成绩的等级为良

上述代码中，定义了学生成绩grade为75。它不满足第一个判断条件grade>80，会执行第二个判断条件grade>70，条件成立，因此会打印“该成绩的等级为良”。

选择结构if语句与三元运算转换

三元运算符，它和if-else语句类似，语法如下：

判断条件 ? 表达式1 : 表达式2

三元运算符会得到一个结果，通常用于对某个变量进行赋值，当判断条件成立时，运算结果为表达式1的值，否则结果为表达式2的值。

例如求两个数x、y中的较大者，如果用if…else语句来实现，具体代码如下：

int x = 0;
int y = 1;
int max;
if (x > y) {
　　max = x;
} else {
　　max = y;
}

可以替换为

int x=0;
int y=1;
int max = x > y ? x : y;

switch语句

根据一个整数表达式的值， switch 语句可从一系列代码选出一段执行。它的格式如下：

switch(整数选择因子或者字符串或者枚举) {
　　case 整数值 1 : 语句; break;
　　case 整数值 2 : 语句; break;
　　case 整数值 3 : 语句; break;
　　case 整数值 4 : 语句; break;
　　case 整数值 5 : 语句; break;
　　//..
　　default:语句;92
}

switch 能将整数选择因子的结果与每个整数值比较。若发现相符的，就执行对应的语句（简单或复合语句）。若没有发现相符的，就执行default 语句。 示例：VowelsAndConsonants.java

public class VowelsAndConsonants {
    public static void main(String[] args) {
        char c = (char) (Math.random() * 26 + 'a');
        System.out.print(c + ": ");
        switch (c) {
            case 'a':
            case 'e':
            case 'i':
            case 'o':
            case 'u':
                System.out.println("vowel");
                break;
            case 'y':
            case 'w':
                System.out.println(
                        "Sometimes a vowel");
                break;
            default:
                System.out.println("consonant");
        }
    }
}

switch语句接受的数据类型

switch语句中的表达式的数据类型,是有要求的

• JDK1.0 - 1.4 数据类型接受 byte short int char
• JDK1.5 数据类型接受 byte short int char enum(枚举)
• JDK1.7 数据类型接受 byte short int char enum(枚举), String

case穿透

在使用switch语句的过程中，如果多个case条件后面的执行语句是一样的，则该执行语句只需书写一次即可，这是一种简写的方式。
例如，要判断一周中的某一天是否为工作日，同样使用数字1~7来表示星期一到星期天，当输入的数字为1、2、3、4、5时就视为工作日，否则就视为休息日。如下所示。SwitchDemo02.java

public class SwitchDemo02 {
    public static void main(String[] args) {
        int week = 2;
        switch (week) {
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                // 当 week 满足值 1、2、3、4、5 中任意一个时，处理方式相同
                System.out.println("今天是工作日");
                break;
            case 6:
            case 7:
                // 当 week 满足值 6、7 中任意一个时，处理方式相同
                System.out.println("今天是休息日");
                break;
        }
    }
}

上述代码中，当变量week值为1、2、3、4、5中任意一个值时，处理方式相同，都会打印“今天是工作日”。同理，当变量week值为6、7中任意一个值时，打印“今天是休息日”。

循环语句

while语句

while循环语句和选择结构if语句有些相似，都是根据条件判断来决定是否执行大括号内的执行语句。区别在于，while语句会反复地进行条件判断，只要条件成立，{}内的执行语句就会执行，直到条件不成立，while循环结束。while循环语句的语法结构如下：

while(循环条件){
    执行语句
    ………
}

在上面的语法结构中，{}中的执行语句被称作循环体，循环体是否执行取决于循环条件。当循环条件为true时，循环体就会执行。循环体执行完毕时会继续判断循环条件，如条件仍为true则会继续执行，直到循环条件为false时，整个循环过程才会结束。

接下来通过一段代码，来实现打印1~4之间的自然数，WhileDemo.java

public class WhileDemo {
    public static void main(String[] args) {
        int x = 1; // 定义变量x，初始值为1
        while (x <= 4) { // 循环条件
            System.out.println("x = " + x); // 条件成立，打印x的值
            x++; // x进行自增
        }
    }
}

//x = 1
//x = 2
//x = 3
//x = 4

在上述代码中，x初始值为1，在满足循环条件x <= 4的情况下，循环体会重复执行，打印x的值并让x进行自增。因此打印结果中x的值分别为1、2、3、4。

值得注意的是，代码x++用于在每次循环时改变变量x的值，从而达到最终改变循环条件的目的。如果没有这行代码，整个循环会进入无限循环的状态，永远不会结束。

循环语句for

for循环语句是最常用的循环语句，一般用在循环次数已知的情况下。for循环语句的语法格式如下：

for（初始化表达式; 循环条件; 操作表达式）{

    执行语句
    ………
}

在上面的语法结构中，for关键字后面()中包括了三部分内容：初始化表达式、循环条件和操作表达式，它们之间用“;”分隔，{}中的执行语句为循环体。

接下来分别用①表示初始化表达式、②表示循环条件、③表示操作表达式、④表示循环体，通过序号来具体分析for循环的执行流程。具体如下：

for（① ; ② ; ③）{
　　④
}

• 第一步，执行①
• 第二步，执行②，如果判断结果为true，执行第三步，如果判断结果为false，执行第五步
• 第三步，执行④
• 第四步，执行③，然后重复执行第二步
• 第五步，退出循环

接下来通过一个案例对自然数1~4进行求和，如下所示。ForDemo01.java

public class ForDemo01 {
    public static void main(String[] args) {
        int sum = 0; // 定义变量sum，用于记住累加的和
        for (int i = 1; i <= 4; i++) { // i的值会在1~4之间变化
            sum += i; // 实现sum与i的累加
        }
        System.out.println("sum = " + sum); // 打印累加的和
    }
}

上述代码中，变量i的初始值为1，在判断条件i<=4为true的情况下，会执行循环体sum+=i，执行完毕后，会执行操作表达式i++，i的值变为2，然后继续进行条件判断，开始下一次循环，直到i=5时，条件i<=4为false，结束循环，执行for循环后面的代码，打印“sum=10”。

do…while语句

do…while循环语句和while循环语句功能类似，其语法结构如下：

do {

    执行语句
    ………
} while(循环条件);

在上面的语法结构中，关键字do后面{}中的执行语句是循环体。do…while循环语句将循环条件放在了循环体的后面。这也就意味着，循环体会无条件执行一次，然后再根据循环条件来决定是否继续执行。

接下来使用do…while循环语句来实现打印1~4之间的自然数DoWhileDemo.java。

public class DoWhileDemo {
    public static void main(String[] args) {
        int x = 1; // 定义变量x，初始值为1
        do {
            System.out.println("x = " + x); // 打印x的值
            x++; // 将x的值自增
        } while (x <= 4); // 循环条件
    }
}

do …while循环和while循环能实现同样的功能。然而在程序运行过程中，这两种语句还是有差别的。如果循环条件在循环语句开始时就不成立，那么while循环的循环体一次都不会执行，而do…while循环的循环体还是会执行一次。若将DoWhileDemo.java中的循环条件x<=4改为x < 1，DoWhileDemo.java运行结果会打印x=1，而WhileDemo.java运行结果什么也不会打印。

无限循环

最简单无限循环格式：

while(true){}

或

for(;;){}

无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。

循环嵌套

嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套，如最常见的在for循环中嵌套for循环，格式如下：

for(初始化表达式; 循环条件; 操作表达式) {
    ………
    for(初始化表达式; 循环条件; 操作表达式) {
        执行语句
        ………
     }
    ………
}

接下来实现使用“*”打印直角三角形，如下所示。ForForDemo.java

public class ForForDemo {
    public static void main(String[] args) {
        int i, j; // 定义两个循环变量
        for (i = 1; i <= 9; i++) { // 外层循环
            for (j = 1; j <= i; j++) { // 内层循环
                System.out.print("*"); // 打印*
            }
            System.out.print("\n"); // 换行
        }
    }
}

运行结果如下所示：

在上述代码中定义了两层for循环，分别为外层循环和内层循环，外层循环用于控制打印的行数，内层循环用于打印“*”，每一行的“*”个数逐行增加，最后输出一个直角三角形。由于嵌套循环程序比较复杂，下面分步骤进行详细地讲解，具体如下：

• 第一步，在第3行代码定义了两个循环变量i和j，其中i为外层循环变量，j为内层循环变量。
• 第二步，在第4行代码将i初始化为1，条件i <= 9为true，首次进入外层循环的循环体。
• 第三步，在第5行代码将j初始化为1，由于此时i的值为1，条件j <= i为true，首次进入内层循环的循环体，打印一个“*”。
• 第四步，执行第5行代码中内层循环的操作表达式j++，将j的值自增为2。
• 第五步，执行第5行代码中的判断条件j<=i，判断结果为false，内层循环结束。执行后面的代码，打印换行符。
• 第六步，执行第4行代码中外层循环的操作表达式i++，将i的值自增为2。
• 第七步，执行第4行代码中的判断条件i<=9，判断结果为true，进入外层循环的循环体，继续执行内层循环。
• 第八步，由于i的值为2，内层循环会执行两次，即在第2行打印两个“*”。在内层循环结束时会打印换行符。
• 第九步，以此类推，在第3行会打印3个“*”，逐行递增，直到i的值为10时，外层循环的判断条件i <= 9结果为false，外层循环结束，整个程序也就结束了。

跳转语句（break、continue）

跳转语句用于实现循环执行过程中程序流程的跳转，在Java中的跳转语句有break语句和continue语句。接下来分别进行详细地讲解。

break语句

在switch条件语句和循环语句中都可以使用break语句。当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。当它出现在循环语句中，作用是跳出循环语句，执行后面的代码。

接下来通过下面一段代码，实现将当变量x的值为3时，使用break语句跳出循环，代码如下所示。BreakDemo.java

public class BreakDemo {
    public static void main(String[] args) {
        int x = 1; // 定义变量x，初始值为1
        while (x <= 4) { // 循环条件
            System.out.println("x = " + x); // 条件成立，打印x的值
            if (x == 3) {
                break;
            }
            x++; // x进行自增
        }
    }
}

在上述带代码中，通过while循环打印x的值，当x的值为3时使用break语句跳出循环。因此打印结果中并没有出现“x=4”。

标记

当break语句出现在嵌套循环中的内层循环时，它只能跳出内层循环，如果想使用break语句跳出外层循环则需要对外层循环添加标记。接下来将ForForDemo.java稍作修改，控制程序只打印4行“*”，如下所示。BreakDemo02.java

public class BreakDemo02 {
    public static void main(String[] args) {
        int i, j; // 定义两个循环变量
        AA: for (i = 1; i <= 9; i++) { // 外层循环
            for (j = 1; j <= i; j++) { // 内层循环
                if (i > 4) { // 判断i的值是否大于4
                    break AA; // 跳出外层循环
                }
                System.out.print("*"); // 打印*
            }
            System.out.print("\n"); // 换行
        }
    }
}

BreakDemo02.java与ForForDemo.java实现原理类似，只是在外层for循环前面增加了标记“AA”。当i>4时，使用break AA;语句跳出外层循环。因此程序只打印了4行“*”。

continue语句

continue语句用在循环语句中，它的作用是终止本次循环，执行下一次循环。接下来通过一个练习对1~100之内的奇数求和，ContinueDemo.java

public class ContinueDemo {
    public static void main(String[] args) {
        int sum = 0; // 定义变量sum，用于记住和
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) { // i是一个偶数，不累加
                continue; // 结束本次循环
            }
            sum += i; // 实现sum和i的累加
        }
        System.out.println("sum = " + sum);
    }
}
//sum = 2500

上述代码中，使用for循环让变量i的值在1~100之间循环，在循环过程中，当i的值为偶数时，将执行continue语句结束本次循环，进入下一次循环。当i的值为奇数时，sum和i进行累加，最终得到1~100之间所有奇数的和，打印“sum = 2500”。

在嵌套循环语句中，continue语句后面也可以通过使用标记的方式结束本次外层循环，用法与break语句相似，在此不再举例说明。

猜数字案例

案例介绍

猜数字案例是要完成什么样的功能呢？顾名思义，这个游戏就是你出个数字、我来猜。

游戏操作如下：

后台预先生成一个1-100之间的随机数，用户键盘录入猜数字

如果猜对了，打印“恭喜您，答对了”

如果猜错了

• 猜大了：打印“sorry，您猜大了!”
• 猜小了：打印“sorry，您猜小了!”
• 直到数字猜到为止

思路

1.通过Random类中方法nextInt（），生成一个1-100之间的随机数

2.输入猜的数字

3.通过while循环，进行猜数字对错判断

猜对，跳出循环，游戏结束

猜错了，根据结果，给出提示，接着猜数字，游戏继续

如果猜大了，打印sorry，您猜大了!继续下一次循环

如果猜小了，打印sorry，您猜小了!继续下一次循环

实现代码步骤

分析完毕之后，完成代码的编写：GuessNumber.java

import java.util.Random;
import java.util.Scanner;

public class GuessNumber {
    public static void main(String[] args) {
//1.通过Random类中方法nextInt（），生成一个1-100之间的随机数
        int randomNumber = new Random().nextInt(100);
        System.out.println("随机数已生成！");
//2.输入猜的数字
        System.out.println("----请输入您猜的数字：----");
        Scanner sc = new Scanner(System.in);
        int enterNumber = sc.nextInt();
//3.通过while循环，进行猜数字对错判断
//猜对，跳出循环，游戏结束
        while (enterNumber != randomNumber) {
//猜错了，根据结果，给出提示，接着猜数字，游戏继续
            if (enterNumber > randomNumber) {
//如果猜大了，打印sorry，您猜大了!继续下一次循环
                System.out.println("sorry，您猜大了!继续下一次循环");
            } else {
//如果猜小了，打印sorry，您猜小了!继续下一次循环
                System.out.println("sorry，您猜小了!继续下一次循环");
            }
//输入猜的数字
            System.out.println("----请输入您猜的数字：----");
            enterNumber = sc.nextInt();
        }
        System.out.println("恭喜您，答对了！");
    }

}

运行结果：

引用数据类型

引用数据类型分类，提到引用数据类型（类），其实我们对它并不陌生，如使用过的Scanner类、Random类。
我们可以把类的类型为两种：

• 第一种，Java为我们提供好的类，如Scanner类，Random类等，这些已存在的类中包含了很多的方法与属性，可供我们使用。
• 第二种，我们自己创建的类，按照类的定义标准，可以在类中包含多个方法与属性，来供我们使用。

这里我们主要介绍第二种情况的简单使用。

自定义数据类型概述

在Java中，将现实生活中的事物抽象成了代码。这时，我们可以使用自定义的数据类型（类）来描述（映射）现实生活中的事物。
类，它是引用数据类型，与之前学习的所有引用数据类型相同，自定义类也是一种数据类型。只是自定义类型并非Java为我们预先提供好的类型，而是我们自己定义的一种引用数据类型用来描述一个事物。

类的定义与使用

java代码映射成现实事物的过程就是定义类的过程。
我们就拿一部手机进行分析，它能用来做什么呢？它可以打电话，上网，聊微信等，这些就是手机所提供的功能，也就是方法；手机也有它的特征，如颜色、尺寸大小、品牌型号等，这些就是手机的特征，也就是属性。
目前，我们只关注类中的属性，类中的方法在面向对象部分再进行学习。

类的定义格式

创建java文件，与类名相同

public class 类名{
    数据类型 属性名称1；
    数据类型 属性名称2；
    …
}

通过类的定义格式，来进行手机类的描述，如下所示

public class Phone {
    /*
    * 属性
    */
    String brand;// 品牌型号
    String color;// 颜色
    double size; // 尺寸大小
}

上述代码，就是创建一个类的的过程，类的名称我们给起名为Phone，类中包含了三个属性（brand品牌型号、color颜色、size尺寸大小）。注意，类中定义的属性没有个数要求。

类的使用格式

Phone类定义好后，我们就可以使用这个类了，使用方式和使用引用数据类型Scanner类相似。格式如下：

• 导包：我们将所有的类放到同一个文件夹下，可以避免导包;
• 创建对象：数据类型 变量名 = new 数据类型();
• 调用方法：目前我们定义的自定义类不涉及方法，只是属性;
• 访问属性：变量名.属性 (这是当前的方式，后期会采取调用方法的方式替代掉直接访问的方式来完成对属性的访问。)

当有了Phone数据类型的变量后，我们就可以使用Phone类中的属性了。对属性的访问我们来演示一下，如下所示：

package arraylist;

public class Test {
    public static void main(String[] args) {
//定义了一个Phone类型的变量p
        Phone p = new Phone();
/*
* 通过p,使用Phone中的属性
*/
//访问p中的brand品牌属性
        p.brand = "苹果6s";//为p中brand属性赋值为 苹果6s
//访问p中的color颜色属性
        p.color = "白色";//为p中color属性赋值为”白色”
//访问p中的size尺寸大小属性
        p.size = 5.5;//为p中size属性赋值为5.5
        System.out.println("手机品牌为" + p.brand);
        System.out.println("手机颜色为" + p.color);
        System.out.println("手机尺寸大小为" + p.size);
    }
}
//手机品牌为苹果6s
//手机颜色为白色
//手机尺寸大小为5.5

自定义类型注意事项与内存图

上述代码中，通过类Phone创建出来的变量p，它相当于我们生活中的盒子，里面包含了它能够使用的属性。
通过 p.属性名 就可以对属性进行操作
与引用类型数组类似，引用类型的自定义类型的变量，直接变量时，结果为对象地址值，这里可以通过内存图简单解释。

下面再来看看某个类创建两个对象的内存图：

ArrayList集合

在前面我们学习了数组，数组可以保存多个元素，但在某些情况下无法确定到底要保存多少个元素，此时数组将不再适用，因为数组的长度不可变。为了保存这些数目不确定的元素，JDK中提供了一系列特殊的类，这些类可以存储任意类型的元素，并且长度可变，统称为集合。在这里，我们先介绍ArrayList集合，其他集合在后续课程中学习。
ArrayList集合是程序中最常见的一种集合，它属于引用数据类型（类）。在ArrayList内部封装了一个长度可变的数组，当存入的元素超过数组长度时，ArrayList会在内存中分配一个更大的数组来存储这些元素，因此可以将ArrayList集合看作一个长度可变的数组。

集合的创建

创建集合的常用格式在此说明一下：
1、导包：import java.util.ArrayList;
2、创建对象：与其他普通的引用数据类型创建方式完全相同，但是要指定容器中存储的数据类型：
3、ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();

• 集合中存储的元素，只能为<>括号中指定的数据类型元素；
• “<要存储元素的数据类型>”中的数据类型必须是引用数据类型，不能是基本数据类型；

下面给出8种基本数据类型所对应的引用数据类型表示形式:
基本数据类型 对应的引用数据类型表示形式

byte　　——> 　　Byte
short    ——>　　Short
Int　　——>    Integer
long    ——>　　Long
float    ——>　　Float
double    ——>　　Double
char    ——>　　Character
boolean    ——>　　Boolean

我们通过举几个例子，来明确集合的创建方式：

//存储String类型的元素
ArrayList<String> list = new ArrayList<String>();
//存储int类型的数据
ArrayList<Integer> list = new ArrayList<Integer>(); 
//存储Phone类型的数据
ArrayList<Phone> list = new ArrayList<Phone>();

集合中常用方法

接下来，我们来学习下ArrayList集合提供的一些常用方法，如下：

boolean add（Object obj）    //将指定元素obj追加到集合的末尾
Object get（int index）      //返回集合中指定位置上的元素
int size（）    　　　　　　   //返回集合中的元素个数

下面通过代码演示上述方法的使用。ArrayListDemo01.java

package arraylist;
import java.util.ArrayList;
public class ArrayListDemo01 {
    public static void main(String[] args) {
// 创建ArrayList集合
        ArrayList<String> list = new ArrayList<String>();
// 向集合中添加元素
        list.add("stu1");
        list.add("stu2");
        list.add("stu3");
        list.add("stu4");
// 获取集合中元素的个数
        System.out.println("集合的长度：" + list.size());
// 取出并打印指定位置的元素
        System.out.println("第1个元素是：" + list.get(0));
        System.out.println("第2个元素是：" + list.get(1));
        System.out.println("第3个元素是：" + list.get(2));
        System.out.println("第4个元素是：" + list.get(3));
    }
}
//集合的长度：4
//第1个元素是：stu1
//第2个元素是：stu2
//第3个元素是：stu3
//第4个元素是：stu4

强调一点，ArrayList集合相当于是一个长度可变的数组，所以访问集合中的元素也是采用索引方式访问，第一个元素存储在索引0的位置，第二个元素存储在索引1的位置，依次类推。

集合的遍历

通过集合遍历，得到集合中每个元素，这是集合中最常见的操作。集合的遍历与数组的遍历很像，都是通过索引的方式，集合遍历方式如下：ArrayListDemo02.java

package arraylist;
import java.util.ArrayList;
public class ArrayListDemo02 {
    public static void main(String[] args) {
        //创建ArrayList集合
        ArrayList<Integer> list = new ArrayList<Integer>();
        //添加元素到集合
        list.add(13);
        list.add(15);
        list.add(22);
        list.add(29);
        //遍历集合
        for (int i = 0; i < list.size(); i++) {//[获取集合中元素的个数]
            //通过索引，获取到集合中每个元素
            int n = list.get(i);//[获取集合中指定位置上的元素值];
            System.out.println(n);
        }
    }
}
//13
//15
//22
//29

上述代码中，定义了一个可以存储int元素的集合；接着实现将int类型数值存储到集合中；接着实现遍历集合元素。这里要强调一点，get方法返回值的类型为集合中元素的类型。

集合中的常用方法补充

ArrayList集合提供的一些常用方法，如下：

boolean add（int index, Object obj）      //将指定元素obj插入到集合中指定的位置
Object remove（int index）    　　　　　 　//从集合中删除指定index处的元素，返回该元素
void clear（）    　　　　　　　　　　　　   //清空集合中所有元素
Object set（int index, Object obj）      //用指定元素obj替代集合中指定位置上的元素

ASCII编码表

ASCII编码表， 英文全称 American Standard Code for Information Interchange，美国标准信息交换代码。

ASCII编码表由来

计算机中，所有的数据在存储和运算时都要使用二进制数表示
a、b、c、d这样的52个字母（包括大写）、以及0、1等数字还有一些常用的符号, 在计算机中存储时也要使用二进制数来表示， 具体用哪些二进制数字表示哪个符号，当然每个人都可以约定自己的一套（这就叫编码）。
大家如果要想互相通信而不造成混乱，那么大家就必须使用相同的编码规则，于是美国有关的标准化组织就出台了ASCII编码，统一规定了上述常用符号用哪些二进制数来表示。

中文编码表

• GB2312
• UNICODE

字符中重要的ASCII码对应关系

• a : 97
• A : 65
• 0 : 48

char类型的存储

short:占两个字节,是有符号数据,取值范围-32768-32767，char: 占两个字节,是无符号数据,取值范围0-65536。char类型的数据参加运算时要先转换为int数据类型。

案例代码

package arraylist;

/*
    ASCII编码表演示
    字符Java 数据类型,char
    整数Java 数据类型,int
    
    int 类型和 char 数据类型转换
    char  两个字节, int 四个字节
    
    char转成int类型的时候,类型自动提示,char数据类型,会查询编码表,得到整数
    int转成char类型的时候,强制转换,会查询编码表
    
    char存储汉字,查询Unicode编码表
    
    char可以和int计算,提示为int类型, 内存中两个字节
    char取值范围是0-65535, 无符号的数据类型
*/
public class ASCIIDemo {
    public static void main(String[] args){
        char c = 'a';
        int i = c + 1;
        System.out.println(i);

        int j = 90;
        char h = (char)j;
        System.out.println(h);

        System.out.println( (char)6 );

        char k = '你';
        System.out.println(k);


        //char m = -1;
    }
}
//98
//Z
//
//你