[TOC]

0x00 JAVA开发初识

Q:什么是软件开发?

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

(1) JAVA 介绍
詹姆斯.高斯林(James Gosling) JAVA之父,与SUN公司的Patrick/Naughton/Mike Sheridan等人合作开发的一套语言叫”Oak”,后改名JAVA;
Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言(Java面向对象程序设计语言和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开始编号,对应位上编号即为该位的权
  1. 处积倒取余:
    123 % 10 = 3
    12 % 10 = 2
    1 % 10 = 1

  2. 8421码及其特点:

  • 8421码事BCD代码中最常用得一种;
  • 这种编码方式中每一位二进制代码的1都是代表一个固定数值,把每一位1代表的十进制数加起来,所得的结果就是十进制数;
  1. 原码反码补码
    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");
44
//实际案例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.