一、数据的表示详情
1.1、整数在数据中的存储原理
任何数据在计算机中都是以二进制来表示的，所谓的二进制其实是数据的表达形式，它的特点就是逢二进一。
数据的表达形式除了二进制（逢二进一），还有八进制（逢八进一），十进制（逢十进一），十六进制（逢十六进一）等。
1.二进制中只有0和1两个数
首先十进制的0和二进制的0是一样的，十进制的1和二进制的1也是 一样的。但是十进制中有2，
但是二进制中就没有2了
2.那么二进制是如何表示十进制的2呢？
1
+ 1
——————————
10 这里两个1相加，结果为2，由于二进制满2进1，所以最终结果10
3.那么二进制是如何表示十进制的3呢？
前面我们已经知道二进制10表示十进制的2，那么二进制10+1就表示十进制的3啊！
10
+ 1
—————————
11 十进制的3对应的二进制是11
4.那么二进制是如何表示十进制4的呢？
前面我们已经知道二进制11表示十进制的4，那么11+1就表示十进制的5啊
11
+ 1
—————————
100 十进制的5对应的二进制是100前面每算一个二进制数据都是采用+1的方式，逢2进1，一个一个算出来的。有没有更快的算出十进制对应二进制的方法呢？
当然是有喽，这种方法我们都叫它除二取余法：
1.那要怎么做嘞？
让十进制数据连续除以2，直到商为0，余数反转
2.举例1：把十进制6转换为二进制
商 余数
6/2 3 0
3/2 1 1
1/2 0 1
然后把余数反转：6对应的二进制是110
3.举例2： 把十进制13转换为二进制
商 余数
13/2 6 1
6/2 3 0
3/2 1 1
1/2 0 1
然后把余数反转：10对应的二进制是1101计算机中的最小单位：
计算机中最小的存储单位是字节（Byte），一个字节占8位（bit），也就是说即使这个数据不足8位也需要用8位来存储。
1.2、 字符在计算机中的存储原理
字符并不是直接存储的，而是将每一个字符编成一个整数，存储的是字符对应的二进制，同时也有对应的关系表格，叫做ASCII编码表。
1.3、图片视频声音的存储原理
图片： 从图片开始，如果你把一张图片不断的放大，你会看到有马赛克的效果。你会发现图片中的每一个细节是由一个一个的小方格组成的，每一个小方格中其实就是一种颜色。任何一种颜色可以使用三原色来表示，简称RGB，其中R（红色），G（绿色），B（蓝色），而RGB中每一种颜色又用一个字节的整数来表示，最小值是0最大值是255。
视频：视频和图片是一样的，把多张图片连续播放，在一秒钟内连续播放24张以上，由于人眼存在视觉暂留现象，人眼感受不到画面切换的时间间隔，就认为是连续的视频了。
声音：声音是以波的形式传播的。我们可以把声波在表示在一个坐标系上，然后在坐标系上取一些点，把这些点的坐标值以二进制的形式存储到计算机中，这就是声音的存储原理。
1.4、数据的其他表示形式
二进制到十进制的转换：
十进制可以转二进制，采用的是除2取余法，那么我们反过来能不能把二进制转换为十进制呢？
介绍一种计算方式叫做：8421码
1.十进制转十进制
比如我们把12345进行分解：
12345 = 10000 + 2000 + 300 + 40 + 5
= 1*10^4 + 2*10^3 + 3*10^2 + 5*10^0
我们发现：
在十进制中如果把十进制的每一位从右往左从0开始编一个号，假设这一位数字是a,那么这一位数表示的值就是：a*10^n；
2.二进制转十进制：
类比十进制：
如果把二进制的每一位从从右往左0开始编一个号用n表示，假设二进制的每一位是a，
那么这一位表示的十进制值是：a*2^n
1)假设二进制的每一位都是1：
128 64 32 16 8 4 2 1 每一位表示的十进制：a*2^n
7 6 5 4 3 2 1 0 编号：n
1 1 1 1 1 1 1 1 二进制的每一位：a
二进制 十进制
11111111 = 1*2^7 + 1*2^6 + 1*2^5 + ... + 1*2^0
= 128 + 64 + 32 + ... + 1
= 255
2)假设二进制的为0010001
128 64 32 16 8 4 2 1 每一位表示的十进制：a*2^n
7 6 5 4 3 2 1 0 编号：n
0 0 1 0 0 0 0 1 二进制的每一位：a
二进制 十进制
0010 0001 = 0*2^7 + 0*2^6 + 1*2^5 + ... + 1*2^0
= 0 + 0 + 32 + ... + 1
= 33
3)8421码：从右往左给二进制的每一位数依次按照1 2 4 8...标记
128 64 32 16 8 4 2 1
0 0 1 0 0 0 0 1
只需要将1位上的数字加起来，就是二进制对应的十进制
二进制 十进制
00001101 = 8+4+1
= 13
0000111 = 4+2+1
= 7
0001111 = 8+4+2+1
= 25二进制转八进制：
1.运算规则：
把二进制的每三位一组合，然后对每三位用8421码进行计算，最后拼接到一起
原因：因为111，的值是7, 再大满7就需要往进位了。
2.把二进制11001110转换为八进制数据
01 100 001 二进制每三位一组合
1 4 1 每一组进行8421码运算
----------
八进制：141二进制转十六进制：
1.运算规则：
把二进制的每四位一组合，然后对每四位用8421码进行计算，最后拼接到一起
原因：因为1111，的值是15, 再大1满16了就需要往进位了。
2.举例：把二进制11001110转换为十六进制数据
0110 0001 二进制每四位一组合
6 1 每一组进行8421码运算
----------
十六进制：61
3.练习：把111100转换为十六进制
0011 1100
3 12 由于十六进制中有a,b,c,d,e,f分别表示10,11,12,13,14,15
-----------
十六进制：3c二、数据类型详解
定义变量需要进行声明变量，这里的数据类型是用来规定变量存储什么类型的数据，比如int a = 10; 这里的int就是限制变量只能存储整数； 除了int这种数据类型Java还提供了很多其他的数据类型。Java的数据类型整体上来说分为两大类： 基本数据类型、引用数据类型。
public class TypeDemo1 {
public static void main(String[] args) {
// 目标：掌握8种基本数据类型，用来定义变量。
// 1、整型
byte number = 98;
System.out.println(number);
short number2 = 9000;
int number3 = 12323232; // 默认
// 注意：随便写一个整型字面量，默认是int类型的，73642422442424虽然没有超过long的范围，但是它超过了本身int的范围了。
// 如果希望随便写一个整型字面量是long类型的，需要在其后面加上L/l
long number4 = 73642422442424L;
// 2、浮点型
//注意:
//随便写一个小数字面量，默认当成double类型对待的，
//如果希望这个小数是float类型的，需要在后面加上：F/f
float score1 = 99.5F;
double score2 = 99.8; // 默认定义方案。
// 3、字符型
char ch1 = 'a';
char ch2 = '中';
char ch3 = '国';
// 4、布尔型
boolean b1 = true;
boolean b2 = false;
// 引用数据类型：String.
// String代表的是字符串类型，定义的变量可以用来记住字符串。
String name = "我爱你";
System.out.println(name);
}
}
三、数据类型转换
3.1 自动类型转换
实际开发中可能存在将某种类型变量的值，赋值给另一个类型的变量；也可能存在多种数据类型的数据一起运算的情况。 在以上情况中，其实都会涉及到类型转换。类型转换的形式总体分为2种，一种是自动类型转换，一种是强制类型转换。 这里先学习自动类型转换。
自动类型转换：
自动类型转换指的是，数据范围小的变量可以直接赋值给数据范围大的变量
byte a = 12;
int b = a; //这里就发生了自动类型转换(把byte类型转换int类型)
原理：自动类型转换其本质就是在较小数据类型数据前面，补了若干个字节自动类型转换的各种形式：
public class Demo02 {
/*
类型之间的自动转换
自动类型转换
类型范围小的变量 可以直接被类型范围大的变量接收
*/
public static void main(String[] args) {
//自动类型转换演示
byte a = 12;// a是 byte 范围小的
int b = a;// 范围大的可以接收范围小的
System.out.println(b);
int c = 100;//int类型 范围比double小
double d = c;//自动发生类型转换
System.out.println(d);
// char 2个字节 表示的是 字符 但是 字符---数值 对应关系
// char --- int char对应的数值变成int
char ch = 'd';// 对应数值 是 100
int i = ch; // 变成int 100 完成了自动类型转换
System.out.println(i);
}
}自动类型转换还有另外一种形式，就是表达式的自动类型转换。所谓表达式指的是几个变量或者几个数据一起参与运算的式子。
如果同一个表达式中，出现不同类型的变量或者数据一起运算，这种情况下运算结果是一个什么数据类型呢？需要遵守下面的两条运算规则：
1.多种数据类型参与运算，其结果以大的数据类型为准
2.byte,short,char 三种类型数据在和其他类型数据运算时，都会转换为int类型再运算
package com.itheima.datatype;
public class Demo03 {
/*
类型之间的自动转换
自动类型转换
类型范围小的变量 可以直接被类型范围大的变量接收
表达式自动类型转换
如果数据参与运算 也存在自动类型转换 也遵循
byte、short、char -- int --long --- float --double
规则
1:byte short char 参与运算 自动变成int类型 。
2:多种数据类型参与运算，其结果以范围大的类型决定。
*/
public static void main(String[] args) {
// 1:byte short char 参与运算 自动变成int类型 。
byte b = 34;
short c = 88;
char ch = 'a';
// byte d = b+c;
// short dd = b+c;
// byte short char 只要参与运算 自动变成int
int i = b+c+ch;
// 多种数据类型参与运算，其结果以范围大的类型决定。
byte a1 = 33;
int a2 = 44;
long a3 = 55;
long a4 = a1+a2+a3;
// 每天花多少钱 10.5 9天花多少钱 10.5 * 9
double money = 10.5;
int day = 9;
double total = money*day;
/*
byte b1 = 3;
byte b2 = 4;
byte b3 = b1 + b2;
// 式子对还是不对 不对 原因 byte short char 运算时会变成int类型 所以用byte不能接收
两个byte类型相加 类型会自动提升为int 所以需要int类型接收
*/
byte b1 = 3;
byte b2 = 4;
// byte b3 = b1 + b2;
int b3 = b1+b2;
}
}
3.2、强制类型转换
你强行将范围大的数据，赋值给范围小的变量也是可以的，这里就需要用到强制类型转换。下面是强制类型转换的格式：
目标数据类型 变量名 = (目标数据类型)被转换的数据;
public class Demo04 {
/*
目标 学习 强制类型转换
*/
public static void main(String[] args) {
// 自动类型转换 小范围数据 被大范围变量接收
// 大范围数据 能被小范围变量接收吗？
int a = 20;
// byte b = a;//报错了
// 如果想强行 用小范围变量 接收大范围数据 可以 --这种强行的转换 称为 强制类型转换。
// 怎么做强制转换
//byte b = (byte)a;// 强制类型转换
byte b = (byte) a;// 目标数据类型 变量名 = (目标数据类型) 被转换的数据;
System.out.println(b);
// 强制类型转换 要 慎用 强制转换 会造成数据丢失
int i = 1500;
byte j = (byte) i;//强制类型转换
System.out.println(j);// -36 why ?
// 应用场景 小数 变 整数 舍去小数部分
double d = 135.6;
int m = (int)d;// 抹零
System.out.println(m);// 小数变整数 会丢失小数部分
}
}注意：强制类型转换的原理，其实就是强行把前面几个字节砍掉，但是有数据丢失的风险。
四、运算符
大家知道计算机是用来处理数据的，处理数据就少不了对数据的计算，想要对数据进行计算就必须用到运算符。
运算符就是参与运算的符号。Java提供的运算符有很多种，可以分为算术下面几种：
4.1 算术运算符
先从最基本的算术运算符开始学习，算术运算符有 + - * / % ，其中*表示乘法，/表示除法，%表示取余数。
需要我们注意以下几点：
1、 /: 两个整数相除，结果也是一个整数
2、 %: 表示两个数相除，取余数
需要我们注意的是：+符号除了用于加法运算，还可以作为连接符。+符号与字符串运算的时候是用
作连接符的，其结果依然是一个字符串。
代码演示：++
package com.itheima.coperator;
/*
算数运算符
+ 加法
- 减法
* 乘法
/ 除法
% 取余数
*/
public class OperatorDemo01 {
public static void main(String[] args) {
int a = 10;
int b = 2;
System.out.println(a+b);//12
System.out.println(a-b);//8
System.out.println(a*b);//20
System.out.println(a/b);//5
System.out.println(a%b);//0
// 除法运算 不能整除 得到只是商
int c = 100;
int d = 33;
System.out.println(c/d);//3.0303030303 ? 整数相除得到只能是整数
// c整数 1.0小数 整体是小数了
System.out.println(c*1.0/d);
System.out.println(c%d);
System.out.println("+号的妙用(+号左右两边连上了字符串 整体变成字符串)");
/*
+号左右两边连上了字符串 整体变成字符串
*/
System.out.println("abc"+5);// "abc5"
System.out.println("abc"+"5");//上下结果是一样的
int e = 5;
System.out.println("abc"+5);
System.out.println("abc"+e);
System.out.println("abc"+"5");
System.out.println("========================");
System.out.println(e+5);
System.out.println(e+"5");
// +号左右两边连上了字符串 整体变成字符串 做拼接
System.out.println("itheima"+e+'a');// itheima5a itheima5a
// "itheima5"+'a' "itheima5a"
System.out.println('a'+e+"itheima");// 104ithema 102itheima
// 'a'+5 97+5 102 "102itheima"
}
}
3. 2 自增自减运算符
需要我们注意的是，自增自减只能对变量进行操作，不能操作字面量。具体使用时也分为两种情况，如下：
1.单独使用：++或者--放在变量前面没有区别
int a =10;
a++; //11
--a; //10
System.out.println(a); //10
2.混合使用：++或者--放在变量或者前面运算规则稍有不通过
//++在后：先做其他事情，再做自增和自减
int a = 10;
int b = a++; //等价于 int b = a; a++;
//++在前：先自增或者自减，再做其他运输
int x = 10;
int y = --x; //等价于x--; int y = x; ++和--的用法：
package com.itheima.coperator;
/*
总结
++ 变量的值进行自增1
-- 变量的值进行自减1
++ -- 都可以用在 变量前面和变量的后面
在单独使用的 放前面和放后面 无所谓！！
如果参与运算
++在变量前 先自增再参与运算
++在变量后 先运算再自增
同理
--在变量前 先自减再参与运算
--在变量后 先参与运算再自减
*/
public class OperatorDemo02 {
public static void main(String[] args) {
int a = 5;
int b = 5;
//a++;//++在变量后面 完成自增
++a;//++ 在变量前面 完成自增
System.out.println(a);
--b;
System.out.println(b);
int i1 = 10;
// ++ 在前
int s1 = ++i1 + 1;
// ++ 在前 先自增 11 再参与运算
System.out.println(s1);// s1 12
int i2 = 10;
int s2 = i2++ +1;
// ++在后 先参与运算 10 再进行自增11
System.out.println(s2);// s2 11
// s1是12 s2是11
// 说明++在运算的时候 放在变量前 和放在变量后 不一样了！！！！！！
System.out.println("i1的值:"+i1);//11
System.out.println("i2的值:"+i2);//11
}
}
3.3 赋值运算符
基本的赋值运算符其实就是=号，意思就是把右边的数据赋值给左边的变量。
int a = 10; //将数据10赋值给左边的变量a
3.4 关系运算符
代码演示：
public class OperatorDemo4 {
public static void main(String[] args) {
// 目标：掌握关系运算符的基本使用。
int a = 10;
int b = 5;
boolean rs = a > b;
System.out.println(rs);
System.out.println(a >= b); // 要么a大于b,或者a等于b
System.out.println(2 >= 2); // true
System.out.println(a < b);
System.out.println(a <= b); // false
System.out.println(2 <= 2); // true
System.out.println(a == b); // false
System.out.println(5 == 5); // true
// 注意了：判断是否相等一定是用 == ，=是用来赋值的。
// System.out.println(a = b);
System.out.println(a != b); // true
System.out.println(10 != 10); // false
System.out.println(false ^ true ^ false);
}
}
3.5 逻辑运算符
逻辑运算符是用来将多个条件放在一起运算，最终结果是true或者false。
代码案例：
//需求1：要求手机必须满足尺寸大于等于6.95，且内存必须大于等于8.
//需求2：要求手机要么满足尺寸大于等于6.95，要么内存必须大于等于8.
public class OperatorDemo5 {
public static void main(String[] args) {
// 目标：掌握逻辑运算符的使用。
// 需求：要求手机必须满足尺寸大于等于6.95，且内存必须大于等于8.
double size = 6.8;
int storage = 16;
// 1、& 前后的条件的结果必须都是true ,结果才是true.
boolean rs = size >= 6.95 & storage >= 8;
System.out.println(rs);
// 需求2：要求手机要么满足尺寸大于等于6.95，要么内存必须大于等于8.
// 2、| 只要多个条件中有一个是true,结果就是true.
boolean rs2 = size >= 6.95 | storage >= 8;
System.out.println(rs2);
// 3、!取反的意思
System.out.println(!true); // false
System.out.println(!false); // true
System.out.println(!(2 > 1)); // false
// 4、^ 前后条件的结果相同时返回false，不同时返回true.
System.out.println(true ^ true); // false
System.out.println(false ^ false); // false
System.out.println(true ^ false); // true
System.out.println(false ^ true); // true
// 5、&& 左边为false，右边不执行。
int i = 10;
int j = 20;
// System.out.println(i > 100 && ++j > 99);
System.out.println(i > 100 & ++j > 99);
System.out.println(j);
// 6、|| 左边是true ，右边就不执行。
int m = 10;
int n = 30;
// System.out.println(m > 3 || ++n > 40);
System.out.println(m > 3 | ++n > 40);
System.out.println(n);
}
}3.6 三元运算符
三元运算符的格式：
关系表达式? 值1 : 值2;
public class OperatorDemo6 {
public static void main(String[] args) {
// 目标：掌握三元运算符的基本使用。
double score = 58.5;
String rs = score >= 60 ? "成绩及格" : "成绩不及格";
System.out.println(rs);
// 需求2：找出2个整数中的较大值，并输出。
int a = 99;
int b = 69;
int max = a > b ? a : b;
System.out.println(max);
// 需求3：找3个整数中的较大值。
int i = 10;
int j = 45;
int k = 34;
// 找出2个整数中的较大值。
int temp = i > j ? i : j;
// 找出temp与k中的较大值。
int max2 = temp > k ? temp : k;
System.out.println(max2);
}
}
3.7运算优先级
1161
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
