java学习笔记(一)数据类型

基本数据类型 8个

类型	数量	数据类型	字节祥情
整形	4	byte	8bit
		short	16bit
		int	32bit
		long	64bit
浮点型	2	float	32bit
		double	64bit
字符型	1	char	16bit 2字节 Unicode编码 0-65535
布尔型	1	boolen	1bit  true false

1. 整型

          1.byte
               字节型------>8个bit 敏感单元位
               1byte == 8bit 0 0000000 256种组合
               用第一个bit位置来记录符号 0正数 1负数
               数值的范围 -2的7次方 ~ 2的7次方-1
                                                  -128 ~ 127
         2.short　　　　
               2字节 == 16bit     65526种                   -32768     32767
          3.int
               4字节 == 32bit          -2147483648      2147483647
          4.long
               8字节 == 64bit

2.浮点

    1.float
         4字节 == 32bit
         0 000000000 00000000000000000000
    2.double

字符char

字符? ‘a’ ‘+’ ‘我’ ‘5’
字符中数字和整数的数字冲突
为了以示区分 每一个字符的前后各加单引号
为什么英文和符号和数字是一个字节
为什么中文是两个字节?
ASCII 美国信息交换标准代码
a------00000000------97
a------00000000------97
a------00000000------97
字母 数字 符号
26*2 + 10 + 100 字节256种组合

布尔型 boolen

引用数据类型

数组[]    类class(抽象类abstract class)     接口interface    枚举enum   注解@inte

常量

常量代表的是程序运行过程中　　不能再次改变的值

###常量的作用*

1. 固定的值　代表计算古城中经常用到的值
　　　　　　　　变于程序计算
　　　　　　　　圆周率 3.1415926…
　　2. 用来代表一个含义
　　　　　　　　UP==> 1 2 3 4 分别代表上下左右四个方向
　　　　　　　　
###什么样的值算是常量???
　　1.固定不变的值 算作常量
　　　　1　3.14　‘a’　true
　　　　可以认为所有的基本类型的值 固定不变 是常量
　　　　
　　2.特殊的常量
　　　　“abc” —>String
　　　　String是一个引用数据类型，它的值很特殊 可以简单的视作常量
　　　　
　　3.自己创建的空间　存储一个值 让他固定起来　不能改变
　　　　fina int UP=1;

变量

变量指的是　程序执行过程中可以改变的
　　变量是一个内存空间(小容器)
　　变量空间在创建(声明)的时候　必须指定数据类型　变量空间的名字
　　变量的空间　 里面只能存储一个内容(值 引用)
　　变量空间的内容可以改变

创建变量时 需要注意命名的问题

命名的规则

字母(大小写敏感感)　数字(0-9不允许开头)　符号(英文符号_ $)　中文(不推荐)

命名的规约

类名字　首字母大写 如果两个以上的单词　　所有首字母大写
　　　　　　　　SuperPerson
　　　　变量名　首字母小写　如果两个以上的单词　　之后的首字母大写
　　　　　　　　superPerson
　　　　　　　　遵循驼峰式命名规约
　　　　所有的名字都需要见名知义
　　　　　　　　为了增强程序的可读性

变量如何创建/声明

数据类型 变量名字;
　　int a;
　　String b;

需要注意：
　　变量是一个空间 可以只创建空间 里面不存放内容
　　变量空间创建后是没有默认内容 空的
　　空的变量空间不能拿来使用 编译错误
　　
　　byte x; //声明一个变量空间 空间的名字是x 空间内要求存储的类型是byte整数
　　x = 1; //讲一个1赋值到x空间内进行存储
　　
　　计算机底层做了什么事情
　　1.x是什么？ 变量空间 存在哪儿？
　　2.1是什么？ 1是常量 存在哪儿？
　　3.=是什么？ =是赋值　做了什么？
　　
　　计算机的硬件组成
　　主板 cpu 声卡 显卡 网卡 电源
　　内存 硬盘
　　1.硬盘上创建了一个文件 Test.java
　　2.文件中的内容是我们编写的源代码(跟计算机发送指令)

public class Test{
     public static void main(String[] args) {
         byte x;
         x=1;
     }
}
 

3.将Test.java源文件—>编译---->Test.class
　　　　　　內容 我们看不懂 字节码 留给计算机识别
　　4.执行---->内存中执行
　　　　　　将硬盘上的Test.class内容 加载到内存里
　　5.我们写好的指令 执行内存的空间 赋值 变化…

注释：

1.单行注释
　　//
　　2.多行注释
　　/*
　　
　　/
　　3.文档注释 类和方法上
　　/*
　　
　　*/
　　
　==================================================
　
　float e=3.4F；
　 　　　　从double转化到float会有损失
　 　　　　1 3.4 常量值
　 　　　　存储在常量缓冲区中的
　 　　　　常量值的存储形式肯定不是十进制 是以二进制形式存储
　 　　　　1----> 32bit(int)
　 　　　　3.4 ----> 64bit(double)
　　　　　byte a = 1;
　　　　　1---->32bit
　　　　　00000000 00000000 00000000 00000001
　　　　　a---->8bit
　　　　　00000001
　　　　　=赋值的时候做了一个自动的决定 自动类型转化 即a的值在范围内-128 至127
　long d = 2147483648L;
　　　　 -2147483648 2147483647 是int类型的取值范围
　　　　 如果创建的常量值超过以上范围
　　　　 程序编译检测的时候会认为 数字太大
　　　　 如果我们真的需要那么大的数字 必须在后面加L告知
　　　　
　字符　　　字符串
　char　　　String
　基本　　　引用
　‘a’　　　“a” “abc” null

 public class Test2{
       public static void main(String[] strs){
         byte a=1;   //
         short b=2;
         int c=3; //-2147483648  2147483647    
         long d=2147483648L;   //超过int取值范围 加L 告诉编译器超过了int取值范围 为超过可不加
         float e=3.4F;
         double f=4.5;
         char g ='a' ;
         boolean h = true;
         

       }
}

数据类型之间的转化问题

整型
　　byte　　short　　int　　long
浮点
　　float　　double
字符
　　char
布尔型
　　boolen
byte a=1;　//8bit　　-128 ~ 127 　　　　　　
int b=a;　//32bit
　　　　　　食堂吃饭
　　　　　　一碗米饭　　2两碗　　　1两米饭
　　　　　　　　　　　　4两碗
int a=1;
byte b=(byte)a; //127 (byte) 强制类型转换
　　　　　　a---->　4两碗　　1两米饭/3两空气　空气强制砍掉一部分
　　　　　　b---->　2两碗　　1两米饭/1两空气
00000000 00000000 00000000 00000001
00000001----只保留最后的8个bit位
　　　　　　
　　　　　　
int a=1000; //编译—运行
byte b=(byte)a; //127 (byte) 强制类型转换
　　　　　　a---->　4两碗　　3两米饭/1两空气　空气强制砍掉一部分
　　　　　　b---->　2两碗　　1两米饭/1两空气　-24
00000000 00000000 00000011 11101000 — 十进制—>二进制 除以2取余数　余数倒叙排列

int　　a = 1; //32bit
float　b = a; //32bit 可以　b = 1.0;　精确程度

long a = 1;　//64bit
float b = a;　//32bit

char—字符----‘a’----0001010101—97----int
char x = ‘a’;
int y = x;　//??? y—>97

类型之间的转换问题

1.同种数据类型之间是可以直接进行赋值操作
　　　 int a=1; int b=a;　||　float x=3.4; float y=x;
2.数据类型不同的空间 之间的赋值 ---->转换的问题
　　　同种大数据类型之间才能发生转换
　 　　　基本类型<---->基本类型之间　可以直接转换(自动　强制)
　 　　　引用类型<---->引用类型之间　可以直接转换(自动　强制—上转型　下转型)
　 　　　基本类型<---->引用类型之间　不可以直接转换(间接—包装类/封装类)
3.保证大数据类型一致的前提下　 　　　　
　　　基本类型----基本类型
　　　　小数据类型相同
　　　　　都是整型　都是浮点
　　　　　 　大空间变量可以直接存储小空间的数据
　　　　　 　小空间变量不可以直接存储大空间的数据(需要强制类型转换)
　　　　　 　转换过程写法都好用　如果转换的过程中数值的范围超过边界　可能会有损失
　　　　　 　byte a = 1;　int b = a; //自动直接转化就可以
　　　　　 　int a = 1; byte b =(byte)a; //需要强制类型转换
　　　　　 　float x=3.4F;　double y = x; //自动直接转化
　　　　　 　double x=3.4;　float y = (float)x; //强制转换
　　　　　 　如果发现强制转换之前的数值比较大　强制转换这件事情是可以做
　　　　　 　int a=1000; 　 byte b=(byte)a; 　//编译好用 执行后 b存放的值一定发生变化
　　　　小数据类型不同
　　　　　 整型----浮点型
　　　　　 　两个比较精确程度　浮点型精确度更高　可以直接存放整数　反之需要强制转换(强行将小数点之后的部分去掉 只保留整数)
　　　　　 　任何一个浮点型都可以直接存放一个整型的值
　　　　　 　int a = 1；fload b = a; //直接自动转化
　　　　　 　float a =1.0F; int b = (int)a; //强制类型转换
　　　　　 整型----字符型
　　　　　 　每一个字符都对应着一个Unicode码 a–97
　　　　　 　char a = ‘a’; int y=x;　　　　//自动转化 y–97
　　　　　 　int x = 97; char y =(char)x;　//强制的转化
　　　　* 布尔类型很特殊
　　　　　 　不能与其他基本类型发生转化
　　　　　 　
　　　引用类型之间后续…