Java学习日记——基础篇（二）基本语法

变量

变量和常量是程序处理的两种基本数据对象，变量是程序的基本组成单位

变量的目的就是确定目标并提供存放空间

public class Hello
{
	public static void main(String args[])
	{
		int a=10;　　//定义一个变量，并赋值
		int b=20;
		int result=a+b;　　//变量之间的运算
		System.out.println("结果是"+result); 
	}
}

运行结果：

D:\myJavaDemo>javac -encoding UTF-8 Hello.java

D:\myJavaDemo>java Hello
结果是30

基本数据类型

补码

程序在运行的时候都是用补码运行的，同样计算出的结果也是补码，

0的原码和补码都是0，
正数的补码是其本身的二进制形式，
负数的补码需要先将其绝对值按位取反（取得的结果叫做反码），再 +1。

比如 - 3 ，就是先将 1000 0011 按位取反（除了符号位），得到 1111 1100 ，在 +1 得到 1111 1101

java有四大基本数据类型：整数类型，浮点类型，布尔类型，字符类型

整数类型

　　整数类型可以表示一个整数，常用的整数类型有：byte，short，int，long

　　计算机中的信息存储单位：

- 最小是bit，也就是位——表示0/1
- 1 字节（Byte / B） == 8 位（bit）
- 1 KB == 1024字节(B) == 2^10B
- 1 MB == 1024KB == 1024 * 1024字节 == 2^20B
- 1 GB == 1024MB == 2^30B

　　他们之间的区别主要是大小

- byte 一个字节————（-128-127）
- short 两个字节————（-32768-32767）
- int 四个字节————（........）
- long 八个字节————（........）

数字的范围是如何计算出来的呢？

　　　　计算公式：

最高位是符号位（0表示正数，1表示负数），所以一个字节中的8位只有7位可以用，最大的数为

　　0111 1111 —— 2^7 - 1 == 127
　　1111 1111 —— - (2^7 - 1) == -127

但是最小为什么是 -128 呢？这就体现出印度人的聪明来了，因为是印度人发明的

　　0000 0000 —— 表示的是 0
　　1000 0000 —— 表示的是 -0

这不就浪费了一个数了吗，所以人们就把 - 0 看成 -128，

[-128] 原码 = 1000 0000 —— 发生了溢出（二进制形式是1000 0000，恰巧和符号位一样都是1不要误解），反码1000 0000是省略了最前面的1，因为溢出
[-128] 反码 = 1111 1111 —— 最高位是符号位所以不会改变，其余取反
[-128] 补码 = 1000 0000 —— 反码 + 1，符号位不会受到影响

1 + 3 的计算过程（运算结果也为补码）

原码为：0000 0001 + 0000 0011
补码为：0000 0001 + 0000 0011 = 0000 0100 　　
运算结果也是补码，但是符号位是0，一个正数，原码就是它本身0000 0100 == 3

1 + -3 的计算过程

原码为：0000 0001 + 1000 0011
补码为： 0000 0001 + (1111 1100 + 1) = 0000 0001 + 1111 1101 = 1111 1110
符号位为1说明是一个负数，转换为原码得（1111 1110 - 1，再取反）1000 0010 == -2

1 + (-128) 计算机的计算过程为

原码：0000 0001 + 1000 0000
转换为补码： 0000 0001 + 1000 0000 == 1000 0001
1000 0001 的符号位为1，是负数，转换成原码为（1000 0001 - 1，再取反）1111 1111 == -127
-127的原码为 1111 1111 ，补码为 1000 0000 + 1 = 1000 0001
127的原码为 0111 1111 ，补码为 0111 1111

神奇的事情就是，把-0在取反码进行计算后，结果就是用128进行计算的值！！！

用程序验证byte型的大小

public class Hello
{
	public static void main(String args[])
	{
		byte bytel = 127;
	}
}


//程序可以正常运行


public class Hello
{
	public static void main(String args[])
	{
		byte bytel = 128;
	}
}


//报错会损失精度
D:\myJavaDemo>javac -encoding UTF-8 Hello.java
Hello.java:6: 错误: 不兼容的类型: 从int转换到byte可能会有损失
                byte bytel = 128;
                             ^
1 个错误

现有的数据结构不够大的时候，可以用链表，字符数组，字符串来解决这样的问题

浮点类型

浮点类型可以表示一个小数，常用的浮点类型有：float，double（单精度，双精度），他们的区别主要是数据大小范围

布尔类型

布尔类型可以表示，真或者假，类型是boolean

boolean spBool = true;

字符类型

字符类型可以表示单个字符，字符类型是char

多个字符称之为字符串，在java中用String（还真是大写）这种数据类型表示，但是String不是基本数据类型，而是类，类是复合数据类型（之后会学习到）

java中字符的加减法

字符类型是一个特殊的整形

ASCII字符表

public class Hello
{
	public static void main(String args[])
	{
		int test1 = 'a' + 'b';			//把a和b对应的ascii码的数相加,赋值给test1
		char test2 = 'a' + 'b';
		char test3 = '中';				//java中一个char占用两个字节,所以可以存放汉字
		char char1 = 'q';
		int char2 = '中';                        //中文是用unicode号存放的
		System.out.println(test1);
		System.out.println(test2);
		System.out.println(test3);
		System.out.println(char1);
		System.out.println(char2);
		
	}
}


运行结果：
D:\myJavaDemo>java Hello
195
?
中
q
20013

注:中对应的unicode码为\u4e2d,为20013的16进制形式

结论：在java中，对char进行运算的时候，直接当做 ascii码对应的整数对待

java基本语法——定义变量、初始化、赋值

什么是定义变量？

int a1;
//这就是定义了一个变量,表示定义了一个整数,名字叫做a1

初始化变量

int a = 45;
//这就是初始化变量,在定义变量的时候就给值

给变量赋值

int tt;
tt = 7780;

int a=25;
a = 45;

//两者都是给变量赋值

数据类型的转换

例1

public class Hello
{
	public static void main(String args[])
	{
		int a = 1.2;
	}
}


只要损失精度就会报错：

D:\myJavaDemo>javac -encoding UTF-8 Hello.java
Hello.java:6: 错误: 不兼容的类型: 从double转换到int可能会有损失
                int a = 1.2;
                        ^
1 个错误

精度排行：byte < short < int < long < float < double

例2

public class Hello
{
	public static void main(String args[])
	{
		int b = 10;
		System.out.println(b);
	}
}

输出结果:
10

　　结论：数据可以从高精度转到低精度

例3

public class Hello
{
	public static void main(String args[])
	{
		float a = 3.4;
	}
}


报错：
D:\myJavaDemo>javac -encoding UTF-8 Hello.java
Hello.java:6: 错误: 不兼容的类型: 从double转换到float可能会有损失
                float a = 3.4;
                          ^
1 个错误

　　因为在java中，小数的默认类型是double
　　　　float a = 3.4;　　
　　表示我要把一个double类型交给float类型，损失精度，报错

例4

public class Hello
{
	public static void main(String args[])
	{
		float a = 3.4f;       //加上f就明确表示用float类型,就可以通过编译了
	}
}

将高精度强制转换为低精度

例5

public class Hello
{
	public static void main(String args[])
	{
		float a = 3.4f;
		int b = (int)a;
		int c = (int)1.9;
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
	}
}


输出结果：
D:\myJavaDemo>java Hello
3.4
3
1

　　可以看出(int)1.9的结果为1，强制转换会直接省略掉后面的

例6

public class Hello
{
	public static void main(String args[])
	{
		float a = 3.4f;
		int b = a;
		System.out.println(a);
		System.out.println(b);
	}
}

报错：
D:\myJavaDemo>javac -encoding UTF-8 Hello.java
Hello.java:7: 错误: 不兼容的类型: 从float转换到int可能会有损失
                int b = a;
                        ^
1 个错误

　　只要造成精度损失就会报错

例7

public class Hello
{
	public static void main(String args[])
	{
		float a = 3;
		int b = a + 3.4;
		System.out.println(a);
		System.out.println(b);
	}
}

报错：
D:\myJavaDemo>javac -encoding UTF-8 Hello.java
Hello.java:7: 错误: 不兼容的类型: 从double转换到int可能会有损失
                int b = a + 3.4;
                          ^
1 个错误

　　a + 3.4的结果会自动往高精度转换，就造成了a+3.4的结果是个double类型的，而b是个int类型，损失精度报错

注： 1 + 3.4f + 6.2的结果是double类型的

posted @ 2018-09-01 18:52 Igniculus 阅读(2645) 评论(0) 编辑收藏举报

刷新页面返回顶部

Igniculus

Size The Day