JavaSE_02_基本数据类型

右京先生

于 2021-04-19 14:49:09 发布

阅读量164

点赞数

分类专栏： JavaSE 文章标签： java javase

本文链接：https://blog.csdn.net/jwsl999/article/details/115864633

版权

JavaSE 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1.IDE集成开发环境

参考文档

2.基本数据类型

补充:2进制一般首位为符号位，首位1 负数  首位0  整数
程序中表示各种常用数据类型的数据有哪些:
1.数值:
整数(
    byte 1个字节, （1个字节占用8个2进制位）1000 0000 -  0111 1111 [-128,127] [-2^7,2^7-1]
    short 2个字节, 2个字节占用16个2进制位  ..................     			[-2^15,2^15-1]                   
    int 4个字节,  ... 32个2进制位 [-2^31,2^31-1]  
    long 8个字节) ... 64个2进制位 [-2^63,2^63-1] 
   
    常用int（超过21亿多的使用long） 重点

小数(float 4个字节 单精度浮点型 (精确度要求低), 
    double 8个字节 双精度浮点型 (精确度要求高)
    ) 
    常用double (重点)
	
2.非数值
 	一般关系运算符，逻辑运算符场景(后续介绍)
	boolean: true(肯定的，正确的)/false (否定的，不正确)  1个字节
  	char:字符类型  2个字节 无符号 	0-2^16-1 
        
	

上述8中类型称之为基本数据类型
特点:占用的空间是固定的，较小。

3.引用类型（简单了解）

引用类型大小不固定的，内存存储结构与基本类型完全不同,相对于基本类型更为复杂(内存结构后续详解)
引用类型:除了基本类型之外所有数据都属于引用类型（后续详解）
常用的引用类型:
String:字符串类型 (用双引号引起来的内容称之为字符串类型) "123" ,"123.456";（重点）
注意:字符串中可以往双引号中放任意长度的内容...
Scanner：开发人员编写好的一个工具类(后续讲解其用法)

4. 变量(重点)

1.概念
本质:变量的本质是内存中分配的一个空间
理解：根据变量的名字可以在找到放在内存空间的数据(获取)，还可以修改空间中的数据(修改)
扩展思维:
所谓变量还可以理解成就是数据的一个别名。。。
比如保存一个用户的名字 ，我们会使用name这个变量名来保存名字
比如保存一个身份证号码, 我们会使用idCard来保存。。。
phoneNum=10086
password=10086
idCard=....
--------------------------------------------------------------------------------------
2.变量的使用
<1>.先声明，后赋值
int age;//根据数据类型 在内存中开辟一个空间(4个字节)
age=18;（将18这个数据放在内存空间中）
0000 0000 0000 0000 0000 0000 0001 0010  ==》18

<2>.声明和赋值同时进行
double money=1888.88;//根据数据类型 在内存中开辟一个空间(8个字节)，将数据放入空间

<3>同时声明多个变量
int i,j,k=100;
i=?  j=?  k=?
i,j 只是声明了(只是开辟了空间，但是没有将数据放入到空间中) 
k 声明了空间，并且赋予了初值 100

注意:
1.没有赋予初值的变量，不能使用，否则编译不通过(使用开发工具，报错);
int age;
System.out.println(age);//错误 编译不通过

2.同一个变量不能重复声明，但是可以多次使用。
int age=18;
int age=19;错误 重复声明

但是可以重复使用
int age=18;
age=28;
age=38;//正确的

3.变量如果没有声明不能使用
age=18;//未声明 直接赋值
改正
int age;//先声明
age=18;//后赋值
总结: 
数据类型  变量名=数据;

5.标识符（重点）

1.项目名:（java project）
命名规则:一般由英文单词组成(看起名知其意)如果由多个单词组成首字母都大写
比如：WoniuShoppingDemo,WoniuFilm,
2.包名:一般由小写字母组成(package)  高内聚(物以类聚)
com.it公司简称.类型
3.类名:
一般由英文单词组成(看起名知其意)如果由多个单词组成首字母都大写
UserService,GoodsService...
变量名:
<1>.仅仅满足变量的命名要求 （满足此要求，编译能通过）
a.名字的组成由字母数字，下划线_,$，组成
b.数字不能放在首位  1num 错误
c.不能使用关键字(public,static,void class,int,....)
--------------------------------------------------------------------------------------
<2>.企业中变量命名规则
a.看其名知其意(英文)
b.小驼峰命名:
	1.名字的组成如果由多个单词组成第一个单词首字母小写，其余单词首字母全部大写
	studentName,userAge
	2.名字由1个单词组成，首字母小写即可
	name,age

补充1 （注释）

注释的特点:程序执行的时候会自动跳过被注释的内容
注释的作用:用来解释一些复杂难懂的特殊代码或者是代码块。
1.// 你要注释的内容 (单行注释) 重点
2./*
	你要注释的内容
*/ (重点)
3.文档注释 (用来解释方法或者类) 一般写在方法或者类上面 
/**
	@author：作者
	@description: 描述
	@updateTime: 修改时间
	@param 
*/

补充2(char字符类型)

char:字符类型 (2个字节) 0-2^16-1  用单引号引起来的单个任意符号称之为字符。 '牛' '啊' '1' '2'
    
ascII编码 (美国信息交换的标准代码) 将一些特殊符号(数字，字母,特殊符号...总共256个) 1个字节  8个2进制位
0000 0000 -1111 1111  [0,255] 可以表示256个特殊符号
256个特殊符号，正好对应256个2进制的值 符号与2进制的值一一对应

Unicode编码(java默认的编码 万国码) 对ascII 的一个扩展 2个字节
0000 0000 0000 0000 -1111 1111 1111 1111 [0,65535] 保留了ascII码值 还扩展了汉字一起其他国家的语言或者特殊符号。
注意:
1.使用字符类型只能表示单个的任意符号。。。
2.底层计算的时候根据Unicode编码进行换算。。。

6. 隐式转换

自动转换:默认进行的
<1>.整数之间转换看空间 空间小的转成空间大的默认进行
<2>.整数与小数之间的转换 看的精确度  整数转小数都是默认进行的
<3>.小数与小数之间的转换 也是看精确度  小的转大的都是默认进行的
<4>.char类型转整数实际上是将符号对应的Unicode的编码进行转换的
Unicode编码几个重要范围
A-ZUnicode编码范围:65-90
a-zUnicode编码范围:97-122
0-9Unicode编码范围:48-57
汉字Unicode编码的范围:19968-40896    
-----------------------------------------------------------------------------------------
		byte num1 = 100;
		short num2 = num1;//默认转换
		int num3 = num2;//默认转换
		long num4 = num3;//默认转换
		
		float num5 = num4;//默认转换
		double num6 = num5;//默认转换
		char c1 = 'a';
		int  cNu m= c1;//Unicode编码 对应的10进制 赋值给cNum  默认进行
		System.out.println(cNum);    
---------------------------------------------------------------------------------------

7. 强制转换

需要进行强制类转换,无法默认进行,有如下几种应用场景
<1>.整数与整数之间 空间占用大的转成 空间占用小的 无法自动转换，不强转编译不通过
	1.先缩小内存空间 （通过强制改变其数据类型）
	2.然后在放入小的空间
举例子理解:
long num1 = 100L;
int num2 = num1; //编译不通过
//改正
int num2 = (int)num1;

<2>.小数转整数会导致精度丢失 所以需要强制转换成整数
double num = 188.88;
int num1 = (int)num;
<3>.小数与小数之间 double转float也需要强制转换

注意:如果不进行强制转换，编译不通过

扩展一:
float类型的定义:
float num1 = 123.456;//编译不通过
注意:123.456程序中默认的类型是double类型  
解决方案一:将double强制转换成float类型
float num1 = (float)123.456;
解决方法二:直接定义float类型的小数
float num1 = 123.456f;

扩展二:
long类型的定义: 8个字节    
long num1 = 100;//正常

//10000000000 超过了int 类型的取值范围 没有超过long类型的取值范围
//10000000000 程序执行时默认类型是int类型
long num2 = 10000000000;//编译不通过
解决方案:
long num2 = 1000000000000L;//加个L才是定义long类型的数据...

总结:
定义 float f = 123.456f;
定义 long l = 100L;

补充一个赋值运算符

=: 赋值运算符
将右边数据的内存地址 赋值给左边这个变量

8. 算术运算符(重点)

算数运算符:+ - * / % 
+ - * / 
<1>.数值之间使用
a.小数与小数之间进行运算最终的结果为 精确度更高的类型
double num1 = 123.456;
float num2 = 456.789f;
num1+num2? double 类型
b.小数与整数之间做运算，一定返回小数类型
long num3 = 100L;
float num4 = 123.456f;
num3+num4？ float小数

c.整数与整数之间做运算 最终的结果返回 字节占用空间最大的整数类型
int number1 = 100;
long number2 = 200L;
number1+number2？ long类型

<2>任何数据类型与字符串类型做+ 运算 最终返回的结果一定是字符串类型最终的结果字符串与数据前后首位相连
11+""+22  类型字符串类型  "1122"
  String str1 = "abc";
		int number3 = 110;
		int number4 = 120;
		String num11 = str1 + (number3+number4);//"abc230"
		System.out.println(num11);  

<3>% 求余数
int num1 = ?;
int num2 = ?;
1.num1<num2 ===> num1%num2=num1 ===>   6%7=6  6%12=6  99%100=99;
2.num1>num2  num1%num2=? 
<1>.一个数它是奇数还是偶数?
   奇数特点 对2取余数为1     
   偶特点  都能够被2整除  对2取余数为0
<2>判断是否是一个闰年
	int year=? ;
	a.年份能够被4整除但是不能被100整除  这样的年份就是闰年 比如2020年就是一个闰年 (366天 2月 有29天)
  	year%4 为0 并且 year%100 不为0    
    或者
    b.年份能够被400整除的 这样的年份也是闰年 比如 2000年 
	year%400 为0 	
	
总结:求余 % 可以用来判断是否能够整除某个数 ，余数为0说明可以整除  不为0不能整除

int num=1234;
//分别 取出个位  十位  百位 千位 打印在控制台?  （提示:%） 
int gNum=num%10;//(1230+4)%10=1230%10+4%10=0+4%10=4
int sNum=num/10%10;
int  bNum=num/100%10;
int qNum=num/1000%10;

举一反三:5000秒转成 多少小时  多少分钟 多少秒？

9. 关系运算符(重点)

关系运算符:>, >=,<,<=,==,!=
注意:
1.使用关系运算符最终返回的结果是一个boolean类型的数据 
2.关系成立返回true 不成立返回false
比如:
4>=5 false  
<1>.判断一个年龄是否成年
int age=?;
age>=18  //输入的是 20 返回 true  输入 16 返回false

<2>.判断一个数是否是偶数
int number=?; 
 number%2 == 0  //输入的是一个偶数  返回true  输入奇数  返回false 
    
5==5 ? true
5!=5 ? false

10. 逻辑运算符（重点）

使用逻辑运算符最终返回的结果一定是boolean

短路运算(掌握这个即可)
&&:与
条件判断1 && 条件判断2
必须满足 条件判断1 和条件判断2 都为 true  条件判断1 && 条件判断2 才会为true
否则为 false 

 条件判断1 && 条件判断2  
 如果条件判断1为false 最终的结果直接返回false 不会只再判断条件判断2了
 
||:或
条件判断1 || 条件判断2
条件判断1 和条件判断2  至少有一个为 true 条件判断1 || 条件判断2为 true
否则为 false
条件判断1为true  直接返回true 不会判断 条件2了
    
!:非
条件判断1 为true    !条件判断1 为 false
--------------------------------------------------------------------------------------
<1>判断是否是一个闰年
	int year=? ;
	a.年份能够被4整除但是不能被100整除  这样的年份就是闰年 比如2020年就是一个闰年 (366天 2月 有29天)
  	(year % 4 == 0  && year % 100 != 0)    
  ||
    b.年份能够被400整除的 这样的年份也是闰年 比如 2000年 
	(yea r% 400 == 0) 	
  最终结果为:
  (year % 4 ==0  && year % 100 !=0 ) || (year % 400 == 0) 	    
 -------------------------------------------------------------------------------   
非短路运算符 (了解)
&:与 
必须满足 条件判断1 和条件判断2 都为 true  条件判断1 & 条件判断2 才会为true
 条件判断1 & 条件判断2  
 如果条件判断1为false 在判断条件判断2 最终的结果直接返回false 

|:或
同上。。。

扩展:
userName!=null && userName.equals(""); //永远不会出现空指针异常

11. 自增运算符

++:自加1
--:自减1
num++: 先使用 然后再对自身进行自加1
++num：先对自身加1，然后再使用
int num1=10;
int num2=20;
int num3=num1++;//num3=num1; num1=num1+1;
int num4=++num2;//num2=num2+1; num4=num2;
最终的结果 
num1 11
num2 21
num3 10
num4 21

-- 同理

12.复合赋值运算符(了解即可)

int num=10;
num+=5;// num=num+5;//num=15
num-=5;// num=num-5;//num=10
num*=5;// num=num*5;// num=50  
num/=5;// num=num/5;// num=10
num%=5;// num=num%5;// num=0

13.位运算符(了解一下)

&：2进制运算中如果都是1才会返回1
|：2进制运算中只要有一项为1 就会返回1
^：2机制运算中 如果相反 才会返回1
<<： 左移 n位  数值扩大了2^n次方倍
>>： 右移 n位  数值缩小了2^n次方倍
		/**
		 * 1代表true 
		 * 0代表false
		 * 	 0001 
		 * 	 0011 
		 * --------- 
		 *   0001  = 1
		 * */
		System.out.println(1&3);//与运算
		/**
		 * 0001
		 * 0011
		 * -----
		 * 0011= 3
		 * */
		System.out.println(1|3);//或
		/**
		 * 0001
		 * 0011
		 * -----
		 * 0010= 2
		 * */
		System.out.println(1^3);//2 异或
		System.out.println(3<<2);//12 左移
		System.out.println(16>>2);//4 右移

14.单分支和三元运算符

结构1:
if(条件判断或者一个boolean类型的数据){ 
	//代码块1
}
1.如果if括号中的最终结果返回的是true 执行一次 代码块1
2.如果if括号中最终返回的结果是false 直接跳过if语句 (不会执行代码块1)
结构2:
if(条件判断或者一个boolean类型的数据){
	//代码块1
}else{
	//代码块2
}
1.如果if括号中的最终结果返回的是true 执行一次 代码块1  跳出if语句块
2.如果if括号中最终返回的结果是false  执行一次代码块2  跳出if语句块

<1>.定义一个年龄 判断是否成年？
int age=20;
if(age>=18){
    System.out.println("恭喜你成年，可以去网吧上网了...");
}else{
    System.out.println("很遗憾，你未成年...");
}
<2>.定义一个整数 判断是奇数还是偶数?
  int num=20;
if(num%2==0){
    System.out.println(num+"是一个偶数...");
}else{
     System.out.println(num+"是一个奇数...");
}
 <3>.定义一个年份 year  判断是平年还是闰年?
 int year=2020;

15.多分支及嵌套判断

定义您的存款 金额，根据存款金额购买车(单位:万元)?
double money=10000;
多条件判断 多分支
<1>.假设你的存款超过 5000万买个 买一个劳斯莱斯
<2>.假设你的存款不足5000万  但是超过1千万  买一个 911
<3>.假设您的存款不足1000万  超过500万     买一个 宝马x6
<4>.不足500万  但是超过10万  买一个 思域
<5>.不足10万 好好学编程，以后争取买个思域。。。
---------------------------------------------------------
多分支
-------------------------------
1.查看余额
2.存取
3.取钱
4.转账
5.退出系统
------------------------------
单分支无法解决所以采用多分支解决
多分支结构:
if(条件判断1){
    //代码块1
}else if(条件判断2){
    //代码块2
}else if(条件判断3){
    //代码块3
}else{//最后一个写else即可
    //代码块4
}
System.out.println("程序结果....");
<1>.当条件判断1 true  执行 代码块1  然后执行 程序结束...
<2>.当条件判断1  false 才会判断条件判断2 true 执行代码块2  程序结束...
<3>.当条件判断1，条件2都为 false   才会判断条件3  true 执行代码块3 程序结束
<4>.当条件1,2,3都为false  才会执行代码块4  程序结束....
    
 注意:条件判断一般都是由关系运算符 以及逻辑运算符组成   
    
<1>.
     double money=10000;
    if(money>5000){
		System.out.println("随便买辆劳斯莱斯开开....");
    }else if(money>1000){//能执行money>1000 说明 money<=5000
        System.out.println("随便买辆911开开....");
    }else if(money>500){// money<=1000
         System.out.println("随便买辆宝马x6开开....");
    }else if(moeny>10){//money <=500
         System.out.println("随便买辆思域开开....");
    }else{
         System.out.println("好好学编程，以后争取买个思域....");
    }