1，Java语言前世今生

    1.1，Java语言简介

        1.1.1，Java是由Sun Microsystems公司于1995年5月23日推出的Java面向对象程序设计语言和Java平台的总称。

        1.1.2，20世纪90年代，硬件领域出现了单片式计算机系统，这种价格低廉的系统一出现就引起了人们的注意，因为使用它能大幅度提升消费类电子产品（如电视机顶盒，面包烤箱，移动电话等）的智能化程度。
                Sun公司为了抢占先机，在1991年成立了Green计划，由James Gosling和同事们在加利福尼亚州门洛帕克市沙丘路的一个小工作室里共同开发新技术，专攻计算机在家电产品上的嵌入式应用，并最终诞生了Java。
        1.1.3，Java语言分为三个版本：
                - Java标准版J2SE（Java 2 Platform，Standard Edition）定位在客户端，主要用于桌面应用软件的编程。
                - Java企业版J2EE（Java 2 Platform，Enterprise Edition）主要用于分布式的网络程序的开发。
                - Java微型版J2ME（Java 2 Platform，Micro Edition）主要用于嵌入式系统的开发。

        1.1.4，Java语言的应用

                - 全场景。

    1.2，Java语言特性

        1.2.1，Java语言是简单易用的

                - 相对于C语言的指针，Java使用了引用。
                - 相对于C++的内存管理，Java迎刃而解。
                - Java提供了垃圾回收器。

        1.2.2，Java语言是面向对象的

                - Java语言提供了类，接口和继承等面向对象的特征。
                - 为了简单，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implements）。
                - Java语言是一个纯面向对象设计语言。

        1.2.3，Java语言是健壮的

                - 定义变量首先要声明其类型
                - 异常处理机制（异常机制可以使程序中异常处理代码和正常业务代码分离；保证程序代码更加优雅，并提高程序的健壮性）
                - 垃圾回收机制（自动回收分配给对象的内存）

        1.2.4，Java语言是多线程的

                - 在音乐app中听音乐同时可以欣赏歌词，支持多个线程的同时执行提供多线程之间的同步机制。

        1.2.5，Java语言是多态的

                - Java可以动态地被载入到运行环境，框架底层都是基于反射。

    1.3，Java语言跨平台和分布式

        1.3.1，Java跨平台

                - 将Java源程序进行一次编译，就可以在装了JVM的机器上运行。
                - Java是跨平台的，但是JVM不是跨平台的。

        1.3.2，Java分布式

                - Java是为Internet分布式环境而设计。
                - 通过URL访问网络资源和访问本地文件是一样的。
                - Java支持远程方法调用RMI（Remote Method Invocation）。

2，Java开发环境的搭建

    2.1，JDK,JRE,JVM的简介和关系

        2.1.1，JDK

                - Java SE Development Kit（Java标准开发包）。
                - 安装目录下的bin文件夹存放Java指令，jre文件夹存放Java运行环境，lib存放类库，src.zip存放源码。

        2.1.2，JRE

                - Java Runtime Environment（Java运行环境）。
                - 安装目录下的bin文件夹存放jvm，lib文件夹存放jvm需要的类。

        2.1.3，JVM

                - Java Virtual Machine（Java虚拟机，是JRE的一部分）
                - jvm.dll就是Java虚拟机

        2.1.4，三者的关系

    2.2，JDK安装

        2.2.1，打开Oracle官网
        2.2.2，选择JDK版本
        2.2.3，选择系统版本
        2.2.4，下载JDK安装包

    2.3，环境变量配置和验证

        2.3.1，右击计算机 -> 点击属性 -> 点击高级系统配置 -> 点击环境变量 -> 进入环境变量配置窗口
        2.3.2，在系统变量里新建系统变量，名为JAVA_HOME，对应JDK的安装目录。
        2.3.3，在系统变量里找到path，点击编辑，在path值后面加上分号（如果以分号结尾就不需要再加分号），再加上"%JAVA_HOME%\bin"，配置好点击确定。
        2.3.4，按win+r键打开运行窗口，输入cmd，在命令行直接输入"java -version"检查是否配置成功，如果成功就会出现版本信息。

    2.4，编写，编译，运行第一个Java程序

        2.4.1，编写Java程序

                - 在Java程序开发中最基础的单元就是类，所有的程序必须封装在类中执行。
                - "public class 类名称{}"：类名称必须与文件名称保持一致，一个*.java文件只允许有一个public class定义。
                - Java语言有着明确的命名要求，以后定义类名称的时候要求每一个单词首字母大写，例如：HelloWorld。
                - "public class void main(String[] args)"：是主方法，主方法是所有程序执行的起点，并且一定要定义在类中。
                - 屏幕打印（系统输出）有两种语法形式，输出后换行：System.out.println()，输出后不换行：System.out.print()。

public class Demo1
{
    public static void main(String[] args)
    {
        System.out.println("Hello World");
    }
}

        2.4.2，编译Java程序

                - 编译指令是javac，c就是compile（编译）的首字母。
                - Java文件只是源码文件，还不能执行，必须将它转换成字节码文件，也就是.class文件才能够执行。这个转换的过程就是编译。

        2.4.3，运行Java程序

                - 在cmd中输入"java HelloWorld"就可以执行Java程序。
                - 关键字：public，释义：公开
                - 关键字：class，释义：类
                - 关键字：static，释义：静态
                - 关键字：void，释义：方法返回值类型
                - 关键字：main，释义：方法名，严格定义
                - 关键字：String，释义：字符串
                - 关键字：[]，释义：数组
                - 关键字：args，释义：参数名

3，Java编码规范

    3.1，标识符和关键字

        3.1.1，类、接口、方法、变量等起名字是使用的字符序列

                - 名称：类，变量，方法，接口，枚举，注解。
                - 标识符规则：1，字母、数字、下划线（_），$组成。2，不能使用数字开头。3，不能使用Java关键字。4，区分大小写。

        3.1.2，类、接口命名规则

                - 单个单词：首字母大写，其余小写（小驼峰命名），例如：Hello。
                - 多个单词：每个单词的首字母都大写，其余单词小写（大驼峰命名），例如：HelloWorld。

        3.1.3，变量、方法命名规则

                - 单个单词：字母全部小写，例如：check()。
                - 多个单词：首字母小写，后面每个单词首字母大写，例如：checkUserName()。

        3.1.4，常量命名规则

                - 单个单词：字母全部大写，例如：NUMBER。
                - 多个单词：字母全部大写，中间使用下划线隔开，例如：MAX_VALUE。

        3.1.5，关键字

                - 访问控制：private，protected，default（默认），public。
                - 类、接口、方法、变量、代码块修饰符：class，abstract，extends，implements，interface，final，strictfp，static，synchronized，transient，volatile，native，enum。
                - 程序控制：for，break，continue，do，while，if，else，switch，case，default，instanceof，return，assert。
                - 错误处理：try，catch，finally，throw，throws。
                - 基本类型：boolean，byte，char，short，int，long，float，double。
                - 变量引用：new，super，this，void，null，true，false。
                - 包相关：import，package。
                - 保留字：goto，const。

    3.2，类注释，多行注释和单行注释

        3.2.1，Java注释的本质

                - 编译器在进行程序编译时如果发现有注释的内容将不对此部分进行编译处理。
                - 书写注释是一个非常好的习惯。

        3.2.2，Java三种注释

                - 单行注释：//（单行注释可以嵌套）
                - 多行注释：/*...*/（多行注释不可以嵌套）
                - 文档注释：/**...*/（文档注释javadoc生成的文档）

    3.3，IntelliJ IDEA工具和配置

        3.3.1，在JetBrains官网下载idea社区版进行安装

        3.3.2，新建项目

                - 然后点击Next，Finish，就完成了项目的创建。

        3.3.3，常规设置

                - 点击 File -> Setting -> Editor -> File Encoding，设置字符集编码。
                - 点击 File -> Setting -> Editor -> Font，设置自己喜欢的字体。

    3.4，华为Java编程军规简介

        3.4.1，注释

                - 源程序注释量必须在30%以上。注释的内容要清楚，明了，含义准确。

        3.4.2，排版规则

                - 程序块采用缩进风格编写，缩进的空格数为4个，不允许使用Tab缩进。
                - 分界符（如大括号'{'和'}'）应各独占一行，同时与引用它们的语句左对齐。
                - 较长的语句、表达式或参数（大于80字符）要分成多行书写。
                - 不允许把多个短语句写在一行中，即一行只写一条语句。
                - if、for、do、while、case、switch、default等语句自占一行。
                - if、for、do、while、case、switch、default等语句的执行语句部分无论多少都要加括号{}。

        3.4.3，命名规则

                - 类名和接口使用类意义完整的英文描述，每个英文单词的首字母使用大写、其余字母使用小写的大小写混合法。
                - 方法名使用类意义完整的英文描述：第一个单词的字母使用小写、剩余单词首字母大写其余字母小写的大小写混合法。
                - 属性名使用意义完整的英文描述：第一个单词的字母使用小写，剩余单词首字母大写其余字母小写的大小写混合法。
                - 常量名使用全大写的英文描述：英文单词之间用下划线分隔开，并且使用static final修饰。

4，Java数据类型和变量

    4.1，变量

        4.1.1，变量的概念

                - 变量是程序中存储数据的基本单元，在该存储空间中，存储的数据值可以改变，通过变量名可以简单快速地找到它存储的数据。

        4.1.2，变量的使用步骤

                - 第一步：声明变量，即根据数据类型在内存申请空间
                        数据类型 变量名;
                        int age;
                - 第二步：赋值，即将数据存储至对应的内存空间
                        变量名=数值;
                        age=20;
                - 第一步和第二步可以合并
                        数据类型 变量名=数值;
                        int age=20;
                - 第三步：使用变量，即取出数据使用

        4.1.3，什么是标识符？

                - 用来标识类名、变量名、方法名、类型名、数组名、文件名的有效字符序列称为标识符。简单的说，标识符就是一个名字。

        4.1.4，标识符命名规范

                - 标识符由字母、数字、下划线（_）和美元符号（$）组成，并且第一个字符不能是数字。
                - 标识符不能是Java关键字和保留字，但可以包含其内。
                - 标识符区分大小写，遵循驼峰命名规范。
                - 标识符命名要简单明了，见名知意。

        4.1.5，下面哪些变量名是合法的？

                - principal，$lastname，123rate，discount%，marks_3，zip_code。

        4.1.6，局部变量和全局变量（Java有3种类型的变量）

                - 全局变量：类的属性，也叫成员变量或实例变量。
                - 局部变量：某个方法或代码块中临时定义的变量。
                - 静态变量：被static修饰的变量，整个类的成员共享的变量。

        4.1.7，变量的作用域

                - 不同类型变量的作用域和生命周期不同。

public class Demo2
{
    int var1 = 1; //var1 为全局变量
    static int var2 = 2; //var2 为静态变量

    public int add()
    {
        int var3 = var1 + var2; //var3 为局部变量
        for (int i = 0; i < 5; i++) // i 为局部变量
        {
            System.out.println(i);
        }
        return var3;
    }
}

    4.2，整型

        4.2.1，为什么Java需要不同的数据类型？

                - Java中的数据类似于衣服、鞋子、裤子，需要分类存放。
                - Java的数据类型分为基本数据类型和引用数据类型两大类。

        4.2.2，8种基本数据类型

                - 整型：byte，short，int，long。
                - 浮点型：float，double。
                - 字符型：char。
                - 布尔型：boolean。

        4.2.3，整数类型

    4.3，浮点型

        4.3.1，浮点数默认为double型，float型的数值有一个后缀"f"

                例如：float a = 123.45f;
                        double b = 123.45;

    4.4，布尔类型

        4.4.1，boolean类型只有两个值：false和true，用于判定逻辑条件。

    4.5，字符型

        4.5.1，编码的概念

                - 计算机内部使用二进制数，一个字符在计算机中是以0和1构成的序列形式来存储的。将字符映射到它的二进制形式的过程称为编码（encoding）。字符有多种不同的编码方式，编码表（encoding scheme）定义该如何编码每个字符。
                - 大多数计算机采用ASCII码，Unicode码包括ASCII码，Java支持Unicode码。

        4.5.2，ASCII码

                - American Standard Code for Information Interchange：美国信息交换标准代码。
                - ASCII码使用指定的7位或8位二进制数组合来表示128或256种可能的字符。标准ASCII码叫做基础ASCII码，使用7位二进制数（剩下的1位二进制为0）来表示所有的大写和小写字母，数字0到9，标点符号已经在美式英语中使用的特殊字符。
                - ASCII是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言。它是最通用的信息交换标准，并等同于国际标准ISO/IEC 646。

        4.5.3，Unicode码

                - Unicode：统一码，也叫万国码、单一码（Unicode）是计算机科学领域的一项业界标准，包括字符集、编码方案等。
                - Unicode是为了解决传统的字符编码方案的局限而产生的，它早起被设计为16位的字符编码，能产生65536个字符。
                - Unicode后期被拓展为1112064个字符，称为补充字符，Java支持这些补充字符。

        4.5.4，字符类型

                - char：存放由单引号引起的单个字符，占2个字节，取值范围：[0,65535]。

        4.5.5，数据类型转换

                - 自动类型转换：把一个表示数据范围小的数据或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的，直接书写即可。例如：double num = 10;
                - 强制类型转换：把一个表示数据范围大的数值或者变量赋值给数据范围小的变量。
                - 强制类型转换格式：目标数据类型 变量名 = (目标数据类型)值或者变量。

    4.6，引用类型

        4.6.1，Java中的引用类型

                - 引用类型：在C和C++里通过指针操作内存中的元素，在Java中是通过"引用"。在Java中一切视为对象，但我们操作的标识符实际上是对象的一个引用。
                - 引用数据类型有：数组，接口，类。

        4.6.2，String字符串类型

                - Java将有多个字符组成的字符序列成为字符串。
                - 字符串类型由String关键字表示，其所表示的若干个字符序列必须包含于英文双引号内。例如："华为加油！"，"I LOVE YOU"。

5，Java运算符

    5.1，运算符分类

        5.1.1，运算符简介

                - 运算符：对常量或者变量进行操作的符号。
                - 表达式：表达式是运算符与操作数的组合，其中操作数可以是常量、变量或其他表达式。不同运算符连接的表达式体现的是不同类型的表达式。

        5.1.2，运算符的分类

                - 按功能分类：赋值运算符，算术运算符，关系运算符，逻辑运算符。
                - 按操作数的个数分类：单目运算符，双目运算符，三目运算符。

    5.2，赋值运算符

        5.2.1，语法：变量名 = 表达式;

                - 赋值运算符"="的作用是将右边的值赋给左边的变量
                    int age = 20; //将20赋给变量age
                - 赋值运算符具有自右向左的结合性
                    int a,b,c; //同时声明三个变量
                    a=b=c=1; //自右向左赋值

    5.3，算术运算符

        5.3.1，Java中提供了算术运算符来实现数学上的算术运算功能

                - 运算符：+；说明：加法运算符，求操作数的和；举例：5+2=7。
                - 运算符：-；说明：减法运算符，求操作数的差；举例：5-2=3。
                - 运算符：*；说明：乘法运算符，求操作数的乘积；举例：5*2=10。
                - 运算符：/；说明：除法运算符，求操着数的商；举例：5/2=2;5.0/2=2.5。
                - 运算符：%；说明：取余（模）运算符，求操作数相除的余数；举例：5%2=1。
                - 参与除法运算的两个操作数都是整数时，表示整数除法，否则表示浮点除法。

        5.3.2，复合运算符

                - Java中有些表达式可以通过复合运算符进行简化。
                - 复合赋值运算符由赋值运算符和算术运算符组合形成，用于对变量自身执行算术运算。例如：a=a+2可以简化为a+=2。
                - 运算符：+=；说明：加法运算；举例：int a=8; a+=2等同于a=a+2; a=10
                - 运算符：-=；说明：减法运算；举例：int a=8; a-=2等同于a=a-2; a=6
                - 运算符：*=；说明：乘法运算；举例：int a=8; a*=2等同于a=a*2; a=16
                - 运算符：/=；说明：除法运算；举例：int a=8; a/=2等同于a=a/2; a=4
                - 运算符：%=；说明：模运算；举例：int a=8; a%=2等同于a=a%2; a=0
                - 当需要对变量自身进行计算时，建议使用复合赋值运算符，效率会远高于算术运算符。
                - 复合赋值运算符的结合性是从左到右。例如：int a=6; a+=a+=6; //等效于a=a+(a+6)
                - Java表达式中使用圆括号与代数中的圆括号作用相同，能增强运算符的优先级，使用圆括号还能够增强程序的可读性并使计算顺序清晰。

        5.3.3，自增自减运算符

                - 语法：++变量名 或 变量名++；--变量名 或 变量名--。
                - 如果将自增或自减运算符放在变量之前，称为前缀运算，前缀运算执行的是"先运算后使用"处理过程。例如：int a=5; int b=++a; //等效于a=a+1; int b=a;
                - 如果将自增或自减运算符放在变量之后，称为后缀运算，后缀运算执行的是"先使用后运算"处理过程。例如：int a=5; int b=a++; //等效于int b=a; a=a=1；

    5.4，关系型运算符

        5.4.1，Java提供了关系运算符，用于进行比较运算，运算结果为boolean类型。

                - 运算符：>；说明：大于。
                - 运算符：<；说明：小于。
                - 运算符：>=；说明：大于等于。
                - 运算符：<=；说明：小于等于。
                - 运算符：==；说明：等于。
                - 运算符：!=；说明：不等于。

    5.5，逻辑运算符

        5.5.1，逻辑运算符也叫短路运算符，它把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断结果是true或者false。

                - 运算符：&&；说明：与运算，表示连接条件要同时成立。
                - 运算符：||；说明：或运算，表示连接条件有一个成立即可。
                - 运算符：！；说明：非运算，取反。

    5.6，三元运算符

                - 语法：布尔表达式？表达式1：表达式2
                - "?:"是Java中唯一的一个三目运算符。条件表达式的结果由布尔表达式决定，如果布尔表达式值为true，则返回表达式1的值，否则返回表达式2的值。

    5.7，instanceof

        5.7.1，instanceof运算符概念

                - instanceof运算符的前一个操作数通常是一个引用类型变量，后一个操作数通常是一个类，它用于判断运算符前面的引用变量是否是运算符后面的类型，或其子类型的实例。

    5.8，位运算符

        5.8.1，位运算符概念

                - 位运算起源于C语言的低级操作，所谓低级操作，是因为位运算的操作对象是二进制位，但这种低级操作对计算机而言是非常之间直接，友好高效的。
                - 在简单的低成本处理器上，通常位运算比除法快得多，比乘法快几倍，有时候比加法快得多。
                - 运算符：&；说明：与；举例：操作数相同位都为1，那么结果为1。
                - 运算符：|；说明：或；举例：操作数相同位有一位为1，那么结果为1。
                - 运算符：^；说明：异或；举例：操作数相同位不相同，结果为1。
                - 运算符：<<；说明：左移；举例：各二进制位全部左移N位，高位丢弃，低位补0。
                - 运算符：>>；说明：右移；举例：各二进制位全部右移N位，若值为正，则在高位插入0，若值为负，则在高位插入1。
                - 运算符：>>>>；说明：无符号右移；举例：忽略符号位，空位都以0补齐，正数做>>>运算的时候和>>是一样的，区别在于负数运算。

6，Java逻辑流程控制

    6.1，main函数

        6.1.1，main函数和顺序结构

                - Java虚拟机通过main方法找到需要启动的运行程序，并且检查main函数所在类是否被Java虚拟机装载。
                - 如果没有装载，那么就装载该类，并且装载所有相关的其他类。因此程序在运行的时候，第一个执行的方法就是main()方法。

    6.2，if分支语句

        6.2.1，选择结构

                - 选择结构：根据逻辑判断代码的执行顺序

        6.2.2，if分支语句

                - 满足判断条件，则执行相对应的代码，否则不执行任何代码。

        6.2.3，if-else条件分支语句

        6.2.4，if-else多级嵌套

    6.3，switch分支

        6.3.1，switch-case语句

    6.4，for，while循环

        6.4.1，循环结构

        6.4.2，while循环语句

        6.4.3，do-while循环语句

        6.4.4，for循环语句

    6.5，循环控制

        6.5.1，break语句

                - 除了可以用于switch语句中，还可以用于循环体中。
                - 在循环体中遇见break语句时，立即结束循环，跳至循环外，执行循环结构后面的语句。

        6.5.2，continue语句

                - 用于结束本次循环，即在循环体中遇见continue语句，循环体中continue语句后面的语句不会执行，接着进行下一次循环的判定。

public class Demo3
{
    public static void main(String[] args)
    {
        int sum = 0;
        for (int i = 1; i <= 100; i++)
        {
            if (i == 10)
            {
                continue;
            }
            sum += i;
        }
        System.out.println("1+2+...+100=" + sum); //输出结果为：1+2+...+100=5040
    }
}

        6.5.3，return语句

                - Java中return用于方法，两个作用：（1）返回方法指定类型的值（这个类型是确定的），也可以是对象。（2）方法的结束。
                - 两种形式：（1）有返回类型，例如：return i;（2）无返回类型 return;
                - 方法前有void代表无返回值，没有void代表有返回值。

    6.6，嵌套控制

        6.6.1，循环里放循环就构成了嵌套循环，例如九九乘法表

//九九乘法表
public class Demo4
{
    public static void main(String[] args)
    {
        for (int i = 1; i <= 9; i++)
        {
            for (int j = 1; j <= i; j++)
            {
                System.out.print(i + "*" + j + "=" + (i * j)+" ");
            }
            System.out.println();
        }
    }
}