[TOC]

0x00 JAVA开发初识

Q:什么是软件开发？

• 软件：按照特定顺序组织的计算机数据和指令的集合；
• 开发：软件的制作过程
  软件开发：就是借助开发工具和计算机语言来制作软件,比如使用Java编程语言可以完成应用软件的开发。

(1) JAVA 介绍
Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言(Java面向对象程序设计语言和Java平台的总称)，其作者是詹姆斯.高斯林(James Gosling)，他也被誉为是JAVA之父, 他是与SUN公司的Patrick/Naughton/Mike Sheridan等人合作开发的一套语言，最开始叫”Oak”后改名为JAVA;

Java分为三个体系(1999年)：

• J2SE【Java的标准版本】：
  基础,无论是以后走EE还是ME,SE是必须要精通的。
  J2SE是SUN公司为java程序员准备的一套“基础类库”,这套基础类库学习之后,可以完成最基本的操作,例如,文件的读写、线程的控制

• J2EE【Java的企业版本-强大】：
  这是SUN公司为程序员专门准备的一套“类库”,这套类库可以协助程序员完成企业级软件的开发企业级软件：OA办公系统、进销存系统、超市系统

• J2ME【Java的微型版本-很少使用】:
  这是SUN公司为java程序员专门准备的另一套“类库”,这套类库可以协助程序员完成微型设备的嵌入式开发,Java最初就是做微型设备嵌入式开发的。

现代Java的三个体系模块更名(2005年)：
2005年6月,JavaOne大会召开,SUN公司公开Java SE 6,Java的各种版本已经更名以取消其中的数字”2”

• JavaSE(J2SE)(Java2 Platform Standard Edition,java平台标准版)
• JavaEE(J2EE)(Java2 Platform,Enterprise Edition,java平台企业版)
• JavaME(J2ME)(Java2 Platform Micro Edition,java平台微型版)

Java语言特性：

• 开源、免费、纯面向对象。

  • 开源：开发源代码,SUN公司编写的java类库的源代码普通程序员能看到。
  • 免费
  • 面向对象：提供类/接口和继承等面向对象的特性(只支持类之间的单继承,但支持接口之间的多继承(extends),并支持类与接口之间的实现机制(关键字为implements),全面支持动态绑定;

• 简单性：

  • 与C语言和C++语言很接近很容易学习和使用
  • 丢弃了C++中(操作符重载、多继承、自动的强制类型转换)
  • 特别地Java语言不使用指针,而是引用)并提供了自动的废料收集,使得程序员不必为内存管理而担忧。

• 健壮性：

  • Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证(丢弃指针pointer),Java的安全检查机制使得Java更具健壮性。

• 动态的
  -设计目标之一是适应于动态变化的环境。Java程序需要的类能够动态地被载入到运行环境,也可以通过网络来载入所需要的类。这也有利于软件的升级,另外Java中的类有一个运行时刻的表示,能进行运行时刻的类型检查。

• 分布式的

  • 支持Internet应用的开发,在基本的Java应用编程接口中有一个网络应用编程接口(java net),它提供了用于网络应用编程的类库,包括URL、URLConnection、Socket、ServerSocket等,JAVARMI(远程方法激活)机制也是开发分布式应用的重要手段

• 安全的

  • 提供了一个安全机制以防恶意代码的攻击,Java对通过网络下载的类具有一个安全防范机制(类ClassLoader),如分配不同的名字空间以防替代本地的同名类、字节代码检查,并提供安全管理机制(类SecurityManager)让Java应用设置安全哨兵。

• 高性能的

  • 与解释型的高级脚本语言相比,Java的确是高性能的。事实上Java的运行速度随着JIT(Just-In-Time)编译器技术的发展越来越接近于C++。

• 体系结构中立

  • Java程序(后缀为java的文件)在Java平台上被编译为体系结构中立的字节码格式(后缀为class的文件),然后可以在实现这个Java平台的任何系统中运行。这种途径适合于异构的网络环境和软件的分发。

• java支持多线程

  • Java语言支持多个线程的同时执行,并提供多线程之间的同步机制(关键字为synchronized)
  • 线程是一种特殊的对象,它必须由Thread类或其子(孙)类来创建；
  • 通常有两种方法来创建线程：其一,使用型构为Thread(Runnable)的构造子将一个实现了Runnable接口的对象包装成一个线程。
  • 其二,从Thread类派生出子类并重写run方法,使用该子类创建的对象即为线程。
  • 值得注意的是Thread类已经实现了Runnable接口,因此任何一个线程均有它的run方法,而run方法中包含了线程所要运行的代码。线程的活动由一组方法来控制。

• java自动垃圾回收机制即GC机制:【java运行过程当中有一个“垃圾回收器”一直在守护者。】

• 跨平台/可移植
  • 跨平台：依靠JVM机制【java程序不和操作系统交互,java程序运行在JVM中,JVM和操作系统交互】
  • Java程序并没有和底层的操作系统直接交互,java程序实际上运行在jvm当中,JVM屏蔽了操作系统之间的差异。不同的操作系统中必须安装不同版本的JVM。
  • 可移植：来源于体系结构中立性,Java严格规定了各个基本数据类型的长度；Java程序在Java平台上被编译为字节码格式,使得可以在java平台上的任何系统种运行;
  • Java系统本身也具有很强的可移植性,Java编译器是用Java实现的,Java的运行环境是用ANSI C实现的。
  • 但是为了达到可移植,必须提前在操作系统中安装JRE,JRE有了之后才会有JVM。

WeiyiGeek.JAVA跨平台

总结：因为有了JVM所以同一个JAVA程序在三个不同的操作系统中都可以执行;这才使JAVA程序具有跨平台性与良好的移植性;

(2) JRE / JDK 介绍
三者之间的关系：JDK 中包含JRE,JRE中包含JVM+类库,简单的说就是JDK开发完成java程序交给JRE去运行;

• JDK【Java开发工具箱| Java Development Kits】-编译工具javac.exe 和 打包工具 jar.exe
• JRE【Java的运行时环境|Java Runtime Environment】
• JVM【Java虚拟机】

Q:为什么JDK中要包含一个JRE呢？
答：开发完程序后,需要运行一下看看效果;

---

0x01 JAVA开发环境

安装环境：Java语言尽量保证系统内存在1G以上,其他工具如下所示：
注意：JDK的版本不同的操作系统需要安装不同版本的JDK

（1）本机安装

JDK -- 开发工具- https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
IDE:Eclispe/VScode -- 开发编辑器 http://www.eclipse.org/downloads/packages/
Java SE Development Kit 8u211


#JDK目录文件说明
PS C:\Program Files (x86)\Java\jdk1.8.0_211> tree 
+---bin  #存储可执行程序（java编译器/java运行工具/jar打包工具/javadoc.exe嗡的生产工具）
+---include #由于JDK是通过C和C++实现的,启动的时候需要引入一些C语言头文件;
+---jre #java运行环境
+---lib #java的library类或库文件是开发工具使用的归档文件
+---src.zip  #放置了JSK核心类的源代码，通过该文件可以查看java基础类的源代码;

#配置环境不多说：
C:\Users\Administrator>ECHO %path%
C:\Program Files (x86)\Common Files\Oracle\Java\javapath;

变量名：JAVA_HOME
变量值：C:\Program Files (x86)\Java\jdk1.8.0_211                    // 要根据自己的实际路径配置

变量名：CLASSPATH #在1.5jdk不怎么重要(可以执行生成的.class)，记录java类运行文件
变量值：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;         //记得前面有个"."

变量名：Path #记录的可执行文件
变量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;


#linux
# Java SE Development Kit 8u211
$tar -zxvf jdk-8u211-linux-x64.tar.gz -C /usr/local/
$vi /etc/profile 

#Java Env
export JAVA_HOME=/usr/local/jdk1.8.0_211/
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar;
export PATH=$PATH:$JAVA_HOME/bin

（2）Cloud Studio 安装JAVA
补充：在 Cloud Studio 中运行 Java 程序对于老手来说,有些时候可能会面临在一台陌生的（配置没有 Java 环境）计算机下临时开发、调试代码。因此这里推荐基于腾讯云主机的在线云端开发工具 Cloud Studio 来快速开始你的 Java 项目。https://studio.coding.net/
step1：访问 Cloud Studio,注册/登录账户。
step2：在右侧的运行环境菜单选择：”PHP + Python + Java 三种语言环境”
step3： 在左侧代码目录中新建 Java 目录进行开发

Tips: 从终端中输入命令可以看出 Cloud Studio 为我们集成了 Ubuntu16.04 + java1.8 的开发环境：

WeiyiGeek.

（3）Eclipse IDE 开发安装
集成开发环境 IDE (Integrated Development Environment):
Eclipse和MyEclipse的区别:

• a:Eclipse是一种可扩展的开放源代码的IDE。
• b:Eclipse的特点描述
  • 免费纯Java语言编写,免安装,扩展性强
• c:MyEclipse
  • 在Eclipse基础上追加的功能性插件对插件收费
  • 在WEB开发中提供强大的系统架构平台

Eclipse汉化(不推荐)
从Eclipse3.5开始，安装目录下就多了一个dropins目录,只要将Eclipse的汉化插件解压后放到到该目录即可。
同理这种方式卸载插件也是特别的方便推荐这种方式

---

0x02 JAVA基础知识

（1）我的第一个JAVA程序
创建文件 HelloWorld.java (文件名与类名尽量是一致), 代码如下：

//注：String args[] 与 String[] args 都可以执行，但推荐使用 String[] args，这样可以避免歧义和误读。
//修饰符  类   类名   （注意要一致）
public class HelloWorld {
    //主方法相当于C中的main函数,入口;
    public static void main(String[] args) {
       System.out.println("Hello World");
    }
}

//采用jdk目录中javac/java进行编译然后执行（下面为了防止乱码在编译成为字节码文件的时候采用utf8编码）    
>javac -encoding UTF-8 HelloWorld.java  ## 该命令用于将 java 源文件编译为 class 字节码文件，会出现一个 HelloWorld.class 的文件
>java HelloWorld   # java 后面跟着的是java文件中的类名(注意：java命令后面不要加.class)
Hello World
Hello World

WeiyiGeek.HelloWorld

Q:什么是类名？
答：答：假设硬盘上有一个文件 Hello.class , 那么类名就叫做 Hello，此时在命令行终端中可以利用java进行直接执行;

完整的Java程序的加载与执行：

• Java开发的整个生命周期，包括两个重要的阶段，分别是：编译阶段和运行阶段且可以在不同的操作系统中完成。
• 编译生成的程序被称为：字节码程序,编译生成的文件是：xxx.class文件

• 程序员在xxx.java文件中编写源代码(存放源代码的文件被称为源文件)，源代码必须符合java的语法，这些源代码就是高级语言。

• 过程：

  1. 编译期：【在windows环境中完成】

     • 安装JDK，配置环境在硬盘的某个位置创建一个xxx.java源文件
     • 打开源文件，在该文件当中编写符合java语法的源程序，然后保存。
     • 使用JDK中自带的javac.exe命令对以上的java源程序进行编译。
       • 编译通过：说明语法没有问题并且在硬盘上生成一个或者多个字节码文件【xxx.class】
       • 编译失败：说明源程序某个位置不符合java语法格式。
       • 编译的语法格式：打开DOS命令窗口，输入：javac 源文件路径
     • 注意：
       • 源文件路径可以是绝对路径，也可以是相对路径。
       • 编译之后，其实java源文件删除不会影响程序的执行。
       • 最好不要将java源文件删除，因为程序最终运行效果不是预期效果的时候，需要重新修改java源代码，然后进行重新编译生成全新的class字节码文件，再重新运行字节码程序。

  2. 运行期：【可以不在windows中完成，可以换一个操作系统，但前提是该操作系统中已经安装java的运行时环境】

     • 打开命令窗口，在命令窗口中使用java.exe命令运行java程序，语法格式：java 类名
     • 以上程序的执行原理：
       • java.exe命令执行会启动：JVM
       • JVM启动之后，马上启动”类加载器-Class Loader”
       • ClassLoader负责去硬盘的“某个位置”上搜索“类名.class”字节码文件。
       • 找不到这个.class文件，一定会出现程序异常现象。
       • 找到了这个.class文件之后将.class文件转换成”二进制”，操作系统可以直接识别二进制，操作系统执行二进制码和底层的硬件平台进行交互。

Java 源程序与编译型运行区别：

WeiyiGeek.源程序与编译型运行区别

（2）JAVA程序书写语法

• java是强类型语言严格区分大小写;
• 大括号要成对书写对齐,左括号前面是有空格;
• 缩进使用tab和四个空格
• 方法与程序块之间加上空行让程序看起来清晰
• 并排语句之间加空格,例如for语句,运算符两侧加空格
• 主方法入口所有的Java 程序由public static void main(String []args) 方法开始执行

（3）代码注释
注释概述：用于解释说明程序文字,提高程序阅读性,进行排错的功能,注意多行注释不能进行嵌套注释;

//空白行，或者有注释的行，Java编译器都会忽略掉。
- 单行注释：//注释
- 多行注释：/* 注释 */
- 文档注释：/** 注释 **/

(4) 关键字与标识符
关键字概述：

• 被JAVA语言赋予特定含义的单词,组成关键字字母全不小写;
• 注意事项goto和const作为保留字存在,目前并不使用;

标识符概述：

• 给类/接口/方法/变量等起名字使用的字符序列;
• 组成规则：英文字母大小写/ 数字/ $ 和 _ 字符;
• 注意事项：与其他语言一样不能使用数字开头,不能使用关键字,且变量名区分大小写;

案例：

合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123abc、-salary

- 包package: 就是文件夹用于解决相同类名问,要求全部小写,一般是域名倒起写
  com.java.www

- 类或者接口：驼峰命名
  一个单词：Demo
  多个单词：DemoStudy

- 方法与变量：
  一个单词：demo
  多个单词：demoStudy

- 常量：(通常大写)
  一个单词：MAX
  多个单词：MAX_VALUE

---

0x03 JAVA语言学习

(1) 常量

// Constant 常量案例
class Demo_Constant {
    public static void main(String[] args) {
        /***
         * 字符串常量：使用双引号括起来的内容例如 "abc"
         * 整数常量：例如 123
         * 小数常量：例如 12.3
         * 字符常量：例如 'a' 'b' 'c'
         * 布尔常量：例如 true / false
         * 空常量：null (数组部分)
         */
        final int DC = 1314520;  //使用 final 关键字来修饰常量，声明方式和变量类似
        System.out.println("abc");  //字符串常量
        System.out.println(123);   //整形常量
        System.out.println(12.3);  //小数常量
        System.out.println('a');  //字符常量
        System.out.println(' ');  //空格常量
        System.out.print(true);   //布尔常量
    }
}

//######## 执行结果 #######
// abc
// 123
// 12.3
// a
 
// true

(2) 进制概述
进制的由来概述：

WeiyiGeek.进制由来

1. 常用进制转换的计算：
   123 = 100 + 20 + 3 = 1 10^2 + 2 10^1 + 3 10^0 (系数 基数 ^ 权) 相加即可

• 系数：每一位上的数据
• 基数：X进制,基数就是X
• 权：从又右到左从0开始编号,对应位上编号即为该位的权

2. 处积倒取余:
   123 % 10 = 3
   12 % 10 = 2
   1 % 10 = 1

3. 8421码及其特点：

• 8421码事BCD代码中最常用得一种;
• 这种编码方式中每一位二进制代码的1都是代表一个固定数值,把每一位1代表的十进制数加起来,所得的结果就是十进制数;

4. 原码反码补码
   Q:为什么要学原码反码补码？
   答：由于后面学习数据类型时候需要进行强制类型转换;

• 原码：二进制定点表示法,即最高位为符号位 0 表示正, 1 表示负,其余位表示数值大小; 比如 0 000 0111 = 7 | 1 000 0111 = -7
• 反码：正数的反码与其原码相同, 负数的反码时对其原码逐位取反(符号位除外)
• 补码：正数的补码与其原码相同, 负数的补码是在其反码的末尾加1

  0 0000111 +7 正数原码(反码/补码)
  -----------------------------
  1 0000111 -7 负数原码
  1 1111000 -7 负数反码
  1 1111001 -7 负数补码
  -----------------------------
  0 0000111 +7 正数反补 (相加为0)
  1 1111001 -7 负数补码 (运算的时候都是用补码)

进制案例：

//进制转换案例
class Demo_Scale {
    public static void main(String[] args) {
        //进制输出表示形式
        System.out.println(0b100);   //二进制  4
        System.out.println(0100);    //八进制  64
        System.out.println(100);    //十进制  
        System.out.println(0x100);   //十六进制 256

        //byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。
        //使用常量的时候，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制
        int decimal = 100;   //一下输出都是100
        int octal = 0144;
        int hexa =  0x64;
        
        //原码/反码/补码
        /* 
        1.已知原码求补码
        * 0b1 011 0100  原码
        * 0b1 100 1011  反码
        * 0b1 100 1100  补码 = 反码 + 1

        2.已知补码求原码
          0b1 110 1110  补码
          0b1 110 1101  反码 = 补码 - 1
          0b1 001 0010  原码  
        */
    }
}

(3) 变量与数据类型
Q:什么是变量？为什么要定义变量？
答：在程序执行过程中,在某个范围内其值可以发生改变的值; 用来不断存放同一类型的常量,并可以重复使用;
变量的定义格式：数据类型 变量名 = 变量名 比如：int count = 102

Java中主要有如下几种类型的变量:

• 局部变量
• 类变量（静态变量）
• 成员变量（非静态变量）

使用变量得注意事项：

• 作用域问题：同一个区域不能使用相同得变量名
• 初始化问题：局部变量在使用之前必须赋值(import)
• 一个语句可以定义几个变量：int a,b,c….;

Q:什么是JAVA基本数据类型？
答：变量就是申请内存来存储值,也就是说当创建变量的时候，需要在内存中申请空间。
内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。

WeiyiGeek.数据类型

Q:为什么有数据类型？
答：JAVA语言是强类型语言,对于每一种数据都定义了明确的具体数据类型,在内存中分配了不同大小的内存空间;因此通过定义不同类型的变量，可以在内存中储存整数、小数或者字符。

JAVA数据类型分类：

• 基本数据类型

  

  WeiyiGeek.数据类型

• 引用数据类型(面向对象部分)
• 实际上JAVA中还存在另外一种基本类型void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。

案例1：

//数据类型与变量 案例
class Demo_DataType {
    public static void main(String[] args) {
/**
byte：类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
Short ：数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
int：一般地整型变量默认为 int 类型；
long：这种类型主要使用在需要比较大整数的系统上
float：在储存大型浮点数组的时候可节省内存空间，浮点数不能用来表示精确的值，如货币；
double：浮点数的默认类型为double类型， double类型同样不能表示精确的值，如货币；
boolean： 这种类型只作为一种标志来记录 true/false 情况；
char： 数据类型可以储存任何字符；
**/
        //整数类型
        byte b = 10;   //1Byte
        short s = 20;  //2Byte
        int  i = 30;   //4Byte
        long x = 40;   //8Byte 有时候还需要加入一个L字符表示long类型
        long x1 = 888888888888L; //在long类型后也可使用l但是不建议使用小写的l  (注意点)

        //浮点数
        float f = 12.36F;  //4Byte 如果是小数要为float类型需要在小数后加F (主要点)
        double d = 33.67;  //8Byte 小数默认的数据类型是Double; 也可以加上d/D 表示()

        //字符类型
        char c = 'a';   //2Byte (注意java字符类型占用两个字节)
        System.out.println(c);

        //布尔类型
        boolean b1 = true;  //没有明确得规定占用几个字节 （注意点）
        boolean b2 = false;
        System.out.println(b1);

        //变量问题 
        //1.使用前必须赋值
        int x2,y,z;
        x2 = 1;
        y = 2;
        z = 3;
        System.out.println(x2); //1

        //Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的"E+数字"表示E之前的数字要乘以10的多少次方。
        //比如3.14E3就是3.14 × 103 =3140，3.14E-3 就是 3.14 x 10-3 =0.00314。
    }
}

JAVA类型得取值范围：

// 数据类型 长度
class Demo_DataTypeLength {
    public static void main(String[] args) {
        //数据类型的长度
        // byte  
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);  
        System.out.println("包装类：java.lang.Byte");  
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);  
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE+"\n");
        
        //short
        System.out.println("基本类型：short 二进制位数" + Short.SIZE);
        System.out.println("包装类：java.lang.Short");  
        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);  
        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE+"\n");
        
         //int  
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);  
        System.out.println("包装类：java.lang.Integer");  
        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);  
        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);  
        System.out.println();  
  
        // long  
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);  
        System.out.println("包装类：java.lang.Long");  
        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);  
        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);  
        System.out.println();  
  
        // float  
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);  
        System.out.println("包装类：java.lang.Float");  
        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);  
        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);  
        System.out.println();  
  
        // double  
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);  
        System.out.println("包装类：java.lang.Double");  
        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);  
        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);  
        System.out.println();  
  
        // char  
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);  
        System.out.println("包装类：java.lang.Character");  
        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台  
        System.out.println("最小值：Character.MIN_VALUE=" + (int) Character.MIN_VALUE);  
        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台  
        System.out.println("最大值：Character.MAX_VALUE=" + (int) Character.MAX_VALUE);  
    }
}

//################### 执行结果 ##################
// 基本类型：byte 二进制位数：8
// 包装类：java.lang.Byte
// 最小值：Byte.MIN_VALUE=-128
// 最大值：Byte.MAX_VALUE=127

// 基本类型：short 二进制位数16
// 包装类：java.lang.Short
// 最小值：Short.MIN_VALUE=-32768
// 最大值：Short.MAX_VALUE=32767

// 基本类型：int 二进制位数：32
// 包装类：java.lang.Integer
// 最小值：Integer.MIN_VALUE=-2147483648
// 最大值：Integer.MAX_VALUE=2147483647

// 基本类型：long 二进制位数：64
// 包装类：java.lang.Long
// 最小值：Long.MIN_VALUE=-9223372036854775808
// 最大值：Long.MAX_VALUE=9223372036854775807

// 基本类型：float 二进制位数：32
// 包装类：java.lang.Float
// 最小值：Float.MIN_VALUE=1.4E-45
// 最大值：Float.MAX_VALUE=3.4028235E38

// 基本类型：double 二进制位数：64
// 包装类：java.lang.Double
// 最小值：Double.MIN_VALUE=4.9E-324
// 最大值：Double.MAX_VALUE=1.7976931348623157E308

// 基本类型：char 二进制位数：16
// 包装类：java.lang.Character
// 最小值：Character.MIN_VALUE=0
// 最大值：Character.MAX_VALUE=65535

WeiyiGeek.类型取值范围

(4) 数据类型转换学习
自动类型转换:
整型、实型（常量）、字符型数据可以混合运算;运算中不同类型的数据先转化为同一类型然后进行运算,转换从低级到高级。

低  ------------------------------------>  高
byte,short,char—> int —> long—> float —> double    //需要注意 long 与 float之间的转换

Q：什么可以将long强制转换到float？
long 8 个字节 / float 4 个字节

通过IEEE 754 标准：float代表了32个二进制位
1 位表达符号位,8 位表达指数位, 23 位代表尾数位
0000000 - 11111111
0       - 255   //0代表0，而255代表的是无穷大
1       - 254   //除去 0 和 255
-126    - 127   //每个指数减去127 该范围超过了long的范围 (所以float 比 float大)

//结论：flaot表示的数据范围比long的范围要大;
long : 2^63 - 1
float : 3.4*10^38 > 2*10^38 > 2*8^38 = 2*2^3^38 = 2*2^114 > 2^63-1

两种类型转换机制：

• 强制类型转换

  1. 条件是转换的数据类型必须是兼容的。
  2. 格式：(type)value type是要强制类型转换后的数据类型

• 隐含强制类型转换

  1. 整数的默认类型是 int。
  2. 浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或者 f。
  3. 必须满足转换前的数据类型的位数要低于转换后的数据类型，例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。

案例：

// 数据类型转换案例
class Demo_DataTypeConversion {
    public static void main(String[] args) {
        //1.隐式转换
        byte b = 3;
        int i = 4;
        i += b; // 这里的b将自动转换成为int类型(注意点)
        System.out.println(i); //7

        //2.强制转换
        byte b1 = 3;
        int i1 = 4;
        b1 = (byte)(i1 + b1);
        System.out.println(b1); //7

        //3.如果值不该该类型得取值范围内（向下强转）将会损失精度
        /***
         * 0000000 00000000 00000000 10000010 = 130二进制
         * 经过byte强制类型转换(去掉前面的3个字节)
         * 10000010  = -126的补码
         * 10000001 = -126的反码
         * 11111110 = -126的原码
         */
        byte b2 = (byte)(126 + 4); 
        System.out.println(b2); //-126

        //4.面试题
        /***
         * 1) byte与byte(或short,char)进行运算的时候会提升为int,两个类型相加的结果也是int类型
         * 2) bt1与bt2是两个变量,变量妞的值是变化的,在编译的时候无法判断里面具体的值,有可能会超出 byte的取值
         **/
        byte bt1 = 3;
        byte bt2 = 4;
        //byte bt3 = bt1 + bt2;  //输入bt3会进行报错
        

        //5.对比面试题
        byte bt4 = 3 + 4; //java编译器有常量的优化机制 (且固定在byte类型范围内)
        System.out.println(bt4);  //7


        //6.long与float转换
        float f1 = 12.34f;
        long l1 = 123456;
        float f2 = l1; //隐型转换 
        long l2 = (long)f1;    //强制转换 
        System.out.println(f2);  //123456.0
        System.out.println(l2);  //12


        //实际案例1:
        char charword = 'A';     //ASCII 65 
        int ch = charword + 1;   // 隐形转换
        System.out.println(ch);  // 65 + 1 = 66
        System.out.println("\'A\'+1 = "+ charword + 1);   //字符串+整形 或者 字符 == 自动转换成字符串形式
        
        //实际案例2:
        ch = 97;
        char chr = (char)ch;  //将整形转换成为字符类型
        System.out.println((char)48+ch);  //自动转换成为整形进行相加
        System.out.print(chr+"\n");
    
        //实际案例3:
        System.out.println((int)12.2132f);  //强制转换 (小数直接虐去)
        System.out.println((float)12);
        System.out.println((double)ch);
    }
}

//######### 执行结果 ######
// 66
// 'A'+1 = A1
// 145
// a
// 12
// 12.0
// 97.0

数据类型转换必须满足如下规则：

1. 不能对boolean类型进行类型转换。
2. 不能把对象类型转换成不相关类的对象。
3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
4. 转换过程中可能导致溢出或损失精度；
5. 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如上面的float转成long类型7

(5) 字符char类型/字符串参与运算
Q:JAVA语言中char可以用来存储中文汉字编码码？为什么？
答：可以因为JAVA采用的Unicode编码,该编码中的每个字符占用两个字节(中文也是两个字节),所以可以存储一个中文汉字;

案例：

// char 数据类型 与 字符和字符串参与运算
class Demo_CharString {
    public static void main(String[] args) {
      //1. 字符串参与运算
      System.out.println('a' + 1); // 'a' 转换成ascii码 = 97 + 1 => 98
      System.out.println('a' + 1 + "K-BiuBiu");  //在有字符串参与中被称为字符串连接符  98K-BiuBiu
      System.out.println("5+5="+5+5);   // 5+5=55
      System.out.println("5+5="+(5+5));  //对比上方 5+5=10

      //2. char类型
      char c1 = 97; //取值范围0-65535
      char c2 = 65;
      System.out.println(c1);  //a
      System.out.println(c2);  //A
      //Char类型是可以存储中文，在JAVA中字符都是占用2个字节（中文也是）
      char c3 = '中';
      System.out.println(c3); //中
      //支持unicode编码
      char a = '\u0001';  //字符串常量和字符常量都可以包含任何Unicode字符
      String a = "\u0001";
      System.out.println("\u6182");   //憂
    }
}

(6) 数字与字符串转换
描述：数字转换成为字符串与字符串转换成为数字进行案例

import java.math.BigDecimal;

class Demo_String {
    public static void main(String[] args) {
        /**
         * 1.数字类型转换成字符串型
         * 2.字符串型转换成各种数字类型
         * 3.扩展大数类型与字符串之间的转换 import java.math.BigDecimal;
         */

        //方法1：整形 -> 字符串
        double num1 = 1234.1234567;
        String snum1 = String.valueOf(num1);
        System.out.println("(1)整型 num1 采用string转换 成为字符串：" + snum1);
        System.out.println("(2)整型 num1 输出 成为字符串：" + num1);

        
        //方法2：字符 -> 整形(强制)
        String s = "64"; 
        byte b = Byte.parseByte( s );       //byte 类型
        short t = Short.parseShort( s );    //short 类型
        int i = Integer.parseInt( s );      //int 类型
        long l = Long.parseLong( s );       //Long int 类型
        Float f = Float.parseFloat( s );    //float 类型
        Double d = Double.parseDouble( s ); //double 类型
        System.out.println("(3)字符串 s = " + s);
        System.out.println(b + " - " + t + " - " + i + " - " + l + " - " + f + " - " + d);


        //方法3：大数类型与字符串之间的转换扩展
        String doubleStr = "44444.55555";
        BigDecimal bignum = new BigDecimal(doubleStr); //String类型转成bigdecimal类型生成bignum对象
        String str = bignum.toString();                //实现bigdecimal类型转成String类型：
        BigDecimal bd = bignum.setScale(2, BigDecimal.ROUND_HALF_UP);   //设置小数位数，第一个变量是小数位数，第二个变量是取舍方法(四舍五入) 
        System.out.println("str 的大数据类型值是： " + str + "  提取str的小数点后两位的值：" + bd);   //str 的值是： 44444.55555   //44444.56
    }
}

---

0x04 JAVA运算符基本用法

Q:什么是运算符？
答：就是对常量和变量进行操作的符号;

运算符的分类：

- 算术运算符 ：+ - * / % ++ --
- 赋值运算符 ：= += -= *= /= %= 
- 比较(关系或条件)运算符: == != > < >= <= 
- 逻辑运算符 ：&& & | ! ^ 
- 位运算符 ：& | ^ ~ >> << >>>
- 三目运算符 ：
- 字符串连接运算符 : +

算术运算符号的注意事项：

WeiyiGeek.

案例：

// 运算操作符 （使用）
class Demo_OperationalCharacter {
    public static void main(String[] args) {
        /**#算法运算符*/
        //0. 整数与小数相除
        System.out.println( 10 / 3.0); //3.3333333333333335

        //1. % 符号
        System.out.println(-3 % 5);  //左边|-3| < |5| 则返回 -3
        System.out.println(-3 % 3); //左右两边绝对值一样返回 0
        System.out.println(-13 % 3); //余数操作至和左边值有关，-1 （正就是正/负就是负）
        System.out.println(13 % 3);  //余数操作至和左边值有关 1

        //2. 自加/自减
        int a = 0;
        System.out.println(a++);  //0 先赋值在++
        System.out.println(++a);  //2 先++再赋值
        //第二题
        int x = 1;
        int y = (x++)+(++x)+(x*10); //1 + 3 + 30
        System.out.println(y);      //34

        //3. 面试题（那一句话回报错）
        byte b = 10;
        b++; //默认在底层进行转换 b = (char)(b+1) 所以不会报错
        //b = b + 1;  //会产生错误需要进行强制类型转换由于byte和int计算，通过隐型需要将byte转换为int
        System.out.println(b); //11


        /*#赋值运算符 ：把右边的常量值赋值给左边的变量,左边必须是变量;*/
        //4.面试题：
        //short s = 1;s = s + 1; //当short与int进行运算时候，会将提升为int类型返回两个int相加后的结果
        short s = 1;s += 1; //不会报错 底层进行自动转换处理 s = (short)(s+1) 
        System.out.println(s); //2


        /*#关系运算符 */
        System.out.println(4 == 3); //false


        /*#逻辑运算符  
         5.&& 与 & 的区别：
            1）效果一样 
            2)&&类似于C有短路求值效果; 左边false，则右边不执行； 
         6.|| 与 |的区别：
            1）效果一样
            2）||也存在短路求值效率；左边为true，则右边不执行；
        */
        int a1 = 10;
        int b1 = 20;
        int c1 = 30;
        System.out.println(a1 > b1 ^ b1 < c1); //true（ ^ 逻辑异或 （true|false）则为真 ,其他都为假）
        System.out.println(a1 < b1 ^ b1 < c1); //false  (true|true) 则为假
        //7.a1 先赋值在++ 这时 a1 = 10 != 3 为假,由于短路求值的原因 ++b1是不被执行的；(结果还是false| a/b 返回 11，20)
        System.out.println((a1++ == 3) && (++b1 == 4));  
        //6.a1 先++在赋值 这时 a1 = 12 == 12 为真，由于短路求值的原因 b1++是不被执行的；（结果为true | a/b返回 12，20）
        System.out.println((++a1 == 12) || (b1++ == 4));  
        System.out.println(a1); //11
        System.out.println(b1); //20
        
        
        /*#为运算符 : 
            ~ ：按位取反 3 = -（3+1）
            << : 向左移动最高位丢弃，右边填0补齐（左移，向左移动几位就是乘以2的几次幂）
            >>> : 无符号右移动，无论最高位是0还是1，左边补齐0
         */  
        System.out.println(6 & 3); // 0110 
                                   // 0011 = 0010 = 2
        System.out.println(6 | 3); // 0111 = 7 
        System.out.println(6 ^ 3); // 0101 = 5
        //7.按位取反
        // 0000 0011 3的原码/反码/补码
        // 1111 1100 对3按位取反
        // 0000 0001  
        // 1111 1011 反码 = 补码 - 1
        // 1000 0100 原码
        System.out.println(~3);  // -4
        //8.^位异或运算符的特定：一个数据对另一个数据位异或两次，该数不变(常常使用在对称加密中)
        System.out.println(5 ^ 10 ^ 5); // 10
        //利用：交换两个数且只有两个变量 (还有一种 x = x + y的方法有弊端可能会超过int取值类型范围)
        int change1 = 5;
        int change2 = 6;
        change1 ^= change2;  // 5 ^ 6 
        change2 ^= change1;  // 6 ^ 5 ^ 6 = 5 
        change1 ^= change2;  // 5 ^ 6 ^ 5 = 6
        System.out.println(change1); //6
        System.out.println(change2); //5

        //9. << 与 >>> 移位运算 (运算效率最高，对二进制位进行操作)
        System.out.println(12 << 1); // 12 * (2 ^ 1) =  24
        System.out.println(24 >> 2); // 24 / (2 ^ 2) = 6
        System.out.println(24 >>> 2); // 6 无符号移动
        System.out.println(-24 >>> 2); // 1073741818 无符号移动
        // 10000000 00000000 00000000 00011000 = -24 （原码）
        // 00100000 00000000 00000000 00000110 > 向右移动2位  （最高位可以不管了）
        // 00011111 11111111 11111111 11111001 > 反码
        // 00011111 11111111 11111111 11111010 > 补码 = 1073741818


        /***
         * #三元运算符
         * (关系表达式)？表达式1 ： 表达式2
         */
        int three = (change1 > change2)? 1:0;
        System.out.println(three); //1
        //获取三个值里面的最大值
        int max = (a1 > b1) ? a1:b1; 
        max = (max > c1) ? max:c1;
        System.out.println(max);  //30
    }
}

0x05 总结补充

Eclipse IDE 使用流程

1.Eclipse中如何生成jar包并导入到项目中
jar是什么?

• jar是多个class文件的压缩包。

jar有什么用?

• 用别人写好的东西,可以看做类似于Python中的模块包的功能,可以导入后使用里面的方法或者类;

如何打jar包?

• 选中项目–右键–Export–Java–Jar–自己指定一个路径和一个名称–Finish

  

  WeiyiGeek.

如何导入jar包？

• 复制到项目路径的lib目录中下并添加至构建路径(add build path 构建后会在Refenrence Libraries之中),如果想移出也是相同操作只不过最后选择是remove build library;

  

  WeiyiGeek.

如果导入项目到工作空间?

• 在项目区域右键找到import找到General，展开并找到Existing Projects into Workspace点击next然后选择你要导入的项目路径(需要注意不能项目重名);
• 注意：这里选择的是项目名称

2.Eclipse中断点调试的基本使用
描述: 程序调试是每一门编程语言必备的,它用来调试程序查看程序执行流程以及错误处理;
Debug的作用: 调试程序以及查看程序执行流程
什么是断点：就是一个标记，从哪里开始。

如何设置断点？

• 你想看哪里的程序，你就在那个有效程序的左边双击即可。

如何运行设置断点后的程序?

• 右键 – Debug as – Java Application (或者点击小虫子也是可以的)

运行调试后将切换视图到Debug界面,下面是我们需要关注的地方:

• Debug：断点测试的地方在F6或者点击也可以,一次看一行的执行过程。
• Variables：查看程序的变量变化
• ForDemo：被查看的源文件
• Console：控制台

如何去断点？

• a:再次双击即可找到Debug视图Variables界面找到Breakpoints，并点击然后看到所有的断点，最后点击那个双叉。

WeiyiGeek.