自学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、决定了该数据是用于什么使用方向的。

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
12 的 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运算符