JavaSE
JavaSE是学习JavaWeb、JavaEE以及Android开发的基础
边听边思考边做“笔记”
不要完全依赖书和视频；
捷径：敲、狂敲；
规范：加注释；
难点，不懂的记录下时间再回头看；
在敲代码中学习知识点，加深知识的理解。
1.基础常识
软件开发：
软件，即一系列按照特定顺序组织的计算机数据和指令的集合。分为系统软件和应用软件。
人机交互方式：
图形化界面（Graphical User Interface GUI）这种方式简单直观，使用者易于接受，容易上手操作。
命令行方式（Command Line Interface CLI）:需要有一个控制台，输入特定的指令，让计算机完成一些操作。需要记住一些命令。
常用的DOS命令
dir：列出当前目录下的文件以及文件夹
mid：创建目录
rd：删除目录
cd：进入特定目录
cd..：退回到上一级目录
cd\：退回到根目录
del：删除文件
exit：退出dos命令
echo javase >1.doc
C:\Users\Administrator>d: D:\>directory
'directory' 不是内部或外部命令，也不是可运行的程序
或批处理文件。 D:\>dir
驱动器 D 中的卷没有标签。
卷的序列号是 0004-E52B
D:\ 的目录
2018/11/04 22:47 <DIR> 140415
2018/11/04 19:22 <DIR> BaiduYunDownload
2018/07/21 15:31 <DIR> centos7
2018/11/05 10:26 <DIR> code
2018/06/08 20:39 <DIR> Git
2017/11/28 11:34 <DIR> photoshop_cs6_33lc
2018/11/05 10:55 <DIR> Program Files
2018/09/26 20:58 <DIR> Program Files (x86)
2018/05/12 08:44 <DIR> WebStorm 2018.1.3
2018/08/03 22:06 <DIR> WeChat
2017/01/11 22:56 510,835,180 文件.rar2018/07/21 15:33 <DIR> 虚拟机
1 个文件 510,835,180 字节
12 个目录 113,653,895,168 可用字节 D:\>md 1130 #创建文件夹 D:\>cd 1130 #切换到这个文件目录下 D:\1130>md team1 #创建文件 D:\1130>md team2 D:\1130>cd.. #退出1层目录 D:\>cd 1130/team1 #进入多层目录 D:\1130\team1>cd.. D:\1130>cd/ #退出到根目录 D:\>cd 1130\team1 D:\1130\team1>echo name:kris sex:male > 1.txt #创建文件并写入内容 D:\1130\team1>echo >1.doc D:\1130\team1>cd.. D:\1130>rd team2 #删除目录 D:\1130>rd team1
目录不是空的。 D:\1130>cd team1 D:\1130\team1>del 1.doc #删除文件 D:\1130\team1>del *.doc
找不到 D:\1130\team1\*.doc D:\1130\team1>cd.. D:\1130>del team1
D:\1130\team1\*, 是否确认(Y/N)? y D:\1130>rd team1 D:\1130>
计算机语言：
语言：人与人沟通的一种方式。中国人要和英国人交流就要学习英语。（更多的是一种形象思维）
计算机语言：人与计算机交流的方式。人与计算机交流就要学计算机语言，如C、C++、java、php等。
2.Java语言概述
C语言主要用来写操作系统，也可写应用软件，但超过十万行代码的用的就比较少了，它对异常处理机制、错误处理做的不好；它不是面向对象的，虽然有很好的运行效率
； C++具有一些面向对象的特性，社区的回复性也很高，但它不是跨平台的；
Java是跨平台的；C#跨平台性、面向对象都有，它是微软搞出来的。
重量型（C、java、objective--C、C++、C#）注重运行效率，功能性；、轻量型级别（PHP、python、JavaScript、Visual Basic .NET）讲究开发的效率，可移植性、跨平台性较差。
java语言的主要特性：
特点一：面向对象
两个基本概念：类、对象
三大特性：封装、继承、多态
提供类、接口和继承等原语，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implement）。
特点二：分布式
支持Interner应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocker等。Java的RMI（远程方法激活）机制也是开发分布式应用的重要手段。
特点三：健壮性
吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分（如指针、内存的申请与释放等），提供了一个相对安全的内存管理和访问机制。
强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。
特点四：跨平台性
跨平台性：通过java语言编写的应用程序在不同的系统平台上都可以运行。“ Write once , Run Anywhere ”；
原理只要在需要运行java应用程序的操作系统上，先安装一个Java虚拟机（JVM Java Virtual Machine）即可。由JVM来负责程序在该系统中的运行。
JAVA程序 -- win版JVM（windows操作系统）、linux版的JVM（Linux操作系统）、Mac版的JVM（Mac操作系统）
因为有了JVM，同一个Java程序在三个不同的操作系统中都可以执行。这样就实现了Java程序的跨平台性。
Java技术体系平台
Java SE(Java Standard Edition)Java标准版
支持面向桌面级应用（如Windows下的应用程序）的Java平台，提供了完整的Java核心API，此版本以前称为J2SE
Java EE(Java Enterprise Edition)Java企业版
是为开发企业环境下的应用程序提供的一套解决方案。该技术体系中包含的技术如:Servlet 、Jsp等，主要针对于Web应用程序开发。
Java ME(Java Micro Edition)Java小型版
支持Java程序运行在移动终端（手机、PDA）上的平台，对Java API有所精简，并加入了针对移动终端的支持，此版本以前称为J2ME
Java Card
支持一些Java小程序（Applets）运行在小内存设备（如智能卡）上的平台
JVM、JRE、JDK的介绍
JDK（Java Development Kit Java开发工具包） JDK = JRE + 开发工具包
JDK是提供给开发人员使用的，包含了Java的开发工具（编译工具（javac.exe）打包工具（jar.exe）等），也包括了JRE。
JRE（Java Runtime Environment Java运行环境） JRE = JVM + JavaSE标准类库
包括Java虚拟机（JVM Java Virtual Machine）和Java程序所需的核心类库等，如果想运行一个开发好的java程序，只需安装JRE即可。
简单而言，使用JDK的开发工具完成的java程序，交给JRE去运行。
JVM Java Virtual Machine java虚拟机
JDK是包含JRE的，JRE java运行式环境，仅仅是用来运行，它里边包含Java虚拟机以及所需的主要库；
include是示例，jre整个运行式环境，bin涉及一些命令；命令对应的代码在lib里边；bin可执行文件（javac编译、java运行）
配置环境变量，就是可以在任何目录下运行；
Java应用程序的开发
D:\code\day01>javac HelloWorld.java //编译之后就会出现HelloWorld.class的文件 D:\code\day01>java HelloWorld //类名
Hello Java!
编译 .java文件--->.class文件 JVM
解释 JVM ->机器
public class HelloJava{
/*
1.源文件以.java结尾；
2.源文件中可以有多个class声明的类；
3.类中可以有主方法（即main()方法，其格式是固定的：public static void main (String[] args){}
4.main()方法是程序的入口，方法内是程序的执行部分；
5.一个源文件中只能有一个声明为public的类，同时要求此类的类名与源文件名一致。
6.每个语句都以";"结束
7.执行程序:编译:javac.exe ,编译完生成诸多个.class字节码文件；运行:java.exe
*/
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
class Person{
}
class Hello{
}
注释：
提高代码的阅读性，调试程序的重要方法。有单行注释、多行注释（不能嵌套）、文档注释（java特有）。将自己的思想通过注释先整理出来，再用代码去体现。（良好的编程习惯）
文档注释（java特有）
格式：
/**
*@author 指定java程序的作者
*@version 指定源文件的版本
*@param 方法的参数说明信息。
*/
注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档。
操作方式：
D:\code\day01>javadoc -d mydoc -author -version HelloJava.java
D:\code\day01>javadoc -d mydoc -author -version HelloJava.java
正在加载源文件HelloJava.java...
正在构造 Javadoc 信息...
正在创建目标目录: "mydoc\"
标准 Doclet 版本 1.8.0_192
正在构建所有程序包和类的树...
正在生成mydoc\HelloJava.html...
正在生成mydoc\package-frame.html...
正在生成mydoc\package-summary.html...
正在生成mydoc\package-tree.html...
正在生成mydoc\constant-values.html...
正在构建所有程序包和类的索引...
正在生成mydoc\overview-tree.html...
正在生成mydoc\index-all.html...
正在生成mydoc\deprecated-list.html...
正在构建所有类的索引...
正在生成mydoc\allclasses-frame.html...
正在生成mydoc\allclasses-noframe.html...
正在生成mydoc\index.html...
正在生成mydoc\help-doc.html... D:\code\day01>
API
源码：
D:\Program Files\Java\jdk1.8.0_192\src.zip 在这个压缩包里边，把它的代码给抽取出来就是我们看到的API，类--下面的一些方法；
文档中英文结合地看；
3.基本语法
关键字、标识符、变量（基本数据类型和基本数据类型转换）、运算符、程序流程控制、数组
3.1 关键字、保留字
定义：被java语言赋予了特殊含义，用做专门用途的字符串（单词）； 特点：关键字中所有字母都是小写；
用于定义数据类型的关键字：
class、interface、enum、byte、short、int、long、float、double、char、boolean、void
用于定义数据类型值的关键字：
true、false、null
用于定义流程控制的关键字：
if、else、switch、case、default、while、do、for、break、continue、return
用于定义访问权限修饰符的关键字：
private、protected、public
用于定义类，函数，变量修饰符的关键字：
abstract、final、static、synchronized
用于定义类与类之间关系的关键字：extends、implements；
用于定义建立实例及引用实例，判断实例的关键字：new、this、super、instanceof
用于异常处理的关键字：try、catch、finally、throw、throws
用于包的关键字：package、import
其他修饰符关键字：native、strictfp、transient、volatile、assert
java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标记符时要避免使用这些保留字。
byValue、cast、future、generic、inner、operator、outer、rest、var、goto、const
3.2 标识符
Java对各种变量、方法和类等要素命名时使用的字符串系列成为标识符。 凡是自己可以起名字的地方都叫标识符。
定义它的规则：
①由26个英文字母大小写，0--9，_或$组成；②数字不可以开头；
③不可以使用关键字和保留字，但能包含关键字和保留字；
④ Java中严格区分大小写，长度无限制。
⑤中间不能有空格
标识符的命名规范：
1、见名知意
2、类名、接口名：每一个单词的首字母大写，形式：XxxYyyZzz
3、变量名、方法名：从第二个单词开始，首字母大写，形式：xxxYyyZzz
例如：main, getName, age, myAge
4、包名：所有单词都小写，单词之间使用.分割，形式：xxx.yyy.zzz
例如：java.util，java.sql，java.lang，java.net
5、常量名：所有单词都大写，单词之间使用_分割，形式：XXX_YYY_ZZZ
例如：PI，MAX_VALUE，MAX_PRIORITY
53个关键字、保留字、特殊值：都是小写。
3.3 变量
变量：存储值、访问值； 用一个固定的名字，代表一个会变的值。
变量：本质上代表内存中的一块存储区域（该区域有自己的名称（变量名）和类型（数据类型）），这块存储区域中的值是可变的。
变量有三个要素：
（1）数据类型 比喻房间的类型，单人间，双人间，总统套房
（2）变量名 比喻房间号，302,312
（3）变量值 比喻房间中的人，张三，李四
如何声明一个变量？
数据类型 变量名; //占用名称，并且确定类型
变量的使用有要求：
（1）先声明后使用
如果一个变量没有声明：
TestVariable.java:27: 错误: 找不到符号
（2）在使用之前，必须先初始化
使用：包括计算、打印值
（3）变量有作用域
A：同一个作用域中，变量不能重复声明，可以重复赋值
B：出了作用域，变量就无法访问了
作用域：从声明处开始，到它所属的{ }结束
该区域的数据可以在同一类型范围内不断变化；
定义变量的格式：数据类型 变量名 = 初始化值；
变量的分类（按数据类型分）
对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。
① 整数类型：byte、short、int、long
Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
整型常量默认为 int 型，声明long型常量须加 ‘ l ’ 或 ‘ L ’
②浮点类型
浮点型：
float：单精度浮点型,占4个字节
大概科学记数法的表示方式，小数点后6~7位，前6位是精确的。
double：双精度浮点型,占4个字节
大概科学记数法的表示方式，小数点后15~16位，前15位是精确的。
③字符类型：char
char：字符类型，Java是存储每一个字符的Unicode编码值，2个字节
世界上所有的字符、标点符号都会有一个唯一的Unicode编码值。
A： B：
a：97 b：
： ：
尚：(十进制) Unicode的数字值占个字节，但是在网络中传输、文件中保存实际占几个字节，要看编码方式：GBK，每一个汉字都是2个字节UTF-，每一个汉字基本上是3个字节，也有特殊的。
char字符的表示方式：
（）'a','男',';' 字符常量是用单引号（‘ ’）括起来的单个字符，涵盖世界上书面语的字符， 例如：char c1 = 'a'；char c2 = '中'；char c3 = '9'；
（）'\n','\t','\b' 转义字符。Java中还运行使用转义字符 ‘ \ ’来将其后的字符转变为特殊字符型常量。例如：char c3 = ' \n '； // '\n'表示换行符。
（）'\u5c1a' 十六进制。直接使用Unicode值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数，如：\u000a 表示\n。 char类型是可以进行运算的。因为它都对应有Unicode码。
转义字符 \b 退格键
\n 换行符
\r 回车符
\t 制表符
\" 双引号
\' 单引号
\\ 反斜杠
④布尔类型：boolean 逻辑值
适于逻辑运算，一般用于流程控制：
if条件语句； while循环控制语句； do-while循环控制语句； for循环控制语句；
boolean 类型数据只允许取值true和false，无null；不可以0或非0的整数替代false和true，这点和C语言不同。
引用数据类型：
类、：例如：String,System，Object，Math，File,Date,Scanner.....
接口：Runnable、Serializable、Comparable....
数组：int[],String[],char[]....
//变量: 基本数据类型(8个) vs 引用数据类型(类、接口、数组)
//1.java中的变量定义的格式: 数据类型 变量名 = 初始值 class TestVeriable{
public static void main(String[] args) {
//2.变量先定义,后使用
int myInt1 = 10;
double d1 = 12.3; System.out.println(myInt1);
System.out.println(myInt1 + d1);
//i1超出了其作用范围，不可使用。
//System.out.println(i1); //3.整型:byte(-128~+127) short int(默认类型) long
byte b1 = 12;
byte b2 = 127;
short s1 = 128;
int i1 = 12; //定义long型变量，值的末尾加"L"或"l"
long l1 = 12324321L;
System.out.println(l1); //4.浮点型(带小数点的数值):float double(默认类型)
double d11 = 12.3;
//声明float类型的浮点型数据,末尾要加"F"或者"f"
float f1 = 12.3F;
System.out.println(f1);
//5.字符型(=两个字节): char 只能表示一个字符(英文、中文，标点符号等)
char c1 = 'a';
//char c2 = 'ab';
String str = "ab";
char c3 = '中';
String str1 = "中国";
//可以表示转义字符
char c4 = '\t';
char c5 = '\n';
System.out.println("abc" + c5 +"def"); char c6 = '\u1234';
System.out.println(c6); //6.布尔类型: boolean 只能够取值true 或 false,不能取值null
boolean bool1 = true;
if(bool1){
System.out.println("你看帅哥!");
}else{
System.out.println("没看到!");
} }
public void method1(){
int i1 = 10;
System.out.println(i1);
}
}
3.4 数据类型的转换
（）自动类型转换
byte,short,char-->int-->long-->float-->double
A：byte与byte,short与short,char与char进行运算，会升级为int
B：byte与short，byte与char等混合运算，也会升级为int
C：所有类型混合运算，会自动升级为参与类型中最大的那个
D：boolean不参与任何类型转换
E：所有类型一旦与String进行“+”拼接，结果都是String （）强制类型转换
double-->float-->long-->int-->byte,short,char
A：把存储范围大的数据类型的值或变量赋值给存储范围小的变量，那么需要强制类型转换，用()，-~32767; 但是强制类型转换有风险，可能会溢出或损失精度。
B：有的时候需要把某个存储范围小的类型，强制转为大的类型，进行运算
int a = ;
int b = ;
System.out.println("a / b = " + (double)a/b);
C：boolean不参与任何类型转换
D：String不参与强制类型转换 short是2个字节，-~
char是2个字节，无符号的整数值，~
/*
变量之间的运算:（不考虑boolean,剩下char(都对应unicode的一个值) byte short int long float double)
1.自动类型转换
2.强制类型转换
*/
class TestVeriable1{
public static void main(String[] args) {
//1.自动类型转换:当容量小的数据类型与容量大的数据类型做运算时,容量小的会自动转换为
//容量大的数据类型:char,byte,short==>int==>long==>float==>double
int i1 = 12; //4个字节
short s1 = 2; //2个字节
int i2 = i1 + s1; //4个字节 float f1 = 12.3F;
float f2 = f1 + i2;
double d1 = f2 + 12.3;//默认12.3为double类型,8个字节,如果用float就错了 long l = 12L; //long l = 12; 默认为int类型,赋值给l也是可以的,int范围比long的小
float f3 = l; //这种形式的也可以.用的是科学计数法 char c1 = 'a';//
c1 = 'A';//
int i3 = c1 + 1;
System.out.println(i3); System.out.println(i2);
System.out.println(f2); //需要主意的:当char\byte\short之间做运算时,默认的结果为int类型
short ss1 = 12;
byte bb1 = 1;
char cc1 = 'a';
//short ss2 = ss1 + bb1; 错误的
int ii1 = ss1 + bb1;
//char cc2 = cc1 + bb1; 错误的
int ii2 = cc1 + bb1;
short ss2 = 11;
//short ss3 = ss1 + ss2 //2.强制类型转换:容量大的转换为容量小的
//强制类型转换的问题:导致精度的损失
long l1 = 12345L;
int m1 = (int)l1;
System.out.println(m1); byte by1 = (byte)m1;
System.out.println(by1); //3. 平时常用的字符串,也是一种数据类型：String
String nation = "我是一个中国人";
System.out.println(nation);
//字符串与数据类型之间的运算:只能是连接运算: + ,得到的结果仍为一个字符串
String str = "abc";
String str1 = str + m1; //abc12345
//String.out.println(str1); 这里为什么说找不到符号?????????????????? m1?? //题目：
String str11 = "Hello";
int myInt1 = 12;
char ch1 = 'a'; //97
System.out.println(str11 + myInt1 + ch1);//Hello12a
System.out.println(myInt1 + ch1 + str11);//109Hello
System.out.println(ch1 + str11 + myInt1);//aHello12
}
}
3.5 二进制与补码反码
计算机的底层所有的数据都是用二进制来存储的。
我们的整数当然也是用二进制存储的。
单位：
bit：位 一个二进制的位，要么是0要么是1，是计算机中最小的存储单位；
byte：字节 一个字节是8位，是计算机最基本的存储单位； 1KB = 1024字节
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
.... 1个字节是8位，存储的范围是多少？ 计算机底层存储数字，用补码存储。
正数的补码和原码、反码一样，就是这个数的二进制值。
例如：25 00011001
负数的补码和原码、反码就不一样
原码：二进制值，最高位是符号位（正数的最高位是0，负数的最高位是1）
-25 原码 100
反码 11100110 最高位不变，其余位取反，0->1,1->0
补码 11100111 反码 + 1 一个字节：-128~127
正数：0000 0001 ~ 0111 1111
1 ~ 127
零： 0000 0000 负数：1000 0001 ~ 1111 1111
-127 ~ -1
特殊值：1000 0000 -128 进制表示：
十进制的数字，就是和平时一样
二进制的数字，在数字前面加0B或0b
八进制的数字，在数字前面加0
十六进的数字，在数字前面加0x或0X 25的二进制是多少？
除2倒取余 二进制->八进制 从右边开始三位一组
二进制->十六进制 从右边开始四位一组 二进制->十进制 对应位数的值 * 2的n次方法，从右边开始n依次是0,1,2，..
八进制->十进制 对应位数的值 * 8的n次方法，从右边开始n依次是0,1,2，..
十六进制->十进制 对应位数的值 * 16的n次方法，从右边开始n依次是0,1,2，.. 自动类型转换： long -->float
8个字节 4个字节
为什么说4个字节的float的存储范围比8个字节的long类型的大
小数在底层如何存储？也是用二进制存储
小数在底层：符号位 + 指数部分 + 尾数部分 和整数的存储不一样，
所以long虽然是8个字节，但是它的存储范围没有float的类型大。 double类型的尾数是52位，float是23位，所以double的精度比float大
因为小数部分转二进制可能是无限的，例如2.2，所以float和double是不精确，是浮点数
十进制的int 1234（4*8，4个字节 32位） --->>二进制的2个字节 给它转换成byte类型，那就会剩下8个了，截断高位的；
进制
对于整数：
二进制：0,1，满2进1.以0b或0B开头；
十进制：0-9，满10进1.
八进制：；0-7，满8进1，以数字0开头。
十六进制：0-9及A-F，满16进1，以0x或0X开头表示。此处A-F不区分大小写。如Ox21AF+1=OX21B0
最高位叫符号位；
正数符号位为0，负数的符号位为1； 在底层都是以补码的形式存的；
十进制转换二进制
4. 运算符（用以表示数据的运算、赋值和比较）
1、算术运算符
2、赋值运算符
3、比较（关系）运算符
4、逻辑运算符
5、条件运算符（三元运算）
6、位运算符 一、算术运算符
加：+
减：-
乘：*
除：/
如果除数和被除数都是整数，那么结果只保留整数部分
取余，取模：%
取模，正负号，只看被除数（被模数） 正号：+
负号：- 字符串拼接：+ Java中对+这个运算符进行重载了，即+有两种意义，一个是加法，一个是字符串拼接
只要字符串参与+，结果一定是字符串，执行的一定是拼接。 自增：++ 自增1
++在前，先自增，后load自增变量的值，然后再做别的
++在后，先load自增变量的值，然后自增，然后再做别的
自减：-- 自减1
//测试算术运算符: + - * / % ++ -- 连接符+
class TestAri{
public static void main(String[] args) {
//除: /
int i = 12;
int j = i/5;
double d = i/5;
double d1 = i/5.0; //int类型除以double类型
System.out.println(j); //
System.out.println(d); //2.0
System.out.println(d1);//2.4
//取模: %:取余数，结果的符号取决于被模数
int i1 = 12 % 5;
int i2 = -12 % 5;
int i3 = 12 % (-5);
int i4 = -12 % (-5);
System.out.println(i1);//
System.out.println(i2);//-2
System.out.println(i3);//
System.out.println(i4);//-2
//前++：先自增1，后做运算;
//后++：先做运算，后自增;
int myInt1 = 10;
int myInt2 = myInt1++; //后++
System.out.println(myInt1); //
System.out.println(myInt2); //
int myInt3 = 10;
int myInt4 = ++myInt3; //前++
System.out.println(myInt3);//
System.out.println(myInt4);//11
//前--：先自减1，后做运算;
//后--：先做运算，后自减;
}
}
二、赋值运算符
最基本的赋值运算符：=
把=右边的（常量值、另一个变量的值、表达式的结果）赋值给左边的变量
注意：右边的（常量值、另一个变量的值、表达式的结果）类型要与左边的变量“一致”或“兼容” 扩展的赋值运算符：强调，扩展的赋值运算符中间不要加空格，即“+ =”错误的，"+="
+=
-=
*=
/=
%=
>>=
.... （1）扩展运算符的右边是作为一个整体运算，然后再最后和左边的变量进行“+=，-=.....”的“+，-...”运算； 支持连续赋值。
（2）如果最后的结果的类型不符合左边的变量了，会发生“强制类型转换”
class Pratice1{
public static void main(String[] args){
short s = 3;
//s = s + 2; //不兼容的类型: 从int转换到short可能会有损失
s += 2;
System.out.println(s);//
}
}
三、比较运算符
比较运算符（又称为关系运算符）
大于：>
小于：<
大于等于：>=
小于等于：<=
不等于：!=
等于：== 比较运算符的表达式的结果只有两种，要么成立true，要么不成立false，
所以比较运算符的表达式通常用作条件。
比较运算符的结果都是boolean型，也就是要么是true，要么是false。
四、逻辑运算符
逻辑与：&
表示两个条件同时成立; 两边都为true时，整个结果才为true；
true & true 结果为true
true & false 结果为false
false & true 结果为false
false & false 结果为false
逻辑或：|
表示两个条件满足其一 两边只要有一个为true时，整个结果才为true；
true | true 结果为true
true | false 结果为true
false | true 结果为true
false | false 结果为false 短路与：&&
表示两个条件同时成立 两个都为true时,整个结果才为true；左边为false时，右边就不用计算了。
true && true 结果为true
true && false 结果为false
false && ? 结果为false
false && ? 结果为false 短路与效率比逻辑与高，因为当&&左边是false时，右边的条件不看 短路或：||
表示两个条件满足其一 只要有1个为true时，整个结果就是true；左边为true时，右边就不用看计算了。
true || ? 结果为true
true || ? 结果为true
false || true 结果为true
false || false 结果为false 短路或效率比逻辑或高，因为当||左边是true时，右边的条件不看
开发中短路与和短路或用的更多
逻辑异或：^
表示两个条件相反为true
true ^ true 结果为false
true ^ false 结果为true
false ^ true 结果为true
false ^ false 结果为false 逻辑非： !
表示条件取反
!true 结果变成false
!false 结果变成true //if(18 <= age < 35)
//18 <= age，比较运算符的结果是boolean
//(2)true < 35 或 false < 35 ，没法比较
左右两端都是布尔类型的
//逻辑运算符 ： & && | || ! ^
class TestLogic{
public static void main(String[] args) {
boolean a = true;
boolean b = false; System.out.println(a & b); //false
System.out.println(a && b);//false
System.out.println(a | b); //true
System.out.println(a || b); //true
System.out.println(a & !b); //true
System.out.println(a^b); //true //& 与 &&的区别: &不管左边是true还是false,右端都会进行运算;
// &&当左端为false时,右端不再进行运算;
// 以后使用时,建议使用&& int i1 = 10;
if(b & (i1++) > 0){
System.out.println("今天天气好暖和啊");
}else{
System.out.println("难得没有雾霾");
}
System.out.println(i1);// int i2 =10;
if(b && (i2++) > 0){
System.out.println("今天天气好暖和啊");
}else{
System.out.println("难得没有雾霾");
}
System.out.println(i2);//10 //| 与 ||的区别: | 当左端为true时,右端照样做运算;
// ||当左端为false时,右端不再进行运算;
// 以后使用时,建议使用|| int i3 = 10;
if(a | (i3++) > 0){
System.out.println("今天天气好暖和啊");
}else{
System.out.println("难得没有雾霾");
}
System.out.println(i3);// int i4 =10;
if(a || (i4++) > 0){
System.out.println("今天天气好暖和啊");
}else{
System.out.println("难得没有雾霾");
}
System.out.println(i4);// }
}
五、位运算符
位运算是直接对二进制进行运算； 注意没有<<<
左右两端都是数值类型的，注意与逻辑& 、| 、^ 的区别
右移，就看你原来的那个数最高位是0还是1，是0的拿0补，是1的拿1补；
位运算符
（1）左移：<<
快速算：左移几位，就相当于乘以2的几次方
本质上：
以2为例，2是int，4个字节，32位
补码：0000 0000 0000 0000 0000 0000 0000
2<<4 0000 0000 0000 0000 0000 0000 0000 以-2为例，-2是int，4个字节，32位; 左移补码补0
原码： 0000 0000 0000 0000 0000 0000
反码：1111 1111 1111 1111 1111 1111 1111 1101 (符号位即最高位不变，其他取相反数)
补码：1111 1111 1111 1111 1111 1111 1111 1110 (补码就是 -->> 反码 + 1)
-2<<4 1111 1111 1111 1111 1111 1111 1110 0000 结果仍然是补码
反码：1111 1111 1111 1111 1111 1111 1101 1111
原码：1000 0000 0000 0000 0000 0000 0010 0000
（2）右移：>>
快速算：右移几位，就相当于除以2的几次方（对于负数有点不太对） 40的补码：0000 0000 0000 0000 0000 0000 0010 1000
40>>4：0000 0000 0000 0000 0000 0000 0000 0010 左边补什么，看最高位
-40的补码：
原码：1000 0000 0000 0000 0000 0000 0010 1000
反码：1111 1111 1111 1111 1111 1111 1101 0111
补码：1111 1111 1111 1111 1111 1111 1101 1000
-40>>4：1111 1111 1111 1111 1111 1111 1111 1101
反码：1111 1111 1111 1111 1111 1111 1111 1100
原码：1000 0000 0000 0000 0000 0000 0000 0011 -3
（3）无符号右移：>>>
和右移的区别就是，无论最高位是什么，左边缺几位，补几个0 -40的补码：
原码：1000 0000 0000 0000 0000 0000 0010 1000
反码：1111 1111 1111 1111 1111 1111 1101 0111
补码：1111 1111 1111 1111 1111 1111 1101 1000
-40>>>4：0000 1111 1111 1111 1111 1111 1111 1101
（4）按位与：&
对应二进制位，按位与
1 & 1 结果为1
1 & 0 结果为0
0 & 1 结果为0
0 & 0 结果为0
（5）按位或：|
对应二进制位，按位或
1 | 1 结果为1
1 | 0 结果为1
0 | 1 结果为1
0 | 0 结果为0
（6）按位异或：^
对应二进制位，按位或 一个整数与另一个整数异或两遍，就是它本身
1 ^ 1 结果为0
1 ^ 0 结果为1
0 ^ 1 结果为1
0 ^ 0 结果为0
如：a = a ^ b
b = a ^ b #b = a ^ b ^ b
a = a ^ b
===>> 这时候就把a，b两个的值交换了。（适用于整数） （7）按位取反：~
每一位取反，1变0，0变1 */
class TestBit{
public static void main(String[] args){
System.out.println(2 << 4);//2 * 2的4次方 ==>> 32 = 2 * 2^4 System.out.println(-2 << 4);//-32 System.out.println(40 >> 4);//2 40 / 2的4次方 = 40/16 = 2
System.out.println(-40 >> 4);//-3 -40 / 2的4次方 = -40 / 16 = -3 System.out.println(-40 >>> 4);// System.out.println(1 & 2);//前面都是0 01 & 前面都是0 10 -->> 0.. 00 输出打印0
System.out.println(1 & 3);//前面都是0 01 & 前面都是0 11 -->> 0.. 01 输出打印1 System.out.println(1 | 2);//前面都是0 01 | 前面都是0 10 -->> 0.. 11 输出打印3
System.out.println(1 | 3);//前面都是0 01 | 前面都是0 11 -->> 0.. 11 输出打印3 System.out.println(1 ^ 2);//前面都是0 01 ^ 前面都是0 10 -->> 0.. 11 输出打印3
System.out.println(1 ^ 3);//前面都是0 01 ^ 前面都是0 11 -->> 0.. 10 输出打印2 System.out.println(~1);
//0000 0000 0000 0000 0000 0000 0000 0001
//1111 1111 1111 1111 1111 1111 1111 1110 补码
//1111 1111 1111 1111 1111 1111 1111 1101
//1000 0000 0000 0000 0000 0000 0000 0010 输出打印为 -2
}
}
class TestExer1 {
public static void main(String[] args) {
int m = 12;
int n = 5;
System.out.println("m:" + m + "n:" + n);
//方法一:提供一个临时变量;
//int temp = m;
// m = n;
// n = temp;
//System.out.println("m:" + m + "n:" + n);
//方法二:当m和n较大时,有可能出现精度损失;
//m = m + n;// m = 12 + 5;
//n = m - n;// m = 17 - 5;
//m = m - n;// m = 17 - 12;
//System.out.println("m:" + m + "n:" + n);
//方法三:优点:没有上面两种方法的缺点
m = m ^ n;
n = m ^ n; //(m ^ n) ^ n == m
m = m ^ n; //(m ^ n) ^ m == n
System.out.println("m:" + m + "n:" + n);
//60 手动的方式,从控制台输出60的十六进制.
int i = 60;
//操作
System.out.prinln();//3c
}
}
//60 手动的方式,从控制台输出60的十六进制.
int i = 60;
//自动调用Integer类现成的方法
String binary = Integer.toBinaryString(i); //变成二进制
System.out.println(binary); //
String hex = Integer.toHexString(i);
System.out.println(hex);//3c /*
char c = 'a';
char c1 = (char)(c + 2);
System.out.println(c1); //c
*/
int j = i & 15; //获取到i的最低4位对应的值。
String k1 = (j <= 9)?j + "" : (char)(j - 10 + 'a') + "";
//System.out.println(k1);//c i = i >> 4;
int z = i & 15;
String k2 = (z <= 9)? z + "" : (char)(z - 10 + 'a') + "";
System.out.println(k2 + k1);
六、条件运算符（唯一的三元运算符）
一元运算符：正号，负号，++，--，逻辑非!
一元运算符是只要一个操作数 +m，!true, i++
二元运算符：加法、减法...
比较运算符
二元运算符有两个操作数： a+b，a-b ,a > b
三元运算符：三个操作数 语法格式：
条件表达式 ? 结果表达式1 ： 结果表达式2
运算规则：
如果条件表达式成立true，整个三元运算符，就取结果表达式1的值，否则就取结果表达式2的值 int max = a>=b ? a : b; int big = (m>=n ? m : n) >= l ? (m>=n ? m : n) : l;
/*
三元运算符:(表达条件式) ? 表达式1 : 表达式2；
要求:表达式1与表达式2为同种数据类型。
既然是运算符，就一定会有运算结果，结果的数据类型与表达式1,2的类型一致。
三元运算符在一定程度上可以与if-else互换(三元运算符一定可以转换为if-else,反之不成立。) */ class TestSanYuan{
public static void main(String[] args) {
int i = 20;
int j = 20;
//此时max记录了i与j的较大值
int max = (i > j)?i : j;
//String str = (i > j) ? "i大" : "j大";
String str = (i > j)? "i大" : (i == j)? "相等" : "j大"; //String str1 = (i > j)? i : "j大";
System.out.println(max);
System.out.println(str); //互换
if(i > j){
System.out.println("较大值为:" + i);
}else{
System.out.println("较大值为:" + j);
} //练习:如何使用三元运算符，输出三个数中的较大值
int m = 12;
int n = 23;
int k = -9;
int max1 = (m > n)? m : n;
int max2 = (max1 > k)? max1 : k;
System.out.println(max2); }
}
