JAVA零基础入门笔记(二)

1，常见的进制

学习程度：

知道什么是二进制？什么是十进制？什么是八进制？什么是十六进制就可以了。

十进制：

现实生活中是十进制。每一位由0123456789组成，逢十进一。

二进制：

计算机中是二进制。每一位由0和1组成，逢二进一。

八进制：（了解）

每一位由01234567组成。逢八进一。

十六进制：（了解）

每一位由0123456789abcdef组成。逢十六进一。

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

学习程度：

我给你一个数字，你能判断出来他是几进制的，而且能说出是否报错即可。

二进制：

是以0b开头的。b可以大写也可以小写。System.out.println(0b10);//0b相当于就是一个标记。//标记着后面的数字是二进制下的。

十进制：

默认前面什么都没有System.out.println(10);//前面什么都没有，就是十进制。

八进制：

是以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.什么是变量？

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

2.变量的定义格式？

数据类型 变量名 = 数据值;数据类型：表示这个变量以后只能存什么类型的数据。变量名：就是这个容器的名字。以后想使用容器里面的内容时，直接使用变量名就可以了。= ：就是把右边的数值赋值给左边的变量。简单理解就是把这个数据放到容器当中进行存储。数据值：真实的存到容器中的数据。分号：表示语句的结束，就跟写作文时候用到的句号是一模一样的。

举例1：

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

举例2：

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

6，Java中的数据类型

四类八种：

整数类型： byte[1] short[2] int[4] long[8]

浮点类型：（小数） float[4] double[8]

字符类型： char[2]

布尔类型： boolean[1]

定义变量的案例：

//定义一个整数类型的变量
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;

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

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

String s = "你好你好";//定义了一个字符串类型的变量。

7，不同类型的范围

知道byte的取值范围：

-128 ~ 127

知道一下int的大概范围：

负21亿多 ~ 21亿多

默认使用的数据类型：

整数：int小数：double字符：char布尔：boolean字符串：String

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

double > float > long > int > short > byte  （包含了整数和小数）

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

byte ：		1short ：		2int ：		4long ：		8float ：		4double ：	8char：		2boolean：	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了。

System.out.println('a' + 0);

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！