01_变量与运算符
第二章：Java基础语法数据类型
01、 变量运算符
02、程序流程控制
03、课后练习题一、Java程序基本结构
1.1 基本结构
Java程序基本结构示例代码：
后面全是资料：
IDEA小技巧：<br>public static void main(String[] args) {} 这一串语句打出快捷键就是psvm，首字母小写的缩写标识符：可以自己起名字的地方<br>变量、类名、数组名、参数名、方法名、成员变量名.....变量与运算符
一、Java程序基本结构
前情回顾<br> 还记得我们在上一章学过的Hello World程序是怎么写的吗？我们写了好几行代码，分别代表什么意思？为什么要这么写？<br>public class HelloWorld {<br> public static void main(String[] args) {<br> System.out.println("HelloWorld");<br> }<br>}<br>1. HelloWorld代表的是类名。类的概念，会在后面的面向对象部分学习。这里我们可以认为，所有的Java程序，必须写在一个类里。类是对同一类型相同事务提取出来共性的一个概念。<br>2. class是修饰类名的关键字。所有的类名之前，必须加class<br>3. {...}类名HelloWorld后面的大括号，是类的内容。大括号要前后对应。<br>4. 括号中的内容，称为main方法。是java程序的入口。以后我们学的多了，可以写很多种方法，a方法，v方法等。但是已经有main方法了，就不能重复定义了。<br>5. java编译器为每个类生成一个字节码文件(也就是后缀名为class的文件)，且文件名与类名相同，同名的类有可能发生冲突。为了解决这一问题，java提供包来管理类名空间，什么是包呢，实际就是文件夹。相同的名字的类，在不同的包下，就像是同样的东西，放在不同的抽屉中一样.<br>6. 一个java源文件，可以有多个类，但是只能有一个公共类(由public修饰的类)，而且经过编译之后，会生成与类名对应的字节码文件(有几个类就有几个字节码文件)。<img>
面试题：static能改变变量的访问权限吗？static是静态的，通过类名直接访问。在Java里面，所有的访问权限，都是什么其他都不可能改变其访问权限。其他都不能改变，只是改变了调用方式。
二、关键字和保留字
正确识别java语言的关键字（keyword）和保留字（reserved word）是十分重要的。Java的关键字对java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等。保留字是为java预留的关键字，他们虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字。 识别java语言的关键字，不要和其他语言如c/c++的关键字混淆。
保留字
保留字（reserved words）：是语言已经定义过的字，一些保留字可能没有相对应的语法，考虑到扩展性，为了向后兼容不能再将其作为变量名。const和goto是java的保留字。 目前没在用，将来可能会用到。
关键字
关键字，是被Java语言赋予了特殊含义的单词。在给类、变量等命名是不要使用。 特点是所有字母都小写。(在很多编程软件中会显示出一种颜色)。见下图
<img>
<img>
详解：https://blog.csdn.net/ZytheMoon/article/details/78648288<br>接口就是一种规范，一种约束。<br>原始类型就是基本数据类型。<br>byte一个字节 8位bit<br>short 2个字节 16<br>int 4个字节 32<br>long 8个字节 64<br>形状类，老虎类，人类，吃类等。<br>final最终的就不能被修改。<br>synchronized面试经常出现。<br>对象就是中国人，美国人，非洲人等。<br>谁来调用这个方法，this就是谁。<br>有些事已经自定义好的异常，有些事我们1自定义的异常。<br>goto保留关键字。不是Java关键字。
三、标识符及命名规范
3.1 标识符概述
应该说命名规范是一种约定，也是程序员之间良好沟通的桥梁。良好的命名规范可以为团队合作开发推波助澜，无论在项目开发，还是产品维护上都起到了至关重要的作用。
Java 对各种变量、方法和类、接口等要素命名时使用的字符序列称为标识符（在Java里面,所有可以自己起名字的地方都叫标识符）。
3.2 命名规范
<img>
/**<br> 标识符测试<br> 命名规则：<br> （1）标识符由字母、下划线“_”、美元符“$”和数字组成。空格也是不行。<br> （2）标识符不能以数值开头。<br> （3）不可以是Java的关键字和保留字。<br> （4）Java 标识符大小写敏感，且长度无限制。<br> （5）见名之意<br> （6）驼峰原则：首字母小写,多个单词组成的话,首个单词的首字母小写，之后每个单词的首字母都大写<br><br> 命名规范：<br> java采用匈牙利命名规范，它的基本原则是名称要有明确的意义。具体要求为：<br> 类名/接口首字母大写，如果包含多个单词，每个单词首字母都大写 XxxYyyZzz\Person<br> 变量/方法首字母小写，如果包含多个单词，每个单词首字母都大写age\useName<br> 常量全部大写，多个单词组成,则每个单词由_分割 PI\SUBSITE_EVER<br> 包名全部小写。我们在项目中，包名一律使用这种方式：<br> com.公司名.项目名.模块名<br> com.newcapec.abgame.util<br><br> Java小技巧：<br> IdEA工具会自动编译我们的源代码，当我们的源代码出现红的时候，那就表示编译不通过<br> Ctrl+d是IDEA的复制快捷键<br> Java同一作用域里面，不能出现同名变量<br> **/<br>public class IdentifierTest {<br> public static void main(String[] args){<br> //String是用来定义字符串变量的<br> //int是用来定义整型的<br> String useName;<br> String useName01;<br> String useName_01;<br> String useName$01;<br> //String useName-01;<br> //String useName%01;<br> //String class;<br> String classes;<br> String realName;<br> //String realName;<br> String realname;<br> String name = "张三";<br> String sex = "男";<br> String 真实姓名 = "李克伟"; //强烈不推荐标识符虽说可以出现中文，但是不要这么写<br> int age;<br> int $age;<br> int _age;<br> //int 2age;<br> }<br>}四、变量
内存如何存放数据
<img>
电脑使用内存来记忆程序运行所使用的数据(程序中所有的数据都是存储在内存里面)<br>内存如何存储数据?<br>1、开房间（前台登记单人间、双人间、总统套间）声明数据类型<br>2、入住<br><br>内存像旅馆<br> 数据各式各样，要先根据数据的需求（即类型）为它申请一块合适的空间<br><br>已经将数据存入内存，但是：<br> 怎么找到存入的数据？<br>内存地址不好记，怎么办？<br> 通过内存中房间的别名找到数据存储的位置<br>通过变量名可以简单快捷的找到它存储的数据。<img>
通过变量名可以简单快速地找到它存储的数据4.1 变量的概念
//声明变量，即“根据数据类型在内存申请空间” 数据类型 变量名； <br>int num;<br>//赋值，即“将数据存储至对应的内存空间”<br>num = 100;<br>//使用变量，即“取出数据使用 ”<br>System.out.println(num);<br><br>//声明变赋值语法<br>int age = 100;<br>//重新赋值<br>age = 200;<br>age = 250;<br>String name = "张三";判断1
public class Error1 {
public static void main(String[] args) {
String title;
System.out.println( title );
}
}
//以上是否有错误?先声明变量并赋值，然后才能使用 判断2
public class Error2 {
public static void main(String[] args) {
int %hour = 18;
System.out.println(%hour);
}
}
//以上是否有错误?变量名不能以%开始 判断3
public class Error3 {
public static void main(String[] args) {
String name = "张三";
String name = "李四";
}
}
//以上是否有错误?声明两个同名变量导致编译错误4.2 变量的分类
按被声明的位置划分：
成员变量：方法外部、类的内部定义的变量
局部变量：方法或语句块(代码块)内部定义的变量 局部变量赋值才能使用
注意：类外面（类对应的大括号外面）不能有变量的声明不能有任何代码出现。/*变量测试
在程序中存在大量的数据来代表程序的状态，其中有些数据在程序的运行过程中值会发生改变，
有些数据在程序运行过程中值不能发生改变，这些数据在程序中分别被叫做变量和常量。
程序运行过程中会发生改变的量,叫变量。程序运行过程中不允许发生改变的量,叫常量。
变量的本质： 其实就是内存的一个存储区域，该区域的数据可以在同一类型范围内不断变化，
不同数据存入具有不同内存地址的空间，相互独立。
变量是程序中最基本的存储单元，包括变量类型、变量名和存储的值。
变量就是存储数据的容器;用于在内存中保存数据
变量：一个数据存储空间的表示；不同数据存入具有不同内存地址的空间，相互独立。
该区域有自己的名称（变量名）和类型（数据类型,表示该区域能放什么样的值）
1、Java中每个变量必须先声明赋值，后使用
2、使用变量，只需要使用变量名，就可以得到该变量的值,例如：System.out.printIn(var);
3、Java是强类型语言，变量在声明的时候必须指定数据类型，后使用。
4、使用变量注意：变量的作用域在一对{ }之间有效。
* */
public class VariableTest {
public static void main(String args[]){
//方式一：先声明，后赋值 指南：数据(变量)类型 变量名；变量名 = 变量值；
int myAge;//向内存中申请一块区域：用来存储int类型值，通过myAge指向这个内存区域申请房间
myAge = 22; //入住房间
//方式二：声明并赋值 指南：数据类型 变量名 = 初始化值和上面执行机制一样的
int yourAge = 33;
System.out.println(myAge);
System.out.println(yourAge);
//myName呈现红色报错：变量没有声明 必须先声明，后使用
//System.out.println(myName);
//String myName;
//局部变量：在方法内部声明的变量
//局部变量必须赋值才能调用，不然控制台语句myName波浪线报错
String myName = "李克伟";
System.out.println(myName);
}
}
4.3 变量的数据类型（面试题）
Java语言是一门强类型语言，也就是说，每个变量或者符号常量甚至一个方法都必须有明确的数据类型或者是返回值类型。在 Java 中，数据类型分为两种，分别是基本类型和引用类型。 基本类型一共有四大类八种基本数据类型，它们是：四种整型，两种浮点型，一种字符型和一种布尔型。 引用类型有类，接口和数组等（后面会详细学习）
int i = 100;对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。 <img>
Java基本数据介绍
1.boolean：数据值只有public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}或false，适用于逻辑计算，占一字节
2.byte：byte型（字节型）数据在内存中占用1个字节，表示的存储数据范围为：-128~127，因为第一位是符号位。一个字节8位。
3.char：char型（字符型）数据在内存中占用2个字节。char型数据用来表示通常意义上的字符。
（思考，char类型的变量能存放汉字吗？） 中文汉字字母符号都是字符占用一个字符。
4.short：short型（短整型）数据在内存中占用2个字节
5.int：int型（整型）数据在内存中占用4个字节。
6.long：long型（长整型）数据在内存中占用8个字节。
7.float：float型（单精度浮点型）数据在内存中占用4个字节。
8.double：double型（双精度浮点型）数据在内存中占用8个字节。 在java中，整形数据默认为int数据类型，浮点型默认为double数据类型，如果要表示long型数据或float型数据，要在相应的数值后面加上l、L或f、F，否则会出现编译问题。char是可以有存储范围的，可以用一个数值来表示它，所以也叫整数型。缺省数值其实就是默认值，局部变量就是默认值，数组的时候会说到。
<img>
public class VaribleTest01 {
String ever = "地球"; //在方法外，类内部声明的变量，叫做成员变量；
static String test = "Test";//由static修饰的成员变量，叫静态变量
int num;
publicstatic void main(String[] args){
/*按数据类型划分
基本数据类型：8种，byte、short、int、long、float、double、boolean、char;
整数类型：byte、short、int、long
浮点类型：float、double
布尔类型：boolean
字符类型：char
引用数据类型：类、接口、数组等；
字符串是引用数据类型
面试题：Java的八种数据类型有哪些？String是基本数据类型吗？Java数据类型划分？
*/
String name = "李克伟";//定义在方法内部的变量，叫局部变量
//static String name = "李克伟";//static不能修饰局部变量
System.out.println(name);
//创建一个对象，通过对象来调用num
VaribleTest01 VaribleTest01 = new VaribleTest01();
System.out.println(VaribleTest01.num);//对象调用成员变量
System.out.println(VaribleTest01.test);//对象调用静态变量
System.out.println(VaribleTest01.test);//类名调用静态变量
}
}4.3.1 整数类型
从小到大取值范围分别是:byte、short、int、long
Java各整数类型有固定的表述范围和字段长度，不受具体 OS （operating system）的影响，以保证 java 程序的可移植性。
Java 的整型常量默认为 int 型，声明 long 型常量须后加 ‘l’ 或 ‘L’ 结尾，就是小写和大写
1个字节 = 8 bit ，每一个bit有两种情况 0 或1，所以就存在2的8次方种组合，就可以存储256个数，语言规定一半正，一半负，但是因为存在0，所以规定-128-127
表数范围公式：-2^（位数-1）次幂~2^（位数-1）次幂-1
例如：-2^（8-1）~2^（8-1）-1 —— -2^7~2^7 - 1<img>
byte b1 = 100;
byte b1 = 128; //编译不通过
short s1 = -100;
short s2 = (short)(b1+s1);
long l1 = 100;
//整数数值默认是int类型，3222233333超出了int的取值范围
//long L2 = 3222233333; //编译不通过
long L3 = 3222233333L; //编译通过
注意:在混合运算中byte、short、char直接转换为int。
使用过程中习惯用int类型，之后再考虑long类型。4.3.2 浮点类型
与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体OS的影响。
Java 的浮点型默认为 double 型，声明 float 型变量，须后加 ‘f’ 或 ‘F’。
float f1 = 3.14f;
double d1 = 3.14;浮点型常量有两种表示形式： 十进制数形式：如：5.12 512.0f 0.512 (必须有小数点） 科学计数法形式:如：5.12e2 512E2 100E-2 2E2=200
System.out.println(2e2);//200.0<img>
在IEEE754标准中进行了单精度浮点数(float)和双精度数浮点数(double)的定义。float有32bit，double有64bit。
它们的构成包括符号位、指数位和尾数位。
这些位的构成如下：
种类-------符号位-------------指数位----------------尾数位----float---第31位(占1bit)---第30-23位(占8bit)----第22-0位(占23bit)double--第63位(占1bit)---第62-52位(占11bit)---第51-0位(占52bit)
取值范围主要看指数部分：
float的指数部分有8bit(2^8)，由于是有符号型，所以得到对应的指数范围-128~128。
double的指数部分有11bit(2^11)，由于是有符号型，所以得到对应的指数范围-1024~1024。
由于float的指数部分对应的指数范围为-128~128，所以取值范围为：
-2128到2128，约等于-3.4E38 — +3.4E38 。
float的精度为6~8位
double 精度是15~16
float 尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
double 精度是float的两倍。有效位数14
取值范围大小：byte short int long float double
//float f = 12.12345678910;
float f = 12.12345678910F;//float类型必须添加F/f
//编译错误，把double赋值给float，可能存在溢出
//整数部分和浮点部分总共8位，但是0除外0
//超出部分四舍五入
float d = 1234.67816729797474471F;
float e = 0.678167294F;
System.out.println(d);//1234.6782
System.out.println(e);//0.6781673
//整数部分和浮点部分总共16位，精确15位
double b = 12.1234567890123456789;
System.out.println(b);//12.123456789012346
4.3.3 字符类型：char
char 型数据用来表示通常意义上"字符"。
字符型变量的三种表现形式： 字符变量是用单引号(‘ ’)括起来的单个字符，涵盖世界上所有书面语的字符。 例如：char c1 = 'a'; char c2 = '中'; char c3 = '9'; char c4 = '$';
Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。 例如：char c3 = ‘\n’; -- ‘\n'表示换行符 char 类型是可以进行运算的。
//浮点类型的测试
public class VaribleTest01 {
public static void main(String[] args){
/*
* char 型数据用来表示通常意义上的"字符"（2字节）
* byte1 Boolean 1
* short 2 char 2
* int 4 float 4
* long8 double8
* 字符：在Java中使用‘’来表示一个字符
* 字符可以是任意一个中文汉字、数字、字母、符号等等
* */
//表现形式一：字符常量是用单引号（‘ ’）括起来的单个字符
//注意：char能存储中文汉字原因：Java中所有字符都使用Unicode万国码编码，所以一个字符可以存储一个字母
//一个汉字，或其他书面语的一个字母
char ch1 = '1';
char ch2 = 'a';
char ch3 = '中';
char ch4 = '-';
//char类型必须存储一个字符,空格也是一个字符，无内容就不行
//char ch6 = '';
char ch7 = ' ';
//字符串可以是空字符串的
String str = "";
//表现形式二：Java中允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量
char ch8 = '\"';
char ch9 = '\n';
//直接使用Unicode值来表示字符型常量
//中文汉字的取值范围:[\ue400 - \u9fa8]
char ch10 = '\u4567';
System.out.println(ch10);//䕧
//char类型是可以进行运算的，因为它都对应有Unicode码
char ch11 = 'a'; //a的Unicode码97 A的Unicode码650的Unicode码48
System.out.println(ch11 + 19); //97+19=116
}
}4.3.4 布尔类型：boolean
boolean 类型适于逻辑运算，一般用于程序流程控制：
if条件控制语句；
while循环控制语句；
do-while循环控制语句；
for循环控制语句；boolean类型数据只允许取值public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}和false，不可以0或非 0 的整数替代public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}和false，这点和JS、C语言不同。 boolean占一个字节
//布尔类型的测试
public class VaribleTest01 {
public static void main(String[] args) {
boolean a1 = public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
};
boolean a2 = false;
//boolean a3 = null; 值不能这样写
boolean isMarried = public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
};
if (isMarried) {
System.out.println("你就不能参与我们的单身周末了");
}else{
System.out.println("可以放飞自我了");
}
boolean a4;
System.out.println(a4 = a1);//public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}
System.out.println(a4 = a2);//false
}}//字符串类型的测试
public class VaribleTest01 {
public static void main(String[] args) {
/*
*字符串不是基本数据类型，而是引用数据类型
* 字符串必须使用""
* 一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。（字符串串联接）
* 任意数据类型都可以和字符串进行+运算(连接运算，字符串拼接)，得到的都是一个新字符串
* */
String str = "Hello";
System.out.println(str + 100); //Hello100
System.out.println(str + 100 +50); //Hello10050
System.out.println(100 + 50 + str); //150Hello
System.out.println(str + 100); //Hello100
System.out.println(str + (100 + 50)); //Hello150
//把数值类型转换为字符串
int num = 100;
String numStr = num + "";
System.out.println(numStr);//"100"
//扩展：怎么把字符串转换为数值把“100”转换为100
int num1 = Integer.parseInt(numStr);
System.out.println(num1);//100
}}4.3.5 基本数据类型转换
4.3.5.1 自动类型转换
自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：
<img>
<img>
将一种类型的变量赋给另一种类型的变量时，只要满足以下条件，就会发生自动类型转换。
两种类型兼容； 目标类型大于源类型；
有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
运算时：byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
当把任何基本类型的值和字符串值进行连接运算时(+)，基本类型的值将自动转化为字符串类型。
//基本数据类型的测试
public class VaribleTest01 {
public static void main(String[] args) {
/*
* 基本数据类型转换分为两种：
* 自动类型转换：容量小的类型会自动转换为容量大的类型
* 强制类型转换：
* 基本数据类型转换指的是7种类型之间的转换规则，不包含boolean
*
* 1、容量小的类型赋值给容量大的类型，会发生自动类型转换
* 容量从小到大分别是：byte——short/char——int——long——float——double
* 注意：这里的容量大小指的是表示数的范围的大小，比如float容量要大于long的容量
* */
byte b1 = 102;
short s1 = 3200;
int i1 = b1;//i1=102
long l1 = s1;//l1=3200
float f1 = l1;//f1=3200
char ch1 = 'a';
System.out.println(ch1);//a
i1 = ch1;
System.out.println(i1);//97
// 2、当容量小的类型和容量大的类型进行运算的时候，会自动转换为大类型
//注意：byte/short/char在进行运算的时候，直接转换为int
byte b2 = 102;
short s2 = 666;
int i2 = 67;
double d2 = 54.2;
int sum1 = i2 + b2;//int类型 = int类型 + byte类型
double sum2 = i2 + d2;//double类型 = int类型 + double类型
int sum3 = b2 + s2;//int类型 = byte类型 + short类型
}}4.3.5.2 强制类型转换
自动类型转换(隐式转换)的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符（()），但可能造成精度降低或溢出,格外要注意。
通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。如： String a = “43”; int i = Integer.parseInt(a);
boolean类型不可以转换为其它的数据类型。
//强制类型转换
public class VaribleTest01 {
public static void main(String[] args) {
double d1 = 666.73;
System.out.println(d1);//double 输出值为：666.73
//int i1 = d1;//因为666.73在编译的时候，就会认为double类型的范围远大于int，会存在溢出问题，编译失败
int i1 = (int)d1; //因为666.73在int的取值范围以内，不存在精度溢出问题
System.out.println(i1);//666
int i2 = 128;
byte b2 = (byte)i2;//128超出byte取值范围，溢出
System.out.println(b2);//-128
/*
* byte
* -128~127
* 10000000
* 01111111
* 127 + 1 —— 01111111 + 1 = 10000000 —— -128
* */
}}4.3.5.3 类型转换对于表达式
如果一个操作数为 long 型，则整个表达式提升为 long 型 如果一个操作数为 float 型，则整个表达式提升为 float 型 如果一个操作数为 double 型，则整个表达式提升为 double 型 在整个运算表达式中找到最大的类型，这个类型及是表达式运算后的类型
4.4 局部变量作用域和生命周期
前面我们说变量要先定义，后使用，但也不是在变量定义后的语句一直都能使用前面定义的变量。我们可以用大括号将多个语句包起来形成一个复合语句，变量只能在定义它的复合语句中使用，即：变量的作用范围从被定义开始到距离其最近的“}”处结束。
变量可以在代码块或方法中声明
块以左大括号开始，以右大括号结束
块用来定义作用域
每次创建一个新块后，就会创建一个新的作用域
变量的作用域是一个作用的范围，每个变量都有自己的作用域
变量的生存期是指变量的生存周期
所谓生命周期，也有说法叫做作用域。是指常量和变量都有自己固定的生效范围，一旦在这个范围之外将失去效用。生命周期一般以区间作为界限，即{}
五、进制
进制也就是进位计数制，是人为定义的带进位的计数方法。 对于任何一种进制---X进制，就表示每一位置上的数运算时都是逢X进一位。
十进制是逢十进一，十六进制是逢十六进一，二进制就是逢二进一，以此类推，x进制就是逢x进位。.比如在运算中常见的进制有十进制、二进制、八进制、十六进制，在日常生活中星期是七进制，秒是60进制，月是12进制等等。
二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2，进位规则是“逢二进一”，借位规则是“借一当二”，由18世纪德国数理哲学大师莱布尼兹发现。当前的计算机系统使用的基本上是二进制系统，数据在计算机中主要是以补码的形式存储的。计算机中的二进制则是一个非常微小的开关，用“开”来表示1，“关”来表示0。
<img alt="img">
进制 英文 范围 前缀 后缀 二进制 Binary 0-1 0b B 八进制 Octal 0-7 0 O 十进制 Decimal 0-9 \ D 十六进制 Hexadecimal 0-9, A-F 0x H
5.1 二进制和十进制之间的转换
5.1.1 十进制转二进制
方法为：十进制数除2取余法，即十进制数除2，余数为权位上的数，得到的商值继续除2，依此步骤继续向下运算直到商为0为止。 （具体用法如下图）
<img alt="img">
5.1.2 二进制转十进制
方法为：二进制转换成十进制，需要二进制的每一位的数值乘以相应的2的幂次方，然后相加。
基数: X进制的基数是X 系数:每一位上面的数值 权:每一位上基数的幂(乘方)
公式:系数乘以基数的权次幂
（具体用法如下图）
<img alt="img">
5.2 二进制与八进制之间的转换
5.2.1 二进制转八进制
方法为：3位二进制数按权展开相加得到1位八进制数。（注意事项，3位二进制转成八进制是从右到左开始转换，不足时补0）。
（具体用法如下图） <img alt="img">
5.2.2 八进制转成二进制
方法为：八进制数通过除2取余法，得到二进制数，对每个八进制为3个二进制，不足时在最左边补零。
（具体用法如下图） <img alt="img">
5.3 二进制与十六进制之间的转换
5.3.1 二进制转十六进制
方法为：与二进制转八进制方法近似，八进制是取三合一，十六进制是取四合一。（注意事项，4位二进制转成十六进制是从右到左开始转换，不足时补0）。
（具体用法如下图）
<img alt="img">
5.3.2 十六进制转二进制
方法为：十六进制数通过除2取余法，得到二进制数，对每个十六进制为4个二进制，不足时在最左边补零。 （具体用法如下图） <img alt="img">
5.4 十进制与八进制与十六进制之间的转换
5.4.1 十进制转八进制或者十六进制有两种方法
第一：间接法—把十进制转成二进制，然后再由二进制转成八进制或者十六进制。这里不再做图片用法解释。
第二：直接法—把十进制转八进制或者十六进制按照除8或者16取余，直到商为0为止。
（具体用法如下图）
<img alt="img">
5.4.2 八进制或者十六进制转成十进制
方法为：把八进制、十六进制数按权展开、相加即得十进制数。
（具体用法如下图）
<img alt="img">
5.5 十六进制与八进制之间的转换
八进制与十六进制之间的转换有两种方法
第一种：他们之间的转换可以先转成二进制然后再相互转换。
第二种：他们之间的转换可以先转成十进制然后再相互转换。
System.out.println(0b101);//二进制:5（0b开头的）
System.out.println(011);//八进制:9 (0开头的)
System.out.println(11);//十进制:11
System.out.println(0x11C);//十六进制:284 （0x开头的）//进制的转换形式和转换规则
public class VaribleTest01 {
public static void main(String[] args) {
/*
* 十六进制（hex）,以0x或0X开头表示。此处的A-F不区分大小写
* 无论是哪种进制，在输出的时候，都会转成十进制
* */
int num1 = 0b11;//Binnary 二进制以数字0b或0B开头
System.out.println(num1);//3
int num2 = 011;//octal八进制以数字0开头
System.out.println(num2);//9
int num3 = 11;
System.out.println(num3);//11
int num4 = 0x11;//hex
System.out.println(num4);//17
}}六、真值、机器数、原码、反码、补码
面试题：什么是原码、反码、补码？为何要使用它？
机器数
一个数在计算机中的二进制表示形式, 叫做这个数的机器数。机器数是带符号的，在计算机用一个数的最高位存放符号, 正数为0, 负数为1.
比如，十进制中的数 +3 ，计算机字长为8位，转换成二进制就是00000011。如果是 -3 ，就是 10000011 。那么，这里的 00000011 和 10000011 就是机器数。
真值
因为第一位是符号位，所以机器数的形式值就不等于真正的数值。例如上面的有符号数 10000011，其最高位1代表负，其真正数值是 -3 而不是形式值131（10000011转换成十进制等于131）。所以，为区别起见，将带符号位的机器数对应的真正数值称为机器数的真值。
例：0000 0001的真值 = +000 0001 = +1，1000 0001的真值 = –000 0001 = –1
原码是什么？
原码就是早期用来表示数字的一种方式: 一个正数，转换为二进制位就是这个正数的原码。
负数的绝对值转换成二进制位然后在高位补1就是这个负数的原码
举例说明：
比如如果是8位二进制:
[+1]原 = 0000 0001
[-1]原 = 1000 0001
第一位是符号位. 因为第一位是符号位, 所以8位二进制数的取值范围就是:
，即：
[-127 , 127]
原码是人脑最容易理解和计算的表示方式.
但是原码有几个缺点，零分两种 +0 和 -0 。很奇怪是吧！还有，在进行不同符号的加法运算或者同符号的减法运算的时候，不能直接判断出结果的正负。你需要将两个值的绝对值进行比较，然后进行加减操作 ，最后符号位由绝对值大的决定。于是反码就产生了。
反码是什么 ？
反码的表示方法是：正数的反码是其本身；负数的反码是在其原码的基础上, 符号位不变，其余各个位取反。
举例说明：
[+1] = 原 = 反
[-1] = 原 = 反
可见如果一个反码表示的是负数, 人脑无法直观的看出来它的数值. 通常要将其转换成原码再计算。
补码是什么？
补码的表示方法是：正数的补码就是其本身；负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)
还是举例说明：
[+1] = 原 = 反 = 补
[-1] = 原 = 反 = 补
对于负数, 补码表示方式也是人脑无法直观看出其数值的. 通常也需要转换成原码在计算其数值.
为何要使用原码, 反码和补码
在开始深入学习前, 我的学习建议是先”死记硬背”上面的原码, 反码和补码的表示方式以及计算方法.
现在我们知道了计算机可以有三种编码方式表示一个数. 对于正数因为三种编码方式的结果都相同:
[+1] = 原 = 反 = 补
所以不需要过多解释. 但是对于负数:
[-1] = 原 = 反 = 补
可见原码, 反码和补码是完全不同的. 既然原码才是被人脑直接识别并用于计算表示方式, 为何还会有反码和补码呢?
首先, 因为人脑可以知道第一位是符号位, 在计算的时候我们会根据符号位, 选择对真值区域的加减. (真值的概念在本文最开头). 但是对于计算机, 加减乘除已经是最基础的运算, 要设计的尽量简单. 计算机辨别”符号位”显然会让计算机的基础电路设计变得十分复杂! 于是人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法, 这样计算机运算的设计就更简单了.
于是人们开始探索 将符号位参与运算, 并且只保留加法的方法. 首先来看原码。计算十进制的表达式: 1-1=0
1 - 1 = 1 + (-1) = 原 + 原 = 原 = -2
如果用原码表示, 让符号位也参与计算, 显然对于减法来说, 结果是不正确的.这也就是为何计算机内部不使用原码表示一个数.
为了解决原码做减法的问题, 出现了反码。计算十进制的表达式:
1-1=0
1 - 1 = 1 + (-1)
= 原 + 原
= 反 + 反
= 反 = 原
= -0
发现用反码计算减法, 结果的真值部分是正确的. 而唯一的问题其实就出现在”0”这个特殊的数值上. 虽然人们理解上+0和-0是一样的, 但是0带符号是没有任何意义的. 而且会有原和原两个编码表示0.
于是补码的出现, 解决了0的符号以及两个编码的问题:
1-1 = 1 + (-1)
= 原 + 原
= 补 + 补
= 补=原
这样0用表示, 而以前出现问题的-0则不存在了.而且可以用表示-128:
(-1) + (-127) = 原 + 原
= 补 + 补
= 补
-1-127的结果应该是-128, 在用补码运算的结果中, 补 就是-128. 但是注意因为实际上是使用以前的-0的补码来表示-128, 所以-128并没有原码和反码表示.(对-128的补码表示补算出来的原码是原, 这是不正确的)
使用补码, 不仅仅修复了0的符号以及存在两个编码的问题, 而且还能够多表示一个最低数. 这就是为什么8位二进制, 使用原码或反码表示的范围为[-127, +127], 而使用补码表示的范围为[-128, 127].
因为机器使用补码, 所以对于编程中常用到的32位int类型, 可以表示范围是: [-231, 231-1] 因为第一位表示的是符号位.而使用补码表示时又可以多保存一个最小值./*
* 真值 +3 -3
* 原码 0000 0011 1000 0011
* 反码 0000 0011 1111 1100
* 补码 0000 0011 1111 1101
*
* 正数的原码、反码、补码都是二进制的表现形式
* 负数的原码是负数的绝对值二进制然后高位补1；
* 负数的反码是符号位不变，其他各个位取反；
* 负数的补码是在反码的基础上+1；
* */总结
正数的反码和补码都与原码相同。
负数的反码为对该数的原码除符号位外各位取反。
负数的补码为对该数的原码除符号位外各位取反，然后在最后一位加1
对于负数原码转补码 符号位不变，然后按位取反+1；
对于负数补转原码 符号位不变，然后按位取反+1；各自的优缺点：
原码最好理解了，但是加减法不够方便，还有两个零。
反码稍微困难一些，解决了加减法的问题，但还是有有个零
补码理解困难，其他就没什么缺点了七、运算符
Java提供了一组丰富的操作符来操作变量。 我们可以将所有Java运算符划分为以下几个分类
算术运算符
关系运算符，比较运算符
按位运算符，了解
逻辑运算符
赋值运算符
其他运算符7.1. 算术运算符
算术运算符在数学表达式中的使用方式与在代数中使用的方式相同。下表列出了算术运算符的使用示例 -假设整数类型变量A的值为：10，变量B的值为：20，则
注: 算数运算符一般是用来做数值运算的(char类型可以参与到数值运算)；但是在java里面，字符串可以和任意数据类型做+运算，都是字符串的拼接。
<img>
//++和--的测试
/*
* 面试题：++（--）在前和在后的区别？
* 如果++（--）不参与运算（就是直接输出结果，调用也不行），那么在前和在后没有区别；
* ++（--）在前，先自增（自减）计算(一条单独的语句)，然后再取值
* ++（--）在后，先自增（自减）计算，然后再取值
* 在自身的基础上-1
* a ++ 相当于 a = a + 1;
*
*/
public class VaribleTest01 {
public static void main(String args[]) {
int a = 10;
int b = 20;
int c = 25;
int d = 25;
int num1 = 10;
int num2 = 20;
int k1 = 10;
int k2 = 20;
num1 ++;//一条单独的语句
++ num2;//一条单独的语句
//直接得到结果
System.out.println(num1);//11
System.out.println(num2);//21
//参与调用
System.out.println("k1++得到结果"+ k1++);//10
System.out.println("k1++得到结果"+ ++k2);//21
//参与运算
//在输入语句输出的时候，先取a的值10放到控制台上，在+1变成11
System.out.println("a++ = " +(a++) );//a ++ = 10
System.out.println(a);//11
//在输入语句输出的时候，先取a的值11放到控制台上，在-1变成10
System.out.println("a-- = " +(a--) );//11
System.out.println(a);//10
// 对比 d++ 和 ++d 有什么区别
System.out.println("d++ = " +(d++) );//d ++ = 25，取值之后，d = 26
System.out.println(d);//26
System.out.println("++d = " +(++d) );//++ d = 27，取值之后，d = 27
System.out.println(d);//27
//注意事项
short s = 10;
//s = s + 1;//编译失败，short类型和int类型进行运算，得到的是int类型改变方法如下：
//方法一:需要强转
s =(short) (s + 1);
//方法二；等价与【s = s + 1;】= 【s += 1;】自增运算符不会改变数据类型
//++ \ += 都是内置运算符，不会改变数据类型
s++;
//三种对数值进行+1运算的写法
short n1 = 10;
short n2 = 10;
short n3 = 10;
//写法1
n1 = (short) (n1 + 1);
//写法2（推荐）
n2++;
//写法3
n3 += 1;
System.out.println(n1);//11
System.out.println(n2);//11
System.out.println(n3);//11
//注意事项：
byte n4 = 127;
n4++;
System.out.println(n4);//-128
}
}执行上面示例代码，得到以下结果：
a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++ = 10
b-- = 11
d++ = 25
++d = 27public class VaribleTest01 {
/*
* 对于除号“/”，它的整数除法和小数除是有区别的：
* 1、两个整数类型做运算，得到的肯定是整数类型，只有浮点数参与运算了，才得到的是小数
* 2、0不能作为除数，但是和浮点类型做运算可以作为除数
* */
public static void main(String args[]) {
int num1 = 12;
int num2 =5;
int x = num1 / num2;
double y = num1 / num2;
System.out.println(x);//2
System.out.println(y);//2.0
double num3 =5.0;
System.out.println("num1 / num3 = " + num1 / num3 );//2.42.4属于double类型
System.out.println("num1 / num2 = " + (double)(num1 / num2) );//2.0
System.out.println("num1 / num3 = " + num1 /(double) num2 );//2.4
//0不能作为除数，但是和浮点类型做运算可以作为除数
//编译正常，运行报错
//System.out.println("num1 / 0 = " + num1 / 0 );
//Exception in thread "main" java.lang.ArithmeticException: / by zero
//编译正常，运行正常 Infinity无穷大
double result1 = 12.0 / 0;
double result2 = 12 / 0.0;
System.out.println(result1);//Infinity
System.out.println(result2);//Infinity
//0能不能作为除数？
//0在和整数类型进行除法运算的时候，不能作为除数；
//0在和浮点类型进行除法运算的时候，可以作为除数，得到的结果是Infinity
}
} /*
* 取模（取余）运算的注意事项
* */
public class VaribleTest01 {
public static void main(String args[]) {
/*
* 取余结果的符号与被模数的符号相同
* 12 / 5 5是除数，12是被除数
* 12 % 5 5是模数，12是被模数
* */
int a1 = 12;
int a2 = 5;
System.out.println("a1 % a2 = " + (a1 % a2));//正2
int a3 = -12;
int a4 = 5;
System.out.println("a3 % a4 = " + (a3 % a4));//负2
int a5 = 12;
int a6 = -5;
System.out.println("a5 % a6 = " + (a5 % a6));//正2
int a7 = -12;
int a8 = -5;
System.out.println("a7 % a8 = " + (a7 % a8));//负2
}
}7.2. 关系运算符
Java语言支持以下关系运算符。假设变量A的值是10，变量B的值是20，则
注:关系运算符的返回值都是boolean类型。一般结合流程控制语句使用
<img>
Java关系运算符示例代码如下 -
public class VaribleTest01 {
public static void main(String args[]) {
int a = 10;
int b = 20;
//比较运算符的结果是boolean类型
System.out.println("a == b = " + (a == b) );//a == b = false
System.out.println("a != b = " + (a != b) );//a != b = public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}
System.out.println("a > b = " + (a > b) );//a > b = false
System.out.println("a < b = " + (a < b) );//a < b = public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}
System.out.println("b >= a = " + (b >= a) );//b >= a = public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}
System.out.println("b <= a = " + (b <= a) );//b <= a = false
/*
* 区分好==和=的区别：
* */
boolean b1 = false;
if(b1 == public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}){//false == public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}结果比较为false
System.out.println("结果为真");
}else{
System.out.println("结果为假");//输出
}
boolean b2 = false;
if(b2 = public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}){//把public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}赋值给b2
System.out.println("结果为真");
}else{
System.out.println("结果为假");//输出
}
}
}执行上面示例代码，得到以下结果：
a = 0011 1100
b = 0000 1101
-----------------
// 1.参加运算的两个数据，按照二进制进行按位与的运算。
// 运算规则：0&0=0; 0&1=0; 1&0=0; 1&1=1;
// 即：两位同时为“1”，结果才为“1”，否则为0。
a&b = 0000 1100
// 2.参加运算的两个对象，按二进制位进行“或”运算。
// 运算规则：0|0=0； 0|1=1； 1|0=1； 1|1=1；
// 即 ：参加运算的两个对象只要有一个为1，其值为1。
a|b = 0011 1101
// 3.参加运算的两个数据，按二进制位进行“异或”运算。
// 运算规则：0^0=0； 0^1=1； 1^0=1； 1^1=0；
// 即：参加运算的两个对象，如果两个相应位为“异”（值不同），则该位结果为1，否则为 0。
a^b = 0011 0001
~a= 1100 0011如果是对负数移位，则是对补码移位
7.4 逻辑运算符
下表列出了逻辑运算符 -假设布尔变量A的值为：public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}，变量B 的值为：false，则 -<img> 以下简单的示例程序演示了逻辑运算符。 将以下Java程序复制并粘贴到Test.java文件中，然后编译并运行该程序 -
byte a = 100;
a>>=2;
//a = a>>2;执行上面示例代码，得到以下结果：
public class Test {
public static void main(String args[]) {
int a = 60; /* 60 = 0011 1100 */
int b = 13; /* 13 = 0000 1101 */
int c = 0;
c = a & b; /* 12 = 0000 1100 */
System.out.println("a & b = " + c );
c = a | b; /* 61 = 0011 1101 */
System.out.println("a | b = " + c );
c = a ^ b; /* 49 = 0011 0001 */
System.out.println("a ^ b = " + c );
c = ~a; /*-61 = 1100 0011 */
System.out.println("~a = " + c );
c = a << 2; /* 240 = 1111 0000 */
System.out.println("a << 2 = " + c );
c = a >> 2; /* 15 = 1111 */
System.out.println("a >> 2= " + c );
c = a >>> 2; /* 15 = 0000 1111 */
System.out.println("a >>> 2 = " + c );
}
}a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2= 15
a >>> 2 = 157.5. 赋值运算符
以下是Java语言支持的赋值运算符； <img>
public class VaribleTest01 {
public static void main(String args[]) {
//练习：交换两个变量的值
int num1 = 10;
int num2 = 20;
System.out.println("num1 = " + num1 + ",num2 = " + num2 );
//第一种：定义临时变量
//最简单的，推荐使用的
// int temp = num1;//temp = 10
// num1 = num2;//num1 = 20
// num2 = temp;//num2 = 10
// System.out.println("num1 = " + num1 + ",num2 = " + num2 );
//第二种：数值运算符
// num1 = num1 + num2;
// num2 = num1 - num2;
// num1 = num1 - num2;
// System.out.println("num1 = " + num1 + ",num2 = " + num2 );
//第三种：按位运算符
//num1 = 10 二进制：0000 1010
//num2 = 20 二进制：0001 0100
num1 = num1 ^ num2;//0001 1110 30
num2 = num1 ^ num2;//0000 1010 10
num1 = num1 ^ num2;//0001 0100 20
System.out.println("num1 = " + num1 + ",num2 = " + num2 );
}
}以下程序是一个演示赋值运算符的简单示例。 将以下Java程序复制并粘贴到Test.java文件中。 编译并运行此程序 -
public class Test {
public static void main(String args[]) {
boolean a = public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
};
boolean b = false;
System.out.println("a && b = " + (a&&b));
System.out.println("a || b = " + (a||b) );
System.out.println("!(a && b) = " + !(a && b));
}
}执行上面示例代码，得到以下结果 -
a && b = false
a || b = public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}
!(a && b) = public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}
注意:&&与||的短路问题 &与|也可以用于逻辑运算，但是不存在短路情况。7.6 其它运算符
Java语言支持的其他运算符很少。
7.6.1. 三目运算符 (?:)
三目运算符也称为三元运算符。 此运算符由三个操作数组成，用于计算布尔表达式。 运算符的目标是确定应将哪个值赋给变量。 运算符写成 -
/*
* 逻辑运算符测试
* */
public class VaribleTest01 {
public static void main(String args[]) {
/*
*&和&&的区别？
* &和&&都是作与运算符，结果都是一致的
* &是按位与运算，&&是逻辑与运算
* &不具备短路，&&具备短路，如果第一个表达式的结果为false，则不在执行第二个；
*公式：两者都为真，才为真，否则为假
*
* |和||的区别？
* |和||都是作或运算符，结果都是一致的
* |是按位或运算，||是逻辑或运算
* |不具备短路，||具备短路，如果第一个表达式的结果为public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}，则不在执行第二个；
*公式：只要有一个为真，结果就为真，否则为假
*
* 良好的编程习惯：运算符两侧为空格
* IDEA的格式化代码快捷键；Ctrl+Alt+L
*
* 结论：运算符的优先级低于+
* */
System.out.println("&和 &&的测试");
System.out.println((public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
} & public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
})+"\t"+(public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
} & false)+"\t"+(false & false)+"\t");
System.out.println((public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
} && public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
})+"\t"+(public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
} && false)+"\t"+(false && false)+"\t");
System.out.println("|和 ||的测试");
System.out.println((public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
} | public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
})+"\t"+(public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
} | false)+"\t"+(false | false)+"\t");
System.out.println((public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
} || public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
})+"\t"+(public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
} || false)+"\t"+(false || false)+"\t");
int a = 10;
int b = 10;
boolean b1 = 5 > 3 & a++ > 10;//输出控制台10a=11
boolean b2 = 5 > 3 && b++ > 10;//输出控制台10b=11
System.out.println(b1 +"\t" + b2 +"\t"+ a +"\t" + b);
boolean b3 = 5 < 3 & a++ > 10;//输出控制台11a变为12
boolean b4 = 5 < 3 && b++ > 10;//b变为11
System.out.println(b3 +"\t" + b3 +"\t"+ a +"\t" + b);
}
}下面是一段示例代码：
/*
*运算符：用来进行运算的符号
* 表达式：有运算符连接起来，符合java运算规则的式子
* 操作数：运算符两侧的值或变量就是操作数
* */
public class VaribleTest01 {
public static void main(String args[]) {
// = 简单的赋值运算符，将右边操作数的值赋给左边操作数
//当“=”两侧数据类型不一致时，可以使用自动类型转换或强制类型转换原则进行处理
//支持连续赋值
int num1 = 100;
long num2 = num1;//num1是int类型，num2是long类型，发生了自动类型转换
byte num3 = (byte)num1;//num1是int类型，num3是byte类型，必须强转
//String str = num1;//编译失败
//变量的另一种写法但是有些规则不支持这种写法，少数
// int a;
// int b;
// int c;
int a,b,c;//一次性声明3个int类型变量
int x,y = 10,z;//一次性声明3个int类型的变量，并且给y赋值
}
}执行上面示例代码，得到以下结果 -
public class Test {
public static void main(String args[]) {
int a = 10;
int b = 20;
int c = 0;
c = a + b;
System.out.println("c = a + b = " + c );
c += a ;
System.out.println("c += a= " + c );
c -= a ;
System.out.println("c -= a = " + c );
c *= a ;
System.out.println("c *= a = " + c );
a = 10;
c = 15;
c /= a ;
System.out.println("c /= a = " + c );
a = 10;
c = 15;
c %= a ;
System.out.println("c %= a= " + c );
c <<= 2 ;
System.out.println("c <<= 2 = " + c );
c >>= 2 ;
System.out.println("c >>= 2 = " + c );
c >>= 2 ;
System.out.println("c >>= 2 = " + c );
c &= a ;
System.out.println("c &= a= " + c );
c ^= a ;
System.out.println("c ^= a = " + c );
c |= a ;
System.out.println("c |= a = " + c );
}
}7.6.2. instanceof运算符
此运算符仅用于对象引用变量。 运算符检查对象是否属于特定类型(类类型或接口类型)。 instanceof运算符写成 -
c = a + b = 30
c += a= 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a= 5
c <<= 2 = 20
c >>= 2 = 5
c >>= 2 = 1
c &= a= 0
c ^= a = 10
c |= a = 10如果操作符左侧的变量引用的对象是右侧的类/接口类型，则结果为真。 以下是一个例子 -
variable x = (expression) ? value if public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
} : value if false执行上面示例代码，得到以下结果：
public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}如果要比较的对象与右侧类型兼容，则此运算符仍将返回public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}。 以下是另一个例子 -
Value of b is : 30
Value of b is : 20执行上在示例代码，得到以下结果：
public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}7.7 运算符的优先级
当多个运算符出现在一个表达式中，谁先谁后呢？这取决于优先级。小括号的优先级是最高的。下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。
第一优先级: () [] .
第二优先级: 算数运算符
第三优先级: 关系运算符
第四优先级: 逻辑运算符
第五优先级：赋值运算符
<img>
八、流程控制语句
流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。其流程控制方式有：顺序结构、分支结构和循环结构。
8.1 顺序结构
<img>
public class Test {
public static void main(String args[]) {
String name = "Kobe";
// 当 name 的类型是 String 时，则返回为：true
boolean result = name instanceof String;
System.out.println( result );
}
}true8.2 分支结构
<img>
<img>
8.2.1 if单分支语句
语法: if(条件表达式){ 语句块; }解释: 条件表达式结果为boolean类型，当表达式结果为public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
},则执行语句块;否则什么都不执行！ 当语句块只有1句代码时,可以省略大括号.建议不要省略<img>
true示例:
张浩Java成绩大于98分，而且音乐成绩大于80分，老师奖励他；或者Java成绩等于100分，音乐成绩大于70分，老师也可以奖励他.
从上到下依次执行8.2.2 if双分支语句
语法: if(条件表达式){ 语句块A; }else{ 语句块B; }解释: 条件表达式结果为boolean类型，当表达式结果为public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
},则执行语句块A;否则执行语句块B！<img>
语法:
if(条件表达式){
语句块;
}
解释:
条件表达式结果为boolean类型，当表达式结果为true,则执行语句块;否则什么都不执行！
当语句块只有1句代码时,可以省略大括号.建议不要省略示例：
如果张浩Java考试成绩大于98分，老师就奖励他一个MP4，否则老师就罚他进行编码。
package Test3;
public class IfDemo1 {
public static void main(String[] args) {
int a = 10;
int b = 10;
if(a>b){
System.out.println("hello");
}
System.out.println("...........");
if(a==b){
System.out.println("hello");
}
}
}8.2.3 if多分支语句
语法： if(条件表达式A){ 语句块A; }else if(条件表达式B){ 语句块B; }... else if(条件表达式N){ 语句块N; }else{ 语句块N+1 }解释: 所有的条件表达式结果都是boolean类型。 如果条件表达式A结果为public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
},则执行语句块A，否则去判断条件表达式B； 如果条件表达式B结果为public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " +b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
},则执行语句块B，否则去判断条件表达式C； .... 如果所有的条件表达式结果都为false,则执行语句块N+1<img>
为什么使用多重if选择结构?
语法:
if(条件表达式){
语句块A;
}else{
语句块B;
}
解释:
条件表达式结果为boolean类型，当表达式结果为true,则执行语句块A;否则执行语句块B！package Test3;
public class IfDemo2 {
public static void main(String[] args) {
int a = 10;
int b = 10;
if(a==b){
System.out.println("hello");
}else{
System.out.println("你好");
}
System.out.println("............");
if(a>b){
System.out.println("hello");
}else{
System.out.println("你好");
}
}
}public class SimpleIf2 {
public static void main(String[] args) {
int score = 91; // 张浩的Java成绩
if (score > 98) {
System.out.println("老师说:不错，奖励一个MP4！");
} else {
System.out.println("老师说:惩罚进行编码！");
}
}
}8.2.4 嵌套if
为什么使用嵌套if？
语法：
if(条件表达式A){
语句块A;
}else if(条件表达式B){
语句块B;
}...
else if(条件表达式N){
语句块N;
}else{
语句块N+1
}
解释:
所有的条件表达式结果都是boolean类型。
如果条件表达式A结果为true,则执行语句块A，否则去判断条件表达式B；
如果条件表达式B结果为true,则执行语句块B，否则去判断条件表达式C；
....
如果所有的条件表达式结果都为false,则执行语句块N+1问题:
1、对学员的结业考试成绩评测
成绩>=90 ：优秀
成绩>=80 ：良好
成绩>=60 ：中等
成绩<60：差
分析：将成绩分成几个连续区间判断。使用单个if选择结构无法完成，使用多个if选择结构很麻烦 ，所以要使用多重if选择结构。<img>
if(score
页:
[1]