1，常见的进制
学习程度：
知道什么是二进制？什么是十进制？什么是八进制？什么是十六进制就可以了。
十进制：
现实生活中是十进制。每一位由0123456789组成，逢十进一。
二进制：
计算机中是二进制。每一位由0和1组成，逢二进一。
八进制：（了解）
每一位由01234567组成。逢八进一。
十六进制：（了解）
每一位由0123456789abcdef组成。逢十六进一。
2，在Java中如何表示二进制，十进制，八进制，十六进制
学习程度：
我给你一个数字，你能判断出来他是几进制的，而且能说出是否报错即可。
二进制：
是以0b开头的。b可以大写也可以小写。
System.out.println(0b10);//0b相当于就是一个标记。
//标记着后面的数字是二进制下的。
十进制：
默认前面什么都没有
八进制：
是以0开头的。
System.out.println(010);//前面的0相当于就是一个标记。
//标记着后面的数字是八进制下的。
十六进制：
是以0x开头的。x可以大写也可以小写。
System.out.println(0x10);//前面的0x相当于就是一个标记。
//标记着后面的数字是十六进制下的。
案例1：
System.out.println(0b123);//报错。
//因为0b表示着后面的数字是二进制。而二进制由0和1组成。没有其他数字
//在本案例当中出现了2和3，就是错误的。
案例2：
System.out.println(090);//报错
//因为以0开头的，表示后面的数字是八进制的。而八进制由01234567组成。
//在本案例中出现了9，所以错误。
案例3：
System.out.println(0x123);//正确没有问题，十六进制
//因为以0x开头，表示是十六进制，十六进制由0123456789abcdef组成。
//本案例中所有的数字没有超出范围。
3，进制之间的转换
手动计算不需要掌握。
咱们只需要掌握使用计算器来求出进制就可以了。
4，计算机的存储单位
一个数字如何存储到硬盘当中？
先把这个数字转成二进制，然后把二进制存到硬盘当中。
举例：99 ----> 0110 0011 —> 在把二进制存储到硬盘当中
知道计算机中最小的存储单元是什么？
是byte.
bit：在二进制中的一个0或者一个1。(比特位)
但是一个bit表示的内容太少了。所以我们会把8个bit分为一组。这一组就叫做byte。（字节）
而这个字节（byte）才是计算机中最小的存储单位。
知道bit，字节，KB,MB,GB,TB之间的转换关系？
8个bit = 1个字节
1024字节 = 1KB
1024KB = 1MB
1024MB = 1GB
1024GB = 1TB
5，变量
什么是变量？
就是在代码中，临时存储数据一个容器，也可以把他理解为一个箱子。但是这个容器当中只能存一个值。
变量的定义格式？
数据类型 变量名 = 数据值;
数据类型：表示这个变量以后只能存什么类型的数据。
变量名：就是这个容器的名字。以后想使用容器里面的内容时，直接使用变量名就可以了。
= ：就是把右边的数值赋值给左边的变量。
简单理解就是把这个数据放到容器当中进行存储。
数据值：真实的存到容器中的数据。
分号：表示语句的结束，就跟写作文时候用到的句号是一模一样的。
变量的命名规范
- 所有变量 、 方法 类名：**见名知意 **
- 类成员变量：首字母小写和驼峰原则 monthSalary
- 局部变量：首字母小写和驼峰原则
- 常量：大写字母和下划线：MAX_VALUE
- 类名：首字母大写和驼峰原则：Man,GoodMan
- 方法名:首字母小写和驼峰原则：run()，runRun()
举例1：
//定义一个整数类型的变量
//数据类型 变量名 = 数据值;
整数类型 a = 10;
//此时在代码当中，就会出现了一个容器。这个容器名字叫做a。这个容器只能存整数，现在这个容器里面已经有值了。值为10.
举例2：
//定义一个小数类型的变量
//数据类型 变量名 = 数据值;
小数类型 b = 10.2；
//此时在代码中，就会出现了一个容器，这个容器名字叫做b。这个容器只能存小数，现在这个容器里面已经有值了。值为10.2
6，Java中的数据类型
四类八种：
public class Demo01 {
public static void main(String[] args) {
//java分基本类型和引用类型
//八大基本数据类型
//整数4中数据类型
int num1= 10;
byte num2=20;
short num3=30;
long num4=30L;//Long类型后面要加L
//小数； 浮点数
float num5= 50.1F;//float类型后加F
double num6=3.66666566666666;
//字符
char name ='A';//字符只能一个
//字符串,String不是关键字，类
//String namea="yuweikang"
//布尔值;是/非
boolean flag=true;
//boolean flag=false;
}
}
整数类型： byte short int long
浮点类型：（小数） float double
字符类型： char
布尔类型： boolean
定义变量的案例：
//定义一个整数类型的变量
byte a = 10;
short b = 20;
int c = 30;
long d = 40L;//如果要定义long类型的变量，在数字的后面需要加L后缀。
//定义一个小数类型的变量
float e = 10.1F;//如果要定义float类型的变量，在数字的后面需要加F后缀。
double f = 20.2;
//定义一个字符类型的变量
char g = '我';
//定义一个布尔类型的变量
boolean h = true;
字符串的详细知识我们在就业班会学习。
目前，我们暂时只要知道如何定义字符串类型的变量即可。
public class Demo3 {
public static void main(String[] args) {
//整数拓展： 进制 二进制0b 十进制 八进制0 十六进制0x
int i=10;
int i2=010;//八进制0
int i3=0x10;//十六进制0x 0~9 A~F
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
System.out.println("------------------------------------");
//------------------------------------
//浮点数拓展? 银行业务怎么表示？ 钱
// BigDecimal 数学工具类
//------------------------------------
//float 有限 离散 有误差 大约 接近但不等于
//double
//最好完全避免使用浮点数进行比较
//最好完全避免使用浮点数进行比较
//最好完全避免使用浮点数进行比较
float f = 0.1f; //0.1
double d = 1.0/10;//0.1
System.out.println(f==d);//false 不一样
System.out.println(f);
System.out.println(d);
float d1 = 232323232323f;
float d2 = d1+1;
System.out.println(d1==d2);//trule 等于说明浮点数有问题
System.out.println("------------------------------------");
//------------------------------------
//字符拓展？
//------------------------------------
char c1 = 'a';
char c2 = '中';
System.out.println(c1);
System.out.println((int)c1);//强制转换
System.out.println(c2);
System.out.println((int)c2);//强制转换\
//所有字符本质还是数字
//编码 Unicode 表：(97=a 65= A) 2个字节 0~65536 Excel 2的16次方=65536
//U0000 uFFFF
char c3 ='\u0061';
// \u0000 转译
System.out.println(c3); //a
//转译字符
// \t 空格
// \n 换行
//...
System.out.println("你\t好");
//布尔值扩展
boolean flag = true;
if (flag==true){}//新手
if (flag){}//老手
//代码要精简易读
}
}
7，不同类型的范围
知道byte的取值范围：
-128 ~ 127
知道一下int的大概范围：
负21亿多 ~ 21亿多
默认使用的数据类型：
整数：int
小数：double
字符：char
布尔：boolean
字符串：String
取值范围由大到小的关系：
double > float > long > int > short > byte （包含了整数和小数）
四类八种在内存中所占用的字节个数：
byte ： 1
short ： 2
int ： 4
long ： 8
float ： 4
double ： 8
char： 2
boolean： 1 //因为只有两个值，true，false。所以一般不会考虑布尔类型在内存中占用字节个数。
关于变量的练习1：
public class Test{
public static void main(String [] args){
//大家好，我叫播仔，是传智播客与黑马程序员的吉祥物
//今年2岁了，身高1.5米
//爱好比较广泛（唱、跳、Rap、Java）
//另外，咱是一只公猴~
//播仔 2 1.5 唱、跳、Rap、Java 公
//定义一个字符串类型的变量去记录姓名
String a = "播仔";
//定义一个整数类型的变量去记录年龄
int b = 2;
//定义一个小数类型的变量去记录身高
double c = 1.5;
//定义一个字符串类型的变量去记录爱好
String d = "唱、跳、Rap、Java";
//定义一个字符类型的变量去记录性别
char e = '公';
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
System.out.println(e);
}
}
关于变量的练习2：
int a = 10；
System.out.println(a);//输出的是变量a里面的值10.
a = 30;//此时不是定义。
//而是把30赋值给变量a。
//变量a是已经存在的。所以把变量a里面原来的值覆盖了。因为变量里面同时只能存一个值。
System.out.println(a);//再次输出，就是修改之后值30.
关于变量的练习3：
public class Test {
public static void main(String[] args) {
int a;//定义一个变量叫做a，但是此时变量a里面没有值。
System.out.println(a);//变量里面没有值，就无法输出。所以这里报错。
{//单独出现的大括号，表示代码块。
//限制了变量的作用范围。
//变量在定义之后，只能在所属的大括号中使用。
int c = 20;
System.out.println(c);
}
c = 30;
System.out.println(c);
}
}
关于变量作用范围的练习：
public class Test {
public static void main(String[] args) {
int a;//定义在main后面的这个大括号中的。
//所以在main的整个大括号中都有效。
System.out.println(a);
}
}
public class Test {
public static void main(String[] args) {
{//代码块。
int c = 20;//变量c此时是定义在里面的单独的大括号中的。
//只能在这个大括号中才能使用。
//超出这个大括号就没有用了
System.out.println(c);//可以使用c
}
System.out.println(c);//此处已经超出了变量c定义的大括号，所以，此时就无法使用变量c了
//变量c其实在内存中就已经消失了。
}
}
public class Test {
public static void main(String[] args) {
{
int c = 20;//定义在里面的大括号中的。
System.out.println(c);//20
}//到了这一行代码的时候第一个c，就已经从内存中消失了。
//既然内存中都没有c了，那么我再定义一个行不行？肯定是可以的。
int c = 10;
System.out.println(c);//10
}
}
8，变量的总结注意点：
public class Demo08 {
//类变量 static
static int salary = 3000;
//属性：变量
//实例变量；从属于对象；如果不自动初始化，这个类型的默认值 0 0.0
//布尔值默认false
//除了基本类型其余都是null
String name="yuweikang";
int age =20;
//mian方法
public static void main(String[] args) {
//局部变量；必须声明和初始化值
int i= 10;
System.out.println(i);
//变量类型 变量名字 = new Demo08();
Demo08 demo08 = new Demo08();
System.out.println(demo08.age);
System.out.println(demo08.name);
//类变量 static
System.out.println(salary);
}
//其他方法
public void add(){
}
}
-
变量的作用范围
只能在所属的大括号中有效。代码运行到当前右大括号时，这个变量就会从内存中消失。
- 变量名不允许重复定义
public class Test {
public static void main(String[] args) {
int a = 10;//因为第一个a是定义在main后面的大括号中的，在整个main当中都有效。
int a = 20;//既然第一个a还没有消失，那么就不能再定义第二个变量a
}
}
- 变量在使用之前，必须要赋值。
- 定义float和long类型的变量时，需要在后面加后缀。
float a = 10.1F;
long b = 100L;
后缀可以大写也可以小写，但是个人推荐大写。
9，标识符
在代码中，我们自己起的名字。
类名，变量名，方法名（后面学）。
10，标识符的硬性规定
我们必须得这么做，不这么做，Java就报错。
- 由数字，字母，下划线，美元$组成.
- 不能以数字开头
- 不能是关键字
- 区分大小写的
11，标识符的软性建议
如果不这么干，程序不会报错。但是代码会显得不专业。
小驼峰命名法:
变量名，方法名：
一个单词：全部小写。 比如：name、age、gender
多个单词：从第二个单词开始，首字母大写。 比如：maxAge
大驼峰命名法:
类名：
一个单词：首字母大写。 比如：Test
多个单词：每个单词首字母都要大写。 比如：HelloWorld
综上所述：不管定义什么东西，都要见名知意。
建议写英文单词，如果英文单词不记得了，那么可以写拼音（不建议）或者是查阅有道词典（建议）。
12，隐式转换
判断技巧：
把取值范围小的，赋值给取值范围大的。
在代码中的触发时机：
-
直接赋值：
取值范围小的赋值给取值范围大的。不需要写代码额外实现，Java底层帮我们自动搞好。
比如：
第一个:
double d = 10;//此时10默认是int类型，交给取值范围大的double就ok的。底层自动操作。
第二个：
int i = 10;
double d = i;//i现在为int类型，交给取值范围大的double是ok的，底层自动操作。
-
不同数据类型参与计算：
小的数据类型会提升为大的，然后再进行计算。这个过程也是底层自动操作的。不需要我们额外写代码。
int i = 10;
long b = 100L;
float f = 20.0F;
double d = 100.0;
??? result = i + b + f + d;
//result变量应该是什么类型？double
//因为在上面的案例中，i,b,f,d当中最大的取值范围是double。所以最终就会提升为double。
byte，short，int类型的变量，在参与运算的时候，先提升为int，再进行计算。
byte b = 10;
short s = 20;
??? result = b + s;
//result变量应该是什么类型？int
//取值范围比int小的，在计算的时候，先提升为int，然后再进行计算。
byte b1 = 10;
byte b2 = 20;
??? result = b1 + b2;
//result变量应该是什么类型？int
//取值范围比int小的，在计算的时候，先提升为int，然后再进行计算。
byte b = 10;
short s = 20;
double d = 20.0;
??? result = b + s+ d;
//result变量应该是什么类型？double
//计算的过程中，发生了什么事情？
//因为b和s分别为byte和short类型，所以计算的时候先提升为int
//那么此时就是 int + int + double
//double的取值范围比int大，所以int需要再次往上提升为double
//最终 double + double + double 结果就是doouble类型。
byte b = 10;
float f = 10.1F;
??? result = b + f;
//result变量应该是什么类型？float double
float：因为变量b是byte类型的，所以在计算的时候先自动提升为int
然后 int去加上float。又因为float> int。所以，最终是float类
double：等号的右边最终计算之后，是float类型的，把一个小的给一个大的，是没有问题的。
核心技巧：
把取值范围小的，赋值给取值范围大的。是完全木有问题的。
double > float > long > int > short > byte //小数的取值范围要大于所有的整数。
13，强制转换
判断核心技巧 :
把一个取值范围大的，赋值给取值范围小的。（硬塞）
注意点：有可能会导致精度的丢失。（数字有可能跟原来的数字不一样）
在代码中的触发时机：
-
直接赋值
把一个取值范围大的变量或者值，赋值给一个取值范围小的变量。
int a = 50;
byte b = a;//此时代码会报错，因为把一个大的给一个小的。
//如果一定要这么干，请硬塞。
//byte b = (byte)a;//想转成什么类型，就在小括号中写什么类型就可以了。
int a = 300;
byte b = (byte)a;//大的赋值给小的，硬塞。
//有没有可能会出现什么问题？
//会出现。因为byte的取值范围是-128~127.而300已经超出了这个范围。
//所以此时，代码编译和运行的时候不会报错，但是数字会精度丢失。
//具体结果是什么，不需要关心，只要知道精度会丢失即可。
- 在运算的时候。把最终的结果进行赋值。
跟上面也是类似的，只不过是把最终的结果赋值给一个变量
byte b1 = 10;
byte b2 = 10;
byte b3 = b1 + b2;//如果操作让这行代码不报错？
//出错的原因：b1和b2都是byte类型的，在运算的时候会自动提升为int。
//把int赋值给byte，肯定报错了。
//修改方式1：
int b3 = b1 + b2;
//修改方式2：
byte b3 = (byte)(b1 + b2);//把b1和b2的结果进行了强制转换，变成了byte再进行赋值。
//注意点：b1和b2一定要加小括号
byte b3 = (byte)b1 + b2;
//如果不加小括号，那么就是先把b1强转成byte，然后再跟b2进行相加。
核心技巧：
把取值范围大的，赋值给取值范围小的。想要转成谁，那么就在小括号中写谁就可以了。
只不过强制之后，有可能导致精度丢失。
14，整数的常量优化机制
byte b = 10; //为什么没有报错。
触发时机：
等号的右边都是整数常量的时候。
比如: byte b = 3 +4;
比如:byte b = 100;
判断技巧：
会看等号右边最终的结果，是不是在左边的范围当中。
如果在，正常赋值，不会报错。
如果不在，就会报错。
//案例一：
byte b = 100;
因为等号的右边是整数100，触发了整数的常量优化机制。
此时会检查，100是否在byte的取值范围当中。
发现，在，那么直接赋值不会报错。
//案例二：
byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2;
//此时会不会触发整数的常量优化机制？不会
//因为此时等号的右边存在变量。
//只有等号的右边都是整数常量的时候才会触发。
//案例三：
byte b = 3 + 4;
//等号的右边都是整数常量，所以也会触发整数的常量优化机制。
//在编译的时候，已经是最终的结果7了。
//检查7是否在左边的范围当中。
//此时在，那么就正常，不会报错。
byte b = 100 + 200;
//报错的。
//因为最终的结果，300，超出了byte的取值范围。
15，小结
隐式转换，整数的常量优化机制，强制转换的小结：
1）看等号的右边，如果等号的右边都是整数常量。那么就触发整数的常量优化机制。
2）等号的右边有小数或者存在变量，那么就看是什么数据类型，来决定如何进行提升。（隐式转换）
如果比int小，先转成int，然后再算。
如果比int大，就会转成取值范围最大的那个。
3）如果我们强制要把大的塞给小的，请使用强制转换的格式。
16，字符的运算
char c = 'a';
System.out.println(c);//打印字符a
技巧：
字符在什么时候会去查ASCII码表。
- 字符参与计算
- 字符赋值给整数类型的变量或者赋值给小数类型的变量
int i = 1;
char c = 'a';
System.out.println(i + c);//此时字符参与了运算。就需要去查询在码表中a字符对应的数字是多少。
int i = 'a';//就会去查阅码表字符a对应的数字是多少。发现是97，就会把97赋值给变量i
System.out.println(i);//97
在ASCII码表中：
所有的都不需要记。
分享一个技巧：
如果我们要查一个字符对应的数字是多少。不需要记，写个代码打印一下就ok了。
![Java小案例——随机数猜测随机数猜测[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)