自学javase的回顾(2/10)

自学javase的回顾(2/10)

1. java数据类型和类型转换

2. java进制换算和字符编码

3. java内存基本单元—变量

4. java运算符

一. java数据类型和类型转换

java数据类型

1)java数据类型分为基本数据类型和引用数据类型?
A、基本数据类型包括八大基本数据类型
B、引用数据类型包括字符串String,类class,接口interface,数组array等

2)数据类型有什么用???
1、会给变量分配对应储存空间。(数据字面值必须和变量数据类型一致,否则报错)
2、决定了该数据是用于什么使用方向的。
这里注意1字节= 8 bit
在这里插入图片描述

java基本类型转换

1、 前提:在 java 中基本类型可以相互转换,boolean 类型比较特殊不可以转换成其他类型。
=号右边是优先运算的,因此是等号右边转左边,(系统默认整数数据打入都为int类型)

2、转换分为自动转换和强制转换: 大数据类型 变量名 = 小数据类型字面值/变量名;
【1】自动转换:容量小的类型会默认转换为容量大的类型
� byte–>short–> int–>long–>float–>double
char–>

【2】强制转换: 小数据类型 变量名 = (小数据类型)大数据字面值/变量名;
� 将容量大的类型转换成容量小的类型,需要进行强制转换。(否则损失精度且报错,不兼容类型)
� 注意1:大转小,字面值超过小类型最大值,无特权,要加强转符号,而且精度一定损失。一般比较小的数不会,比如下面的long p =100L不会。
� 注意2:大转小,字面值超大类型最大值,编译直接报错。(所以最好不要超过大和小类型的最大值,不然一个报错一个损精)。
� 注意3:大转小,除了long必强转之外,chart,byte,short有特权,但“仅限于是单单后面字面值并且没超范围时候”
� 注意4:特权就是:可以将整型字面值直接赋值给 byte,short,char(sun公司亲儿子们有特权)

�注意特别重点强调!!!:byte,short,char类型后面赋值必须得为具体字面值,并且在自己数据类型围内才可以不用强转,如果是赋值变为变量无特权了,一样需要强转。

下面有两段代码展示:好好理解,基础打好,耐心冷静

public class Shift
{    
	public static void main(String[]args){
		
		int b =32767;
		short a = (short)b;//可以打,但直接打short a = 32767;更快捷
		System.out.println(a);

		int x =32767;
		long y = x;//小转大可以直接转。。。。long    先看运算符等号右边是优先算的,所以int转long自动转
		System.out.println(y);

        //默认int = 32768;
		byte d =(byte)32768;//同上,只是byte超了范围要int强转了,而且损失精度,结果已经不是32768,所以
		short f = d;//超了short也可以小转大
		System.out.println(f);

		long p = 100L;//long转比int小的类型也是直接转因为int默认给了long,这里为默认的int转long
		byte k = (byte)p;//强转先看等号右边,因为优先级是先算等号右边线,这里为long转byte。
		System.out.println(k);


		short d = 666;//这里有特权因为是字面值,并且没超出自己范围,下面一个反例就是超了自己范围
		byte f = (byte)d;//无特权,因为不是字面值,赋值为变量就要恢复强转机制
		System.out.println(f);

		        
		short m = 32768;//直接报错,声明已经违反了语法规则,可以超出自己范围但要单行解决,并且损失精度.
		short n = (short)m;//纠正,直接short n =(short)32768,必须一行解决
		System.out.println(n);

		/*int i = 10;
		short a = i;这里会报错因为i 为int类型,特权只限字面值,语法上int和short不相等
		
		short a = 10;这里要和上面区别开单单直接赋值有特权int默认转short,但是上面语法有问题的。*/
public class Shift01//不同大小容量的数据类型转换
{       //第一long i = 100L;                                  long x = 100L;
       //首先系统默认 100是int的字面值,属于int转long小转大   int y = (int)x;属于大转小,long转int         
   //小转大自动直接转,包括long i =100L;属于自动转。

  //大转小除了long必强转之外,chart,byte,short有特权,但“仅限于是单单后面字面值并且没超范围时候”
  //(不是字面值一样加强转符比如“①是后面赋值是字母变量,②超出自己范围”),看下面反例12
//这三种类型公司规定在自己范围内不用,超范围就强转,最好必须一行解决,下面有反例1
//大转小,超小类型最大值,无特权,要加强转符号(看下面反例3),而且精度一定损失。一般比较小的数不会,比如上面的100L不会
//大转小,超大类型最大值,编译直接报错。(所以最好不要超大和小类型的最大值,不然一个损精一个报错)
	//long x = 2147483648L;long转int                       short y = (short)2147483648; int转short  
	//int y =(int)x; 超过小类型int最大值,变成-2147483648。  超了大类型int最大值,编译直接报错gg。 
    
	public static void main(String[]args){
		//int = 32768;这里有默认的一行,系统看到整数就默认32768是int了
		short i = (short)32768;//可以超自己范围,但必须当行解决加符号即可,不用再加一行赋值的。
		//如果是short,byte,chart会默认转,不用自己声明int,声明后反而麻烦,直接赋值即可,
		//大转小超小类型最大值,精度一定损失。超大类型最大值,编译报错。(所以最好不要超大小类型的最大值)

        //int = 32767;默认的一行
		short x = 32767;//没超自己范围,那么默认自己转,不会损失精度
		
		System.out.println(i);
		System.out.println(x);


				   
        //以下为反例
		int d = 1000;//大转小,这里报错short特权只局限于字面值,语法上short不能等于int,所以当不是字面值时候就要老老实实加强转符号
        short f = d;//,纠正:int d = 1000;  short f = (short)d;
		//纠正2直接打 short f = 1000(参考上面short x),因为系统默认了1000是int字面值,不用自己声明
		System.out.println(f);

		short o = 666;//大转小,这里有特权因为是字面值,并且没超出自己范围,
		byte w = (byte)o;//这里无特权,不是字面值的,精度损失了
        System.out.println(w);

        short y = 32767;//不算反例,不超范围声明和赋值可以分开,但要记住一定声明是那个数字。
	    short z =(short)y;//参考上面的short i
		//或者是short y = (short)32767;更快捷而已
           System.out.println(z);

        short j = 32768;//直接报错,超范围必须当行转,而且加强制符号
	    short k =(short)j;//纠正 short j = (short)32768;
		System.out.println(k);

        //默认int t = 32767;不算反例
		byte t =(byte)32767;//-1精度损失
		short u = t;//虽然32767超过了short最大值,但是精度损失变成-1,小转大直接转
		System.out.println(u);//这里混合运算大转小,小转大,最后结果-1

	}
}

在这里插入图片描述

3、运算顺序
【1】 byte、short、char 之间计算不会互相转换,首先先转换成 int
【2】多种类型混合运算过程中,首先先将所有数据转换成容量最大的那种,再运算
【示例代码】

public class DataTypeTest06 {
public static void main(String[] args) {
//出现错误,1000 超出了 byte 的范围
//byte a = 1000;

//正确,因为 20 没有超出 byte 范围
//所以赋值
byte a = 20;

//直接报错,同一作用域内变量名不能重复。
//short a = 1000;

//正确,因为数值 1000 没有超出 short 类型的范围
//所以赋值正确
short b = 1000;

//正确,因为默认就是 int,并且没有超出 int 范围
int c = 1000;

//正确,可以自动转换
long d = c;


//错误,出现精度丢失问题,大类型-->>小类型会出现问题。需要强转
//int e = d;


//将 long 强制转换成 int 类型
//因为值 1000,没有超出 小类型int 范围,所以不会出现精度损失,强制转换是正确的
int e = (int)d;


//因为 java 中的运算会转成最大类型来运算。
//而 10 和 3 默认为 int,所以运算后的最大类型也是 int
//所以是正确的
int f = 10/3;


//声明 10 为 long 类型
long g = 10;


//int h = g/3;
//出现错误,多个数值在运算过程中,会转换成容量最大的类型
//以下示例最大的类型为long,而 h 为 int,所以必须要出现大类型(long)到小类型(int)
//的强制转换,将会出现精度丢失问题

//int h = (int)g/3;
//可以强制转换,因为运算结果没有超出 int 范围
//long h = g/3;
//可以采用 long 类型来接收运算结果


//byte h = (byte)(int)g/3;
//出现精度损失问题,这里主要是优先级的问题
//有括号先算括号,将 g(long) 先转换成 int,然后又将 int 类型的 g 转换成 byte,最后 byte 类型的 g(byte) 和 3(int) 运算,
//因此它的运算结果类型就是 int,所以 int 数据赋值给 byte类型 ,报错且出现了精度损失问题
//三种解决方案,
//byte h = (byte)(int)(g/3);       扩起来最后的g/3,优先运算,最终再转为byte
// byte h = (byte)((byte)(int)g/3);  将最终结果整一个括起来,强制转为byte。
//int h = (byte)(int)g/3;;   直接采用 int 类型来接收最终运算结果


//byte h = (byte)g/3;
//不能转换,还有因为优先级的问题

//byte h = (byte)(g/3);
//可以转换,因为运算结果没有超出 byte 范围

short h = (short)(g/3);
//可以转换,因为运算结果没有超出 short 范围

short i = 10;
byte j = 5;
//short k = i + j;
//错误,short 和 byte 和int 运算,首先都会转换成 int 再运算
//所以运算结果为 int,int 赋值给 short 就会出现精度丢失问题
//可以将运算结果强制转换成 short
//short k = (short)(i + j);
//因为运算结果为 int,所以可以采用 int 类型接收
//int k = i + j;


char l = 'a';
System.out.println(l);
//输出结果为 a
System.out.println((byte)l);
//输出结果为 97,也就是 a 的 ascii 值。'a'-97 ,'A'-65

int m = l + 100;   //char字符参与运算时,会转为ascii值先。然后一起转为int运算。
//输出结构为 197,取得 a 的 ascii 码值,让后与 100 进行相加运算
System.out.println(m);
}
}

二. java进制换算和字符编码

1)进制换算

1、在计算机内部,所有信息都采用二进制表示,每个二进制由 0 和 1 两种状态,一个字节有 8
位,也就是由 8 个 0 或 1 构成,如果 short类型的 6 在计算机中是如何存储的,short 是两个
字节,那么 short 6 的二进制为:00000000 00000110,int 类型的 6 在计算机中存储为 32 位:
00000000 00000000 00000000 00000110

2、
【1】简单了解十进制到二进制的换算
规则:除 2 取余,逆序输出
如 10 进制 6 二进制换算方式为:
6/2=3 余 0
3/2=1 余 1
1/2=0 余 1
将余数逆序输出就是 6 的二进制表示:110,位数不够补零

【2】简单了解二进制到十进制的换算
规则:取出最后一位,从 2 的 0 次方开始乘,将得到的结果相加即可
如:二进制的 110 的十进制换算:
02 的 0 次方=0
1
2 的 1 次方=2
1*2 的 2 次方=4
110 的十进制为:0+2+4=6

2)字符编码

一、字符编码分类和发展
1、ASCII :字符编码 采用一个字节编码,主要针对英文编码 ‘a’-97 ,‘A’-65
(阿克斯码老祖宗,起源就是英文)
2、ISO-8859-1: 又称 latin-1,是国际化标准或组织 ISO 制定的,主要为了西欧语言中的字符编码,和ASCII 兼容
(欧美英文为主)
3、GB2312/GBK/GB18030 :主要是汉字编码,三种编码从容量上看是包含关系
(中国人强大了)
4、Unicode 如今Unicode统一了全世界上的所有文字编码,unicode 有几种实现:UTF-8,UTF-16,UTF-32。(世界合作开发)
【UTF-8 存储格式(UTF8 主要就是为了节省空间)】

二、以下为Char 字符的测试

public class CharTest {
public static void main(String[] args) {
//不能采用双引号声明字符类型,必须采用单引号声明字符类型
//char c1 = "a";
//声明一个字符
char c1 = 'a';
//char 类型可以存放一个汉字,java 中的 char 使用 utf-16 编码
//所以 char 占用两个字节
char c2 = '中';
System.out.println(c1);
System.out.println(c2);
}
}

三、ps:字符’ a '和字符串" a "区别?????????

1、数据类型不同:字符’a’是基本数据类型,字符串“a”是引用数据类型。

2、占用字节大小不同:‘a’占用2字节," a “占用4字节。” a "字符串包括了:字符’a’ + 隐含‘\0’这个字符,
因此" a "字符串它有两个字符组成。

3、运算方法不同,字符在进行运算时是当整数处理的,可以存在堆或者栈内存,
字符串不能参与运算,字符串本身是个地址,存放在方法区常量池。

三. java内存基本单元—变量

1、变量本质是 java 中的一个最基本的储存单元,也就是内存中的一块区域(内存空间套娃变量空间),Java 中的变量有四个基本属性:数据类型,变量名,存储单元和变量值
� 变量的数据类型:可以是基本类型和引用类型(必须包含类型)
� 变量名:合法的标识符,小写见名知意。
� 存储单元:存储单元大小是由数据类型决定的,如:int 为 4 个字节 32 位bit
� 变量值:在存储单元中放的就是变量值(如果是基本类型放的就是具体值,如果是
引用类型放的是内存地址,如果 null,表示不指向任何对象,代表空指针)
变量的声明格式:数据类型 +变量名 = 字面值;

2、变量分类:成员变量(实例+静态) 和 局部变量

3、变量作用?一个单元空间,空间大小由变量的数据类型决定分配,最终去存储数据字面值

4、变量注意点:
【1】局部变量必须初始化,变量初始化的过程就是赋值,变量声明后必须初始化。(成员变量带有有默认值)
【2】在同一作用域中,变量名不能重复,只能声明一次,但变量名可以给予多次赋值。

在这里插入图片描述

四. java运算符

在这里插入图片描述
在这里插入图片描述

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 1024 设计师:上身试试 返回首页