文章目录

1，常见的进制
- - - - 学习程度：
      - 十进制：
      - 二进制：
      - 八进制：（了解）
      - 十六进制：（了解）
2，在Java中如何表示二进制，十进制，八进制，十六进制
- - - - 学习程度：
      - 二进制：
      - 十进制：
      - 八进制：
      - 十六进制：
      - 案例1：
      - 案例2：
      - 案例3：
3，进制之间的转换
4，计算机的存储单位
- - - - 一个数字如何存储到硬盘当中？
      - 知道计算机中最小的存储单元是什么？
      - 知道bit，字节，KB,MB,GB,TB之间的转换关系？
5，变量
- - - - 什么是变量？
      - 变量的定义格式？
6，Java中的数据类型
7，不同类型的范围
- - - - 知道byte的取值范围：
      - 知道一下int的大概范围：
      - 默认使用的数据类型：
      - 取值范围由大到小的关系：
      - 四类八种在内存中所占用的字节个数：
      - 关于变量的练习1：
      - 关于变量的练习2：
      - 关于变量的练习3：
      - 关于变量作用范围的练习：
8，变量的总结注意点：
9，标识符
10，标识符的硬性规定
11，标识符的软性建议
- - - - 小驼峰命名法:
      - 大驼峰命名法:
12，隐式转换
- - - - 判断技巧：
      - 在代码中的触发时机：
13，强制转换
- - - - 判断核心技巧 :
      - 在代码中的触发时机：
14，整数的常量优化机制
- - - - 触发时机：
      - 判断技巧：
15，小结
16，字符的运算

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，变量

什么是变量？

就是在代码中，临时存储数据一个容器，也可以把他理解为一个箱子。但是这个容器当中只能存一个值。

变量的定义格式？

数据类型变量名 = 数据值;

数据类型：表示这个变量以后只能存什么类型的数据。

变量名：就是这个容器的名字。以后想使用容器里面的内容时，直接使用变量名就可以了。

= ：就是把右边的数值赋值给左边的变量。

简单理解就是把这个数据放到容器当中进行存储。

数据值：真实的存到容器中的数据。

分号：表示语句的结束，就跟写作文时候用到的句号是一模一样的。

举例1：

//定义一个整数类型的变量
//数据类型 变量名 = 数据值;
整数类型 a = 10;
//此时在代码当中，就会出现了一个容器。这个容器名字叫做a。这个容器只能存整数，现在这个容器里面已经有值了。值为10.

举例2：

//定义一个小数类型的变量
//数据类型 变量名 = 数据值;
小数类型 b = 10.2；
//此时在代码中，就会出现了一个容器，这个容器名字叫做b。这个容器只能存小数，现在这个容器里面已经有值了。值为10.2

6，Java中的数据类型

四类八种：

整数类型： 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;

字符串的详细知识我们在就业班会学习。

目前，我们暂时只要知道如何定义字符串类型的变量即可。

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 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了。

文章目录

1，常见的进制

学习程度：

十进制：

二进制：

八进制：（了解）

十六进制：（了解）

2，在Java中如何表示二进制，十进制，八进制，十六进制

学习程度：

二进制：

十进制：

八进制：

十六进制：

案例1：

案例2：

案例3：

3，进制之间的转换

4，计算机的存储单位

一个数字如何存储到硬盘当中？

知道计算机中最小的存储单元是什么？

知道bit，字节，KB,MB,GB,TB之间的转换关系？

5，变量

什么是变量？

变量的定义格式？

6，Java中的数据类型

7，不同类型的范围

知道byte的取值范围：

知道一下int的大概范围：

默认使用的数据类型：

取值范围由大到小的关系：

四类八种在内存中所占用的字节个数：

关于变量的练习1：

关于变量的练习2：

关于变量的练习3：

关于变量作用范围的练习：

8，变量的总结注意点：

9，标识符

10，标识符的硬性规定

11，标识符的软性建议

小驼峰命名法:

大驼峰命名法:

12，隐式转换

判断技巧：

在代码中的触发时机：

13，强制转换

判断核心技巧 :

在代码中的触发时机：

14，整数的常量优化机制

触发时机：

判断技巧：

15，小结

16，字符的运算

继续阅读