第四章后链接
目录
2.12、基本数据类型和String类型的转换（P58~P59）
一、Java概述
1、快速入门（P17）
编写：
//java的快速入门，演示Java开发步骤
//对代码的相关说明
//1.public class Test 表示Test是一个类，是一个public共有的类
//2.Test{}表示一个类的开始和结束
//3.public static void main(String[] args)表示一个主方法，即我们程序的入口
//4.main(){}表示方法的开始和结束
//5.System.out.println("hello world!"); 表示数出"hello world!"到屏幕
//6. ； 表示语句结束
public class Test{
public static void main(String[] args){//程序的入口
System.out.println("hello world!");
}
}//一个源文件中最多只能有一个 public 类。其它类的个数不限，也可以将 main 方法写在非 public 类中，
//然后指定运行非 public 类，这样入口方法就是非 public 的 main 方法
文件有中文时，在File（文件）中打开Set File Encoding to，点击chinese simplified(GBK) ，点击后保存代码，就哦了。
编译：
在Test.java路径下打开cmd，输入javac Test.java,即可创建Test.class文件
运行：
在Test.class文件路径上，打开cmd输入以下内容，或者win键+r键输入cmd，再输入Test.class的路径后输入以下内容
D:\Sublime_Project>java Test.class//运行时，不要加上文件名后的.class
错误: 找不到或无法加载主类 Test.class
D:\Sublime_Project>java Test
hello world!1.1、运行机制（P18）
1）先编写.java文件（源文件）
2）用javac指令编译，得到对应的.class文件（字节码文件）
3）得到.class文件后，用java指令运行，运行的本质就是将.class文件装载到虚拟机里去执行
什么是编译
1.有了java源文件，通过编译器将其编译成JVM可以识别的字节码文件（.class文件）。
2.在该源文件目录下，通过javac编译工具对Hello.java文件进行编译。
3.如果程序没有错误，就没有任何提示，但会在当前目录下出现一个.class文件，该文件成为字节码文件，也就是可以执行的java的程序。
什么是运行
1.有了可执行的java程序（字节码文件）
2.通过运行工具java.exe对字节码文件进行执行，本质就是.class装载到JVM机执行
java程序开发注意事项！！！
对修改后的.java源文件需要重新编译，生成新的class文件后，再进行执行，才能生效。
2、开发细节（P19）
注意事项：
1.Java源文件以.java为扩展名。源文件的基本组成部分是类(class)，如最上面的Test类。
2.Java应用程序的执行入口时main()方法。他有固定的书写格式：
public static void main(String[] args){...}
3.Java语言严格区分大小写。
4.Java方法由一条条语句构成，每条语句以“;”结束。
5.大括号都是成对出现的，缺一不可。[习惯：先写{}再写代码]
6.一个源文件中最多只能有一个public类。其它类的个数不限。
7.如果源文件包含一个public类，则文件名必须按该类命名！！！
public class Hello{
public static void main(String[] args)
{
System.out.println("我 is studing java!");
}
}
class Dog{//非public类
public static void main(String[] args)
{
System.out.println("Dog运行");
}
}
class Tiger{//非public类
public static void main(String[] args)
{
System.out.println("Tiger运行");
}
}cmd中命令
D:\Sublime_Project>javac Hello.java
D:\Sublime_Project>java Dog
Dog运行
D:\Sublime_Project>java Tiger
Tiger运行
D:\Sublime_Project>java Hello
我 is studing java!3、学习方法（P20）
4、转义字符（P21）
在控制台，输入Tab键，可以实现命令补全
-
java常用的转义字符
-
\t：一个制表位，实现对齐的功能
-
\n：换行符
-
\ \：一个\
-
\ "：一个"\
-
\ '：一个‘
-
\r：一个回车 System.out.println("韩顺平教育\r北京");
-
-
说明
应用实例
-
对齐（ \t ） 和 换行（ \n ）。有中文先设置文件编码----->保存代码----->控制台编译----->输出
public class ChangeChar{
public static void main(String[] args)
{
System.out.println("北京\t上海\n南京");
}
}控制台输出
D:\Sublime_Project>javac ChangeChar.java
D:\Sublime_Project>java ChangeChar
北京 上海
南京2.双引号（"）、斜杆（\）和双斜杠（\ \）
public class ChangeChar{
public static void main(String[] args)
{
System.out.println("\\我在\\\\北京\\\\上海\\\\南京\\");
}
}控制台输出
D:\Sublime_Project>javac ChangeChar.java
D:\Sublime_Project>java ChangeChar
\我在\\北京\\上海\\南京\3.单引号（’）
public class ChangeChar{
public static void main(String[] args)
{
System.out.println("\'我在北京、上海、南京\'");
}
}控制台输出
D:\Sublime_Project>javac ChangeChar.java
D:\Sublime_Project>java ChangeChar
'我在北京、上海、南京'4.一个回车( \ r )
(1)
public class ChangeChar{
public static void main(String[] args)
{
System.out.println("我在北京、上海、南京\r你在");
}
}控制台输出
D:\Sublime_Project>javac ChangeChar.java
D:\Sublime_Project>java ChangeChar
你在北京、上海、南京(2)
public class ChangeChar{
public static void main(String[] args)
{
System.out.println("我在北京、上海、南京\r\n你在");
}
}控制台输出
D:\Sublime_Project>javac ChangeChar.java
D:\Sublime_Project>java ChangeChar
我在北京、上海、南京
你在课堂练习
使用一句输出语句，达到输入如下图形的效果
```java
public class java_Test{
public static void main(String[] args)
{
System.out.println("书名\t作者\t价格\t销量\n三国\t罗贯中\t120\t1000");
}
}
```
控制台输出
```java
D:\Sublime_Project>javac java_Test.java
D:\Sublime_Project>java java_Test
书名 作者 价格 销量
三国 罗贯中 120 1000
```
5、初学Java易犯错误（P22）
1.找不到文件
- 路径错误
- 路径正确，文件名错误
- 全部改正
2.主类名和文件名不一致
会出现java_Tes是公共的
3.缺少分号
报错
4.常见错误总结
学习编程最容易犯的错是语法错误（初学者）。Java要求你必须按照语法规则编写代码。如果你的程序违反了语法规则，例如：忘记了分号、大括号、引号，或者拼错了单词，java编译器都会报语法错误。尝试着去看懂编译器汇报的错误信息。
举例：
-
将1写成字母l
-
将0写成字母o
-
英文符号写成中文符号
输出，”非法字符“一般是字符输入编码不对
-
拼写错误void写成viod
输出，找不到符号一般是单词拼写错误
-
缺少大括号
输出，解析时已到达文件结尾
}
-
不好修改的错误其实是 业务错误、环境错误
6、注释comment（P23~P25）
-
介绍
用于解释程序的文字就是注释，注释提高了代码的阅读性（可读性）；注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，在用代码去体现。
实例：
public class java_Test{
public static void main(String[] args)
{
//下面代码完成两个数相加
//定义变量
int n1 = 20;
int n2 = 30;
//求和
int sum = n1 + n2;
//输出结果
System.out.println("结果：" + sum);
}
}输出：
-
Java中注释的类型
1.单行注释：
格式：//双斜杠后面就是注释内容
2.多行注释
格式：/**/
/*在这里面所有内容都是注释，但是不允许再嵌套一个多行注释 */
-
注释的使用细节
1）.被注释的文字，不会被JVM（java虚拟机）解释执行
2）.多行注释里不允许有多行注释嵌套
3.文档注释：
注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档，一般写在类
-
基本格式：
javadoc -d 保存的文件夹路径 -xx -yy 代码文件名字.java
-
实例
/**
*@author 韩顺平
*@version 1.0
*/
public class Commen01{
public static void main(String[] args)
{
}
}输出：
javadoc标签，截自Java文档注释-JavaDoc标签_李穆的博客-优快云博客
7、Java代码规范（P26）
1.类、方法的注释，要以javadoc的方式来写。
2.非Java Doc的注释，往往是给代码的维护者看的，着重告述读者为什么这样写，如何修改，注意什么问题等
3.使用tab键操作，实现代码缩进。单按tab键整体向右边移动；shift键 + tab键整体向右移动。
4.运算符和 = 两边习惯性各加一个空格。比如：2+4*5+345-89/6 改为-------> 2 + 4 * 5 + 345 - 89 / 6
5.源文件使用utf-8编码
6.行宽度最好不要超过80字符
7.代码编写风格
-
次行风格：大括号在次行写出
-
行尾风格：大括号在行末尾
8、DOS命令（P27）
-
DOS：Disk Operating System 磁盘操作系统。（DOS命令了解）
-
基本原理：
1、md 创建目录命令
在控制台输入md E:\aaa，即在E盘创建名为aaa的文件夹
输入命令后，按下回车，刷新E盘，E盘出现aaa文件夹
2、rd 删除目录命令
在控制台输入rd E:\aaa，即在E盘删除名为aaa的文件夹
输入命令后，按下回车，刷新E盘，E盘中的aaa文件夹就被删除了
8.1、路径详解（P28）
-
图中文件夹和目录是一个意思
-
../表示返回上一级目录
8.2、DOS命令1（P29）
常用的DOS指令（DOS命令的使用非常少）
1、查看当前目录是有什么内容
dir命令
-
格式：dir 后面加上绝对路径，能查看其他路径下的目录
2、切换到其他盘符
格式：cd /D 盘符:
现在在C盘
输入cd /D 盘符: 转入D盘
- 只切换盘符，盘符+:即可
3、切换到当前盘的其他目录下（使用相对路径和绝对路径）
格式：cd 相对路径或绝对路径
4、切换到上一级
格式：cd ../
5、切换到根目录
格式：cd \
8.3、DOS指令2（P30）
6、查看指定的目录下所有的子级目录
格式为下方指令，自己去试吧
指定路径下所有的子级目录
7、清屏命令cls
执行后
8.退出DOS命令
输入完命令，按下回车即可退出
8.4、DOS命令3（P31）
-
了解即可的DOS命令（Linux常用）
-
copy 拷贝文件命令
-
echo 输入内容到文件
-
3.del 删除文件命令
4.move 剪切命令
9.本章作业1（P32）
1、JDK、JRE、JVM的关系
答：JDK = JRE + java开发工具
JRE = JVM + 核心类库
2、环境变量Path配置及其作用
-
环境变量的作用是为了在dos的任意目录中，去使用java 和 javac命令
-
先配置 JAVA_HOME 指向jdk安装的主目录
-
右击此电脑，点击属性
-
点击高级系统设置
-
-
新建用户变量
-
变量名输入JAVA_HOME
-
我这里已经配置好了，点击浏览目录，找到jdk安装目录，选择jdk主目录
-
配置Path，双击Path
-
输入%JAVA_HOME%\bin
-
-
java编写步骤
-
编写java的源代码
-
javac 编译，得到对应的 .class字节码文件
-
java 运行，本质就是把 .class 加载到jvm 运行
-
二、变量
2.1、变量的概念（P36）
-
概念：变量相当于内存中一个数据存储空间的表示，你可以把变量看作是一个房间的门牌号，通过门牌号我们可以找到房间，而通过变量名我们可以访问到变量值。8
-
变量使用的基本步骤
-
声明变量
int a;
-
赋值
a = 10;//将10赋值给a变量
-
也可以一步到位[int a = 10;]，通常都是一步完成的
-
2.2、变量的快速入门（P37）
1、变量使用入门案例
public class var02{
public static void main(String[] args)
{
//记录人的信息
int age = 18;
double score = 100;
char gender = '男';
String name = "靓仔";
System.out.println("个人信息如下：\n");
System.out.println("姓名：" + name);
System.out.println("年龄：" + age);
System.out.println("性别：" + gender);
System.out.println("分数：" + score);
}
}2.3、变量细节（P38）
-
变量使用注意事项
-
变量表示内存中的一个存储区域。不同的变量类型，占用的空间大小不同；比如：int占用4个字节，double占用8个字节。
-
该区域有自己的名称和类型，即变量名和数据类型
-
变量必须先声明，后使用！
-
该区域的数据/值可以在同一类型范围内不断变化
-
变量在同一个作用域内不能重名
-
变量形成格式：数据类型 变量名 = 值;
-
2.4、加号的使用（P39）
-
规则：
-
当 + 左右两边都是数值型时，则做加法运算
-
当 + 左右两边有一方为字符串时，则做拼接运算
-
运算顺序：从左到右
-
-
下面代码输出什么？
System.out.println(100 + 98);//输出198
System.out.println("100" + 98);//输出10098
System.out.println(100 + 3 + "hello");//输出103hello
System.out.println("hello" + 100 + 3);//输出hello10032.5、数据类型（P40）
- 引用数据类型，放到面向对象编程去讲解。
2.5、整型使用（P41）
-
基本介绍
Java的整数类型就是用于存放整数值的，比如12，30，3456等等
-
整数的类型
2.5.1、整型细节（P42）
-
整型的使用细节
-
Java各整数类型有固定的范围和字段长度，不受具体OS（操作系统）的影响，以保证java程序的可移植性。
-
Java的整型常量（具体值）默认为int型，声明long型常量须后加'l'或'L'
-
java程序中变量常声明为int型，除非不足以表示大树，才使用long
-
bit：计算机中的最小存储单位。
-
byte：计算机中基本存储单元
-
2.6、浮点类型（P43~P45）
-
基本介绍
Java的浮点类型可以表示一个小数，比如123.4，7.8，0.12等等
-
浮点数的类型
- 说明：
-
关于浮点数在机器中存放形式的简单说明，浮点数 = 符号位 + 指数位 + 尾数位；
-
尾数部分可能丢失，造成精度损失（小数都是近似值）
- 浮点型使用细节
-
与整数类型相似，Java浮点类型也有固定的范围和字段长度，不受具体OS的影响。
-
Java的浮点型常量（具体值）默认为double型，声明float型常量，需后加'f'或'F'
-
浮点型常量有两种表示形式
-
十进制数形式，如：5.12 512.0f .512（与0.512等价，0可以省略，但是必须有小数点）
-
科学计数法形式，如：5.12e2[5.12*10的2次方]，5.12E-2[5.12 / 10的二次方]
-
通常情况下，应该使用double型，因为它比float型更精确。
-
举例说明
public class varDetail{ public static void main(String[] args){ double a = 1.234567899999; float b = 1.234567899999f; System.out.println(a); System.out.println(b); } }控制台输出，float丢失了数据精度
1.234567899999 1.2345679
-
-
-
-
浮点数使用陷阱
public class varDetail{ public static void main(String[] args){ // 浮点数使用陷阱：2.7和8.1 / 3比较 double num1 = 2.7; double num2 = 8.1 / 3; System.out.println(num1);//2.7 System.out.println(num2);//2.6999999999999997, 一个接近于2.7的小数 // 因为两个数不相等,所以执行不了if里面语句 if(num1 == num2){ System.out.println("相等"); } //正确的写法 if(Math.abs(num1 - num2) < 0.0000001) { System.out.println("差值非常小,到规定范围内.");//差值非常小,到规定范围内. } //输出差值 System.out.println(Math.abs(num1 - num2));//4.440892098500626E-16 } }
2.7、Java API 文档（P46）
1、API（Application Programming Interface，应用程序编程接口）是Java提供的基本编程接口（Java提供的类还有相关的方法）。中文在线文档：Java 8 中文版 - 在线API手册 - 码工具最新Java 8 中文版 api手册,Java 8 中文版 chm在线版浏览,Java 8 中文版在线中文参考手册,Java 8 中文版开发文档
https://www.matools.com/api/java8
2、Java语言提供了大量的基础类，因此Oracle公司也为这些基础类提供了相应的API文档，用于告诉我们开发者如何提供这些类，以及这些类里包含的方法。
2.8、字符型使用（P47）
-
基本介绍
字符类型可以表示单个字符，字符类型是char，char是两个字节（可以存放汉字）
多个字符我们使用字符串String（后面详细讲解String）
-
案例演示
public class char01 { public static void main(String[] args) { char c1 = 'a'; char c2 = '\t'; char c3 = '韩'; char c4 = 97; System.out.println(c1);//a System.out.println(c2);// System.out.println(c3);//韩 System.out.println(c4);//a } } -
字符类型使用细节
-
字符常量是用单引号括起来的单个字符。例如：char c1 = 'a'; char c2 = '我';char c3 = '9'
-
Java中还允许使用转义字符 ' \ ' 来将其后的字符转变为特殊字符型常量。例如：char c3 = '\n';//'\n'表示换行符
-
在java中，char的本质是一个整数， 在输出时，是Unicode码对应的字符。
-
可以直接给char赋一个整数，然后输出时，会按照对应的Unicode字符输出。
public class CharDetail{ public static void main(String[] args){ char c1 = 97; System.out.println(c1); char c2 = 'a'; System.out.println((int)c2); char c3 = '王'; System.out.println((int)c3);//29579 '王'对应的Unicode码 char c5 = 29579; System.out.println(c5);//输出'王' } } -
char类型时可以进行运算的，相当于一个整数，因为它都对应有Unicode码。
public class CharDetail{ public static void main(String[] args){ char c1 = 'a' + 1; System.out.println(c1);//b System.out.println((int)c1);//98 } }
-
-
字符类型本质探讨
-
字符型 存储到 计算机中，需要将字符对应的码值（整数）找出来，比如‘ a ’存储：'a'--->码值97--->二进制：110 0001--->存储。读取：二进制：110 0001--->码值97--->'a'--->显示。
-
字符和码值的对应关系是通过字符编码表决定的（提前规定好的）
-
-
字符编码表
ASCII（ASCII编码表 一个字节表示，一共128个字符。实际上一个字节可以表示256个字符，但是只用了128个）
Unicode（Unicode 编码表 固定大小的编码表 使用两个字节来表示字符，字母和汉字统一都是占用两个字节，这样浪费空间）
utf-8（编码表，大小可变的编码 字母使用一个字节，汉字使用3个字节）
gbk（可以表示汉字，而且范围广，字母使用1个字节，汉字2个字节）
gb2312（可以表示汉字，gb2312 < gbk）
big5码（繁体中文，台湾，香港）
2.9、常用编码（P50）
-
ASCII码介绍（了解）
-
ASCII码：上个世纪60年代，美国定制了一套字符编码（使用一个字符），对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符编码，只占用了一个字节的后面7位，最前面的1位统一规定为0。
-
缺点：不能表示所有字符
-
-
Unicode编码（了解）
-
Unicode的好处：一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用Unicode没有乱码的问题。
-
unicode的缺点：一个英文字母和一个汉字都占用两个字节，这对于存储空间来说是浪费。
-
2的16次方是65536，所以最多编码是65536个字符
-
编码0-127的字符是与ASCII的编码一样。比如'a'在ASCII码是0x61，在unicode码是0x0061，都对应97。因此Unicode码兼容ASCII码。
-
-
utf-8编码（了解）
-
utf-8是在互联网上使用Unicode的实现方式（改进）
-
utf-8是一种变长的编码方式。它可以使用1-6个字节表示一个符号，根据不同的符号而变化字节长度。
-
使用大小可变的编码 字母占一个字节，汉字占3个字节。
-
2.10、布尔类型（P51）
-
基本介绍
-
布尔类型也叫boolean类型，boolean类型数据只允许取值true和false，无null。
-
boolean类型占用1个字节
-
boolean类型适用于逻辑运算，一般用于程序流程控制。
-
if条件控制语句
-
while循环控制语句
-
do-while循环控制语句
-
for循环控制语句
-
-
1、
public class Boolean01{
public static void main(String[] args){
//判断成绩是否通过
// 定义一个布尔类型
boolean isPass = true;
if(isPass == true)
{
System.out.println("成绩通过，恭喜！");
}else{
System.out.println("成绩失败，下次努力！");
}
}
}控制台输出：
成绩通过，恭喜！2、
public class Boolean01{
public static void main(String[] args){
//判断成绩是否通过
// 定义一个布尔类型
boolean isPass = false;
if(isPass == true)
{
System.out.println("成绩通过，恭喜！");
}else{
System.out.println("成绩失败，下次努力！");
}
}
}控制台输出：
成绩失败，下次努力！-
使用细节说明
不能以0或非0的整数替代false和true，这点和C语言不同。
2.11、自动类型转换基础（P52~P54）
-
自动类型转换
-
介绍：
当Java程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数据类型，这个就是自动类型转换。
-
数据类型按精度（容量）大小排序为（背，规则）
-
//案例演示 public class AutoConvert{ public static void main(String[] args){ //演示自动转换 int num = 'a';//num = 97 由'a'的字符类型转换为int整型 double d1 = 80;//由80的整型转换为双精度类型80.0 System.out.println(num); System.out.println(d1); } }
-
-
自动类型转换注意和细节
-
有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
public class AutoConvertDetail{ public static void main(String[] args){ //有多种类型的数据混合运算时 //系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。 int n = 19; //float a = n + 1.1;//错误，n + 1.1----->结果类型为double //double a = n + 1.1;//正确，n + 1.1----->结果类型为double float a = n + 1.1f;//正确，n + 1.1----->结果类型为float } } -
当我们把精度（容量）大的数据类型赋值给精度（容量）小的数据类型时，就会报错，反之就会进行自动类型转换。
-
public class AutoConvertDetail{ public static void main(String[] args){ //当我们把精度（容量）大的数据类型赋值给精度（容量）小的数据类型时, //就会报错，反之就会进行自动类型转换。 int n1 = 1.1;//错误，1.1为double类型，占八个字节，而int容量只有4字节 } }
-
-
byte和short不能与char进行相互自动转换。
-
public class AutoConvertDetail{ public static void main(String[] args){ //byte和short不能与char进行相互自动转换。 //当把具体数赋值给byte变量时，会先判断该数是否在byte范围内，如果是就可以 byte b1 = 10;//正确，byte类型范围在-128~127之间 int n1 = 1;//n1为int类型，占4个字节 byte b2 = n1;//错误: 不兼容的类型: 从int转换到byte可能会有精度损失 char c = b1;//错误: 不兼容的类型: 从byte转换到char可能会有精度损失 byte b3 = 1000;//错误: 不兼容的类型: 从int转换到byte可能会精度有损失 } }
-
-
byte，short，char他们三者可以计算，在计算时首先转换为int类型
-
public class AutoConvertDetail{ public static void main(String[] args){ //byte，short，char他们三者可以计算，在计算时首先转换为int类型 byte b2 = 1; byte b3 = 2; short s = 3; //short s1 = b2 + s;//错误: 不兼容的类型: 从int转换到short可能会有损失,b2(byte) + s(short) ==>int int n2 = s + b2;//正确，s(short) + b2(byte) ==> int，自动转换为int类型 byte b4 = b2 + b3;//错误，b2(byte) + b3(byte) ==> int } }
-
-
boolean不参与转换。
-
public class AutoConvertDetail{ public static void main(String[] args){ boolean pass = true; int n3 = pass;//错误: 不兼容的类型: boolean无法转换为int。boolean不参与类型的自动转换 } }
-
-
自动提升原则：表达式结果的类型自动提升为操作数中最大的类型。
-
public class AutoConvertDetail{ public static void main(String[] args){ byte b = 1; short s = 2; int n = 3; double d = 100; //b + s + n + d;//为double类型 double dd = b + s + n + d;//正确 float f = 100; //int nn = f + n + s + b;//错误: 不兼容的类型: 从float转换到int可能会有损失 double nn = f + n + s + b;//正确，由于f + n + s + b为float类型，转换为double类型正确 } }
-
-
2.12、基本数据类型转换(P55~P57)
-
强制类型转换
-
介绍
自动类型转换的逆过程，将容量大的数据抓换为容量小的数据类型。使用时要加上强制转换符 ()，但是肯造成精度降低或者溢出，要格外注意。
-
案例演示
-
public class ForceConvert{ public static void main(String[] args){ int n = (int)1.9; System.out.println("n = " + n);//n = 1，造成精度损失 int n1 = 1000; byte b = (byte)n1; System.out.println("b = " + b);//b = -24，数据溢出 } }
-
-
-
强制类型转换细节
-
当进行数据的大小从 大---------------->小，就需要使用到强制类型转换。
-
强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级。
-
public class ForceConvertDetail{ public static void main(String[] args){、 //(int)10*3.5+6*1.5只将10转换为整形，而3.5和1.5均为double类型 //int x = (int)10 * 3.5 + 6 * 1.5;//错误: 不兼容的类型: 从double转换到int可能会有损失。 //System.out.println(x); //正确方法：用()提升10 * 3.5 + 6 * 1.5运算优先级 int y = (int)(10 * 3.5 + 6 * 1.5); System.out.println(y);//44 } }
-
-
char类型可以保存int的常量值，但不能保存int的变量值，需要强转
-
public class ForceConvertDetail{ public static void main(String[] args){ char c1 = 100;//ok int m = 100;//ok //char c2 = m;//错误: 不兼容的类型: 从int转换到char可能会有损失 char c3 = (char)m; System.out.println(c3);//输出100对于的ASCII码值----->d } }
-
-
byte和short与char类型进行运算时，当作int类型处理
-
-
基本数据类型转换-练习题
-
short s = 12;//ok
s = s - 9;//错误 int -> short
-
byte b = 10;//ok
b = b + 11;//错误，11为int 类型，不能转换为byte类型
b = (byte)(b + 11);//正确，使用强制类型转换
-
char c = 'a';//ok
int i = 16;//ok
float d = .314f;//ok，小数点前面的0可以省略
double result = c + i + d;//ok，表达式结果的类型自动提升为操作数中最大的类型
-
byte b = 16;//ok
short s = 14;//ok
short t = s + b;//错误，byte和short计算时转换为int类型
-
2.12、基本数据类型和String类型的转换（P58~P59）
-
介绍
在程序开发中，我们经常需要将基本数据类型转成String类型，或者将String类型转成基本数据类型。
-
基本类型转String类型：
语法：将 基本类型的值 + "" 即可
public class StringToBasic{ public static void main(String[] args){ int n1 = 100; float n2 = 1.1f; double n3 = 3.4; boolean b1 = true; //将上面的基本类型值转换为String类型 String str1 = n1 + ""; String str2 = n2 + ""; String str3 = n3 + ""; String str4 = b1 + ""; //输出：100 1.1 3.4 true System.out.println(str1 + " " + str2 + " " + str3 + " " + str4); } } -
String类型转基本数据类型
语法：通过基本类型的包装类调用parseXX方法即可
public class StringToBasic{ public static void main(String[] args){ String s1 = "113"; String s2 = "true"; //解读 使用 基本数据类型对应的包装类的相应方法，得到基本数据类型 int num1 = Integer.parseInt(s1); float num2 = Float.parseFloat(s1); double num3 = Double.parseDouble(s1); boolean num4 = Boolean.parseBoolean(s2); byte num5 = Byte.parseByte(s1); short num6 = Short.parseShort(s1); long num7 = Long.parseLong(s1); System.out.println(num1);//113 System.out.println(num2);//113.0 System.out.println(num3);//113.0 System.out.println(num4);//true System.out.println(num5);//113 System.out.println(num6);//113 System.out.println(num7);//113 //把字符串转成字符char //由于char只能存储单个字符 //s1.charAt(0)得到s1字符串第一个字符 '1'。 System.out.println(s1.charAt(0));//1 //而s1.charAt(2)得到s2字符串的第三个字符 '3'。 System.out.println(s1.charAt(2));//3 } }
-
注意事项
-
在将String类型转成基本数据类型时，要确保String类型能够转成有效的数据。
比如：我们可以把字符串“123”，转换成一个整型，但是不能把“hello”转成一个整数。
-
如果格式不正确，就会抛出异常，程序就会终止，这个问题在异常处理章节中，会处理。
-
-
案例演示
public class StringToBasicDetail{ public static void main(String[] args){ String str = "hello"; //转换为int int n1 = Integer.parseInt(str); System.Out.println(n1);//直接报错，计算机无法将"hello"字符串转换为int整型 } }
三、运算符
3.1、算术运算符介绍(P63)
-
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
常用的运算符有：
-
算术运算符
-
赋值运算符
-
关系运算符(比较运算符)
-
逻辑运算符
-
位运算符(需要二进制基础)
-
三元运算符
-
-
算数运算符
-
介绍
算数运算符是对数值类型的变量进行运算的，在Java程序中使用的非常多
-
-
算数运算符一览
-
案例演示算术运算符的使用
-
+，- ，*，/，%，++，--，重点讲解/、%、++
-
自增：++
1、作为独立的语句使用：
前置++和后置++都完全等价于i=i+1；
2、作为表达式使用：
前置++，如：++i则表达先自增后赋值
后置++，如：i++则表达先赋值后自增
-
在Java中 % 的公式：a % b = a - a / b * b
-
案例演示
-
public class ArithmeticOperator{
public static void main(String[] args){
System.out.println(10 / 4);//由于10和4均为整数类型，所以结果2.5小数部分省略，输出2
System.out.println(10.0 / 4);//10.0为double类型，4为int类型，结果自动转换为double类型，故输出2.5
double d = 10 / 4;//由于10和4均为整数类型，
//所以结果2.5小数部分省略，为2。但是d为double类型，后面有小数点部分，故输出2.0
System.out.println(d);
// % 取余
//在Java中 % 的公式：a % b = a - a / b * b
System.out.println(10 % 3);//1
System.out.println(-10 % 3);//-1
System.out.println(10 % -3);//1
System.out.println(-10 % -3);//-1
//++的使用
//1、独立使用
int i = 10;
i++;//自增 1，等价于 i = i + 1;
System.out.println(i);//i = 11;
++i;//自增 1，等价于 i = i + 1;
System.out.println(i);//i = 12;
/*
2、作为表达式使用
++i则表达先自增后赋值
i++则表达先赋值后自增
*/
int j = 10;
int k = ++j;
System.out.println("k=" + k + " " + "j=" + j);//k=11，j=11
k = j++;
System.out.println("k=" + k + " " + "j=" + j);//k=11，j=12
}
}
3.2、算术运算符练习（P65~P68）
-
面试题
1、
public class ArithmeticOperatorExercise01{ public static void main(String[] args){ int i = 1; i = i++;//规则：使用历史变量：(1)temp=1;(2)i=i+1;(3)i=temp;故而i=1 System.out.println(i);//1 int n = 1; n = ++n;//规则：使用临时变量：(1)n=n+1;(2)temp=n;(3)n=temp System.out.println(n);//2 } }2、
public class ArithmeticOperatorExercise01{ public static void main(String[] args){ int n1 = 10; int n2 = 20; int i = n1++; System.out.print("i=" + i + "\t");//i=10 System.out.println("n2=" + n2);//n2=20 i = --n2; System.out.print("i=" + i + "\t");//i=19 System.out.println("n2=" + n2);//n2=19 } }3、
-
假如还有59天放假，问：合xx个星期零xx天
public class ArithmeticOperatorExercise02{ public static void main(String[] args){ //假如还有59天放假，问：合xx个星期零xx天 int days = 59; System.out.println(days + "天一共有" + days / 7 + "个星期" + "零" + days % 7 + "天"); } } -
控制台输出：
一共有8个星期零3天 -
定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：5/9*(华氏温度-100)，请求出华氏温度对应的摄氏温度。
public class ArithmeticOperatorExercise02{
public static void main(String[] args){
//定义一个变量保存华氏温度，
//华氏温度转换摄氏温度的公式为：5/9*(华氏温度-100)，
//请求出华氏温度对应的摄氏温度。
double fahrenheit = 1234.6;
//注意此处一定要为5.0转换为double类型-----> 5.0 / 9 * (fahrenheit - 100)
System.out.println("摄氏温度为：" + 5.0 / 9 * (fahrenheit - 100) + "°");
}
}3.3、关系运算符介绍(比较运算符)（P69~P70）
-
介绍
-
关系运算符的结果都是boolean型，也就是要么么是true，要么是false
-
关系表达式经常用在if结构的条件中或循环结构的条件中
-
-
关系运算符一览
-
案例演示
public class RelationalOperator{ public static void main(String[] args){ int a = 9;//在开发中，不可以使用a,b,n,n1,n2...这种简单变量命 int b = 8; System.out.println(a > b);//true System.out.println(a >= b);//true System.out.println(a <= b);//false System.out.println(a < b);//false System.out.println(a == b);//false System.out.println(a != b);//true boolean flag = a > b; System.out.println("flag=" + flag);//ture } } -
细节说明
-
关系运算符的结果都是boolean型，也就是要么是true，要么是false
-
关系运算符组成的表达式，我们成为关系表达式。a > b
-
比较运算符“==”不能写成“=”
-
3.4、逻辑运算符(P71)
-
介绍
用于连接多个条件（多个关系表达式），最终的结果也是一个boolean值
-
逻辑运算符一览
-
说明逻辑运算符规则
1、a&b：&叫逻辑与，规则：当a和b同时为true，则结果为true，否则为false
2、a&&b：&&叫短路与，规则：当a和b同时为true，则结果为true，否则为false、
3、a|b：|叫逻辑或，规则：当a和b，有一个为true，则结果为true，否则为flase
4、a||b：||叫短路或，规则：当a和b，有一个为true，则结果为true，否则为flase
5、!a：叫取反，或者非运算，规则：当a为true，则结果为false，当a为false时，结果为true
6、a^b：叫逻辑异或，当a和b不同时，则结果为true，否则为false
-
3.4.1、短路与和逻辑与(P72)
-
&&和&基本规则
名称 语法 特点 短路与&& 条件1 && 条件2 &&... 所有条件都为true，结果为true，否则为false 逻辑与& 条件1 & 条件2 &&... 所有条件都为true，结果为true，否则为false&&和&的使用区别：
1、&&短路与：如果第一个条件为false，则后面的条件不会判断，最终结果为false，执行效率高
2、&逻辑与：不管第一个是否为true或false，后面的条件都要判断，执行效率低
3、开发中，我们经常使用的是短路与&&，效率高
-
案例演示
-
/** * 演示逻辑运算符的使用 */ public class LogicOperator01{ public static void main(String[] args){ int age = 30; //&&短路与 if(age > 18 && age < 37) System.out.println("ok1");//ok1 //&逻辑与 if(age >18 & age <37) System.out.println("ok2");//ok2 //区别 int a = 4; int b = 9; //对于&&短路与，如果第一个条件为false，则后面的条件不再判断 if(a < 1 && ++b < 50){ System.out.println("ok3"); } System.out.println("a=" + a + " b=" + b);//a = 4 b = 9;可见++b并没有执行 //对于&逻辑与，如果第一个条件为false，则后面的条件也会判断 if(a < 1 & ++b < 50){ System.out.println("ok3"); } System.out.println("a=" + a + " b=" + b);//a = 4 b = 10;可见++b执行 } }
3.4.2、短路或和逻辑或(P73)
-
|| 和 | 基本规则
名称 语法 特点 短路或|| 条件1 || 条件2 ||... 所有条件中只要有一个成立，结果为true，否则为false 逻辑或|| 条件1 | 条件2 |... 所有条件中只要有一个成立，结果为true，否则为false|| 和 | 的区别：
1、短路或：如果第一个条件为true，则后面的条件不会判断，最终结果为true，执行效率高
2、逻辑或：不管第一个为true或者false，后面的条件都要判断，执行效率低
3、在开发中，我们基本使用||
-
案例演示
public class LogicOperator02{ public static void main(String[] args){ int age = 50; // 短路或|| //第一个条件为真 if(age > 20 || ++age > 30 || ++age < 20) System.out.println("ok1 " + "age=" + age);//age = 50 //可见一个条件为真，后面的条件语句不再判断 // 逻辑或 | if(age > 20 | ++age > 30 | ++age < 20) System.out.println("ok1 " + "age=" + age);//age = 52 //可见一个条件为真,后面的条件语句依旧被判断 } }
3.4.3、逻辑非和逻辑异或(P74)
-
! 取反 基本规则
名称 语法 特点 ! 非（取反） !条件 如果条件本身成立，结果为false，否则为true -
案例演示
public class InverseOperator{
public static void main(String[] args){
//真变假，假变真
System.out.println(60 > 20);//true
System.out.println(60 < 20);//false
}
}-
逻辑异或 ^
a ^ b ：叫逻辑异或，当 a 和 b 不同时，则结果为true，否则为false -
案例演示
public class InverseOperator{ public static void main(String[] args){ //a ^ b ：叫逻辑异或，当 a 和 b 不同时，则结果为true，否则为false boolean flag1 = (10 > 1) ^ (9 > 2); System.out.println("flag1=" + flag1);//flag1 = false boolean flag2 = (10 < 1) ^ (9 > 2); System.out.println("flag2=" + flag2);//flag2 = true } }
3.4.4、逻辑运算符练习(P75)
练习题1
public class LogicalOperatorExercise01{
public static void main(String[] args){
//&逻辑与
int x = 5;
int y = 5;
if(x++ == 6 & ++y == 6)
x = 11;
System.out.println("x=" + x + "，y=" + y);//x = 6，y = 6
//&&短路与
int x1 = 5;
int y1 = 5;
//由于x1++ == 6为假（x1++先判断，后++），
//继续判断后面条件语句++y1 == 5，故y1 = 5
if(x1++ == 6 && ++y1 == 6)
x1 = 11;
System.out.println("x1=" + x1 + "，y1=" + y1);//x1 = 6，y1 = 5
// | 逻辑或
int x2 = 5;
int y2 = 5;
if(x2++ == 6 | ++y2 == 6)
x2 = 11;
System.out.println("x2=" + x2 + "，y2=" + y2);//x2 = 11，y2 = 6
// || 短路或
int x3 = 5;
int y3 = 5;
//由于x3++ == 6为假，则继续判断后面条件语句++y3 == 6，故y3 = 6
if(x3++ == 6 || ++y3 == 6)
x3 =11;
System.out.println("x3=" + x3 + "，y3=" + y3);//x3 = 11，y3 = 6
}
}练习题2
public class LogicalOperatorExercise02{
public static void main(String[] args){
boolean x = true;
boolean y = false;
short z = 46;
//(z++ == 46)后置++，先判断z是否等于46(无论是否相等，判断完都执行z++)
//判断为相等后，再将true赋值给y。注意这里是(y = true)
//都为真，执行括号里的z++; z = 48;
if((z++ == 46) && (y = true)){
z++;//都为真，执行括号里的z++; z = 48;
System.out.println("z=" + z);//48
}
//先将false赋值给x，第一个条件语句为假
//再执行条件语句(++z == 49)
//由于为前置++，先将z+1，再判断是否相等（为真）
if((x = false) || (++z == 49)){
//判断为相等，执行z++;z = 50
z++;
}
System.out.println("z=" + z);//输出z = 50；
}
}3.5、赋值运算符（P76~P77）
-
介绍
赋值运算符就是将某个运算后的值，赋给指定的变量
-
赋值运算符的分类
1、基本赋值运算符 =
2、复合赋值运算符
+=、-=、*=、/=、%=等，
a += b------------>a = a + b; a -= b------------>a = a - b; a *= b------------>a = a * b;............... -
代码演示
public class AssignmentOperator{ public static void main(String[] args){ int n1 = 10; n1 += 4;//等价于 n1 = n1 + 4; System.out.println(n1);//14 n1 /= 3;//等价于 n1 = n1 / 4; System.out.println(n1);//4 } } -
赋值运算符的特点
1、运算顺序从右往左 如：int num = a + b + c;//先将abc相加，再赋值给num
2、赋值运算符的左边，只能是变量，右边可以是变量、表达式、常量值
public class AssignmentOperator{ public static void main(String[] args){ int num = 20; int a = 1; int num1 = 70 * 80 / 11; int num2 = a; int num3 = a + 20; System.out.println(num3);//21 } }3、复合赋值运算符会进行类型强制转换
public class AssignmentOperator{ public static void main(String[] args){ byte b = 2; b += 3;//等价于b = (byte)(b + 3); System.out.println(b);//5 b++;//等价于b = (byte)(b + 1); System.out.println(b);//6 } }
3.6、三元运算符(P78~P80)
-
基本语法
条件表达式?表达式1:表达式2;运算规则：
1、如果条件表达式为true，运算后的结果是表达式1； 2、如果条件表达式为false，运算后的结果是表达式2； -
代码演示
public class TernaryOperator{ public static void main(String[] args){ int num1 = 10; int num2 = 100; //num1 > num2条件表达式为假 //故将num2--赋值给result，先将num2赋值给result，再执行num2-- //故result = 100;num1不变，num2-1后为99 int result = num1 > num2?++num1:num2--; System.out.println("result=" + result);//100 System.out.println("num1=" + num1);//10 System.out.println("num2=" + num2);//99 } }
-
使用细节
1、表达式1和表达式2要为可以赋值给接收变量的类型（或可以自动转换）
2、三元运算符可以转成if--else语句(三目运算符的本质就是if--else语句)
-
如：int res = a > b ? a++ :--b;//等价于
if(a > b)res = a++;
else res = --b;
-
-
public class TernaryOperatorDetail { public static void main(String[] args) { //表达式1和表达式2要为可以赋给接收变量的类型 //（或可以自动转换/或者强制类型转换） int a = 3; int b = 8; //强制转换类型 int c = a > b ? (int)1.1 : (int)3.4;//可以执行 System.out.println(c);//3 //自动转换类型 double d = a > b ? a : b + 3;//可以执行，满足 int转换为double类型 System.out.println(d);//11 } }
-
三目运算符练习
public class TernaryOperatorExercise {
public static void main(String[] args) {
//求三个数的最大值
int num1 = 111;
int num2 = 222;
int num3 = 333;
//思路：先判断出num1和num2中的最大数，赋值给max1
//再判断max1和num3中的最大数，赋值给max2
int max1 = num1 > num2 ? num1 : num2;
int max2 = max1 > num3 ? max1 : num3;
System.out.println("最大数为：" + max2);
//使用一条语句实现求最大值
//推荐使用上面方法，可读性和执行效率高于下面方法
int max = (num1 > num2 ? num1 : num2) > num3
? (num1 > num2 ? num1 : num2) : num3;
System.out.println("最大数为：" + max2);
}
}3.7、运算符优先级(P81)
-
运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如下图，上一行运算符总优先于下一行。
-
只有单目运算符和赋值运算符是从右向左运算。
3.8、标识符命名的规则和规范（P82）
-
标识符概念
1、java对各种变量、方法和类等命名时使用的字符序列称为标识符
2、凡是自己可以起名字的地方都叫标识符
-
标识符的命名规则
1、由26个大小写英文字母、数字0到9、_或$组成，其中数字不可以为标识符开头。如下
int 9abc = 10;//错误2、不可以使用关键字和保留字，但能包含关键字和保留字。如下：
int class = 5;//class为关键字，故错误 int acdclass = 5;//包含关键字，正确3、java中严格区分大小写，标识符的长度无限制
4、标识符不能包含空格。如下
int a b = 10;//标识符a b中间有空格，错误
3.8.1、标识符练习（P83）
判断下列变量名是否正确
hsp//正确
hsp12//正确
1hsp//错误，数字不能开头
h-s//错误，不能有 -
x h//错误，标识符中间不能有空格
h$3//正确
class//错误，class为关键字
int//错误，int为关键字
double//错误，double为关键字
public//错误，public为关键字
static//错误，static为关键字
goto//错误，goto为保留字
stu_name//正确3.8.2、标识符规范（P84）
1、包名：多单词组成时所有字母都小写，比如：aaa.bbb.ccc
2、类名、接口名：多单词组成时，所有单词的首字母大写（大驼峰命名），比如：TankShotGame
3、变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写（小驼峰命名），比如：tankShotGame
4、常量名：所有字母都大写。多单词时每个单词用下划线连接，比如TANK_SHOT_GAME
5、如果查不到标识符命名的英文单词，可以求助旁人或者使用汉语拼音命名
3.9、关键字和保留字(P85)
-
关键字
关键字的定义和特点不用背
定义：被java语言赋予了特殊含义，用做专门涌入的字符串（单词）
特点：关键字中所有字母都为小写
-
保留字
现有java版本尚未使用，但以后版本肯会作为关键字使用。自己命名标识符时，要避免使用这些保留字
byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const3.10、键盘输入语句（P86）
-
介绍
在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。需要一个扫描器（对象），就是Scanner
-
步骤：
1、导入该类的所在包，java.util.*
2、创建该类对象（声明变量）
3、调用里面的功能
//演示接收用户的输入
//步骤
//Scanner类 表示 简单文本扫描器，在java.util 包中
//1、引入/导入 Scanner类所在的包
import java.util.Scanner;//表示把java.util下的Scanner类导入
public class Input {
public static void main(String[] args) {
//2、创建Scanner 对象，new 创建一个对象
Scanner myScanner = new Scanner(System.in);
//myScanner就是Scanner类的对象
System.out.println("请输入名字");
//3、用户输入,程序执行到next 方法时，会等待用户输入
String name = myScanner.next();//接收用户输入的字符串
System.out.println("请输入年龄");
int age = myScanner.nextInt();
System.out.println("请输入薪水");
double salary = myScanner.nextDouble();
System.out.println("个人信息如下");
System.out.println("姓名：" + name + " 年龄：" + age + " 薪水：" + salary);
}
}3.11、进制（P87）
-
进制介绍
对于整数，有四种表示方式：
1、二进制：0，1。满2进1，以0b或0B开头表示。
int num1 = 0b1010;2、十进制：0-9，满10进1。
int num2 = 1010;3、八进制：0-7，满8进1 。以数字0开头表示。
int num3 = 01010;4、十六进制：0-9及A:10、B:11、C:12、D:13、E:14、F15，此处的A-F不区分大小写。满16进1，以0x或0X开头表示
int num4 = 0xa01c;
-
进制的图示
-
二进制转换成十进制(P88)
规则：从最低位（数的右边）开始，将每个位上的数提取出来，乘以2的（位数-1）次方，然后相加。
例：将0b1011转换成十进制数
0b1011 = 1 * 2的(1 - 1)次方 + 1 * 2的(2 - 1)次方 + 0 * 2的(3 - 1)次方 + 1 * 2的(4 - 1)次方 = 1 + 2 + 0 + 8 = 11; -
八进制转换成十进制(P89)
规则：从最低位（数的右边）开始，将每个位上的数提取出来，乘以8的（位数-1）次方，然后相加。
例：将0234转换成十进制数
0234 = 4 * 8的(1 - 1)次方 + 3 * 8的(2 - 1)次方 + 2 * 8的(3 - 1)次方 + 0 * 8的(4 - 1)次方 = 4 + 24 + 128 + 0 = 156; -
十六进制转换成十进制表示(P90)
规则：从最低位（数的右边）开始，将每个位上的数提取出来，乘以16的（位数-1）次方，然后相加。
例：将0x23A转换成十进制数
0x23A = 10 * 16 ^ 0 + 3 * 16 ^ 1 + 2 * 16 ^ 2 = 10 + 48 + 512 = 570;
-
十进制转二进制(P91)
规则：将该数不断除以2，直到商为0为止，然后将每步得到的余数倒过来，就是对应的二进制。
案例：将34转成二进制 = 0B00100010(补两个0，因为一个字节有8位)
- 十进制数转换成八进制数(P92)
规则：将该数不断除以8，直到商为0为止，然后将每步得到的余数倒过来，就是对应的二进制。
案例：将131转成八进制 = 0203
- 十进制转换成十六进制(P93)
规则：将该数不断除以16，直到商为0为止，然后将每步得到的余数倒过来，就是对应的二进制。
案例：将237转换成十六进制 = 0xED
-
二进制转换成八进制(P94)
规则：从低位开始，将二进制数每三位一组，转成对应的八进制数即可
案例：将0b11010101转成八进制 = 0325
0b11(3)010(2)101(5)----->0325 -
二进制转换成十六进制(P95)
规则：从低位开始，将二进制数每四位一组，转成对应的十六进制数即可
案例：将0b11010101转换成十六进制 = 0xD5
0x1101(D)0101(5)----->0xD5 -
八进制转换成二进制(P96)
规则：将八进制数每一位，转成对应的一个三位的二进制数即可
案例：将0237转换成二进制 = 0b000010011111
0(000)2(010)3(011)7(111)----->0b000010011111 -
十六进制转换成二进制(P97)
规则：将八进制数每一位，转成对应的一个四位的二进制数即可
案例：将0x23B转换成二进制 = 0b001000111011
0x2(0010)3(0011)B(1011)----->0b0010 0011 1011
3.12、原码、反码、补码(P99)
1、二进制的最高位是符号位，0表示正数，1表示负数
2、正数的原码，反码和补码都一样
3、负数的反码 = 它的原码符号位不变，其它位取反（0变成1，1变成0）
4、负数的补码 = 它的反码 + 1，负数的反码 = 负数的补码 - 1
5、0的反码，补码都是0
6、java没有无符号数，换言之，java中的数都是有符号的
7、在计算机运算的时候，都是以补码的方式来运算的
使用补码的原因在于,使用补码,可以将符号位和数值域统一处理,同时,加法和减法也可以统一处理。
8、当我们看运算结果的时候，要看它的原码
3.13、位运算详解(P100~P101)
P（100）
-
java中有7个位运算符（&、|、^、~、>>、<<和>>>）
分别是 按位与&、按位或|、按位异或^、按位取反~，它们的运算规则是：
按位与&：两位全为1，结果为1，否则为0
按位或|：两位有一个为1，则为1，否则为0
按位异或^：两位不相同为1，相同为0
按位取反~：0变1，1变0
-
案例演示
public class TernaryOperatorDetail01 {
public static void main(String[] args) {
//1.先得到2和3的补码
//由于正数的原码、反码、补码相同
//2的补码：00000000 00000000 00000000 00000010
//3的补码：00000000 00000000 00000000 00000011
//2.按位与&
//2的补码：00000000 00000000 00000000 00000010
//3的补码：00000000 00000000 00000000 00000011
// 结果：00000000 00000000 00000000 00000010
//将结果转换为十进制，为2
System.out.println(2&3);//2
//先求-2的补码
//-2原码：10000000 00000000 00000000 00000010
//-2反码：11111111 11111111 11111111 11111101
//-2补码：11111111 11111111 11111111 11111110
//按位取反0变1，1变0
//~-2结果：00000000 00000000 00000000 00000001
//将结果转换为十进制，为1
System.out.println(~-2);//1
//先求2的补码
//由于2为正数，原、反、补码相同
//2的补码：00000000 00000000 00000000 00000010
//~2按位取反结果：11111111 11111111 11111111 11111101
//取反后仍为补码。由于取反后为负数，故需求原码
//运算结果的反码：11111111 11111111 11111111 11111100
//运算结果的原码：10000000 00000000 00000000 00000011
//将运算结果的原码转换为十进制，为-3
System.out.println(~2);//-3
}
}P（101）
-
还有3个位运算符 >>、<<和>>>，运算规则：
1、算术右移 >> ：低位溢出，符号位不变，并用符号位补溢出高位
2、算术左移 << ：符号位不变，低位补0
3、逻辑右移（无符号右移） >>>：低位溢出，高位补0
4、没有逻辑左移
-
代码演示
public class TernaryOperatorDetail02 {
public static void main(String[] args) {
System.out.println(1 >> 2);//1 / 2 / 2 = 0；
System.out.println(1 << 2);//1 * 2 * 2 = 4；
System.out.println(4 << 3);//4 * 2 * 2 * 2= 32；
System.out.println(15 >> 2);//15 / 2 / 2 = 3;
}
}3.14、本章作业（P102）
//a % b当a是小数时，公式：a - (int)a / b * b;
//注意：有小数运算，得到的结果是近似值
System.out.println(-11.5%3);//-2.5
//注意：有小数运算，得到的结果是近似值
System.out.println(-11.4%3);//-2.4000000000000004int i = 66;
System.out.println(++i+i);//++运算符优先级高，先执行++，i=67。故输出134；1、int num1 = (int)"18";//错误，应为Integer.parseInt("18");
2、int num2 = 18.0;//错误 double类型不能转换为int类型
3、double num3 = 3d;//ok
4、double num4 = 8;//ok
5、int i = 48;char ch = i + 1;//错误，int类型不能转换为char类型
6、byte b = 19;short s = b + 2;//错误，b + 2为int类型，int类型不能转换为short类型试写出将String转换成double类型的语句，以及将char类型转化成String的语句
String str = "19.8";
double d1 = Double.parseDouble
char c1 = '韩';
String str2 = c1 + "";
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
