第二讲

##Java语言基础第二讲

一.常量的概述和使用

什么是常量—-在程序执行的过程中其值不可以发生改变.

java中常量的分类—字面值常量,自定义常量.

字面值常量的分类

字符串常量 (用双引号括起来的内容)

整数常量 (所有整数)

小数常量 (所有小数)

字符常量 (用单括号括起来的内容,里面只能放单个数字,单个字母或单个字符)

布尔常量 (该常量较为特殊,只有true和false)

class Demo1 Constant {       //Constant为常量的意思
public static void main(String[] args){
System.out.println("abc");     //字符串常量
System.out.println(456);     //整数常量
System.out.println(45.6);     //小数常量
//System.out.println('10');    //单括号中必须是单个数字,10代表的是1字符和0字符
//System.out.println('');     //单括号中什么也不放也不行,因为什么字符也不能代表
System.out.println(' ');     //代表空格字符,这样是可以的
System.out.println(true);     //布尔(Boolean)常量只有两个值,true和false
System.out.println(false);
}
}

二.进制概述

什么是进制—-是人们规定的一种进位方法,表示在某一位置上的数运算时时逢X进一位.进制越大,表现形式越短.

1 byte = 8 bit;

不同进制数据的表现形式

二进制—-由0和1组成,以0b(b可以大写也可以小写)开头.

八进制—-由0到7,八个数字组成,以0开头.

十进制—-由0到9,十个数字组成,整数默认的就是十进制.

十六进制—-由0到9,a,b,c,d,e,f(大小写均可),这十六个数字组成,以0x开头.

class Demo1_Scale {         //scale 进制的意思
public static void main(String[] args) {
/*
0b100     二进制
0100     八进制
100      十进制
0x100     十六进制
*/
System.out.println(0b100);      //4 二进制表示形式前面加0b(b可以大写也可以小写)
System.out.println(0100);     //64  八进制表示形式前面加0
System.out.println(100);
System.out.println(0x100);      //256   十六进制表示形式前面加0x(可以大写也可以小写)
}
}

进制间的转换

任意进制到十进制的转换原理—-就是把系数*基数的权次幂相加.(系数指每一位上的数据,基数指x进制基数就是x,权指的是在右边从0开始编号,对应位上的编号就是该位上的权.)

十进制到任意进制间的转换原理—-除积倒取余.

快速的进制间转换—-8421码.

原码反码补码

原码—-就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。

反码—-正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。

补码—-正数的补码与其原码相同；负数的补码是在其反码的末位加1。

通过一个字节,也就是8个二进制位表示+7和-7
0(符号位)        0000111
1(符号位)        0000111
反码                           补码
0   0000111  (+7反码)          0   0000111  (+7补码)
1   0000111  (-7原码)          1   1111000  (-7反码)
1   1111000  (-7反码)          1   1111001  (-7补码)

练习题
A:已知原码求补码
0b10110100       0b  1  0110100  (原码)
1  1001011  (反码)
1  1001100  (补码)
B:已知补码求原码
0b11101110       0b  1  1101110  (补码)
1  1101101  (反码)
1  0010010  (原码)

三.变量的概述及格式

什么是变量—-在程序执行的过程中,在某个范围内其值可以发生改变的量.

定义的格式为——数据类型 变量名(合法的标识符)=变量值

为什么要定义变量—-用来不断的存放同一类型的变量,并可以重复使用.

四.数据类型的概述及分类

为何会有数据类型—-java语言是强类型语言,对于每一种数据都定义了明确的具体数据类型,在内存中分配了不同大小的内存空间.

java中数据类型的分类

基本数据类型

引用数据类型(面向对象部分讲)

基本数据类型分类(4类8种)

整数型
byte   占一个字节,取值范围(-128到127)
short  占两个字节,取值范围(-2^15到2^15-1)
int    占四个字节,取值范围(-2^31到2^31-1)
long   占八个字节,取值范围(-2^63到2^63-1)
浮点型
float  占四个字节,取值范围(-3.403E38到3.4036E38)单精度
doudle  占八个字节,取值范围((-1.798E308到1.798E308)双精度
字符型
char  占两个字节,取值范围(0-65535)
布尔型
boolean  java中么有具体定义它的大小.

定义不同基本数据类型的变量

class DataType {        //DataType数据类型
public static void main(String[] args) {
//整数型
byte  b = 10;
short  s = 20;
int   i = 30;    //整数默认的整数类型是int类型
long  x1 = 40;
long  x2 = 66666666L   //如果long类型后面加L进行标识最好加大写L,因为小写的太像一了
System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(x1);
System.out.println(x2);
//浮点型
float  f = 12.3F;      //小数默认的小数类型是double.
double  d = 23.4;
System.out.println(f);
System.out.println(d);
//字符型
char c = 'a';
System.out.println(c);
//布尔类型
boolean b1 = true;
boolean b2 = false;
System.out.println(b1);
System.out.println(b2);
}
}

使用变量的注意事项

作用域问题—-同一个区域不能使用相同的变量名.

初始化值问题—-局部变量在使用之前必须赋值.

一条语句可以定义好几个变量,int,a,b,a…

数据转换类型之隐形转换

java中的默认转换规则—-取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的数据类型,在进行运算.

隐式转换
class DataTypeConversion {    //DataTypeConversion数据类型转换
public static void main (String[] args) {
int  i = 1;
byte  b = 2;
i = i + b;
System.out.println(i);
}
}

数据类型转换之强制转换

强制转换的格式—-b=(byte)(a+b)去掉前三个八位;

注意事项—-如果超出了被赋值的数据类型的取值范围得到的结果会与期望结果不同.

//强制转换

class DataTypaConversion2{

public static void main (String[] args){

int a = 10;

byte b = 20;

b = (byte)(a + b);

System.out.println(b);

//强制转换超出范围

byte b1 = (byte)(126 + 8);

System.out.println(b1);

byte b2 = (byte)(200);

System.out.println(b2);

}

}

变量相加和常量相加之间的区别 :

变量相加因为值无法判断所以在程序运行中JVM无法判断里面具体的值

变量相加因为值无法判断所以在Java编译器无法判断里面具体的值

class DataTypeConvension{
public static void main(String[] args){
byte b1 = 3;
byte b2 = 4;
//byte b3 = b1 + b2;

/*错误的原因如下:
1.byte与byte(或short,char)进行运算的时候会提升为int,两个int类型相加的结果也是int类型
2.b1和b2是两个变量,变量存储的值是变化,在编译的时候无法判断里面具体的值,相加有可能会超出byte的取值范围*/

byte b3 =(byte)(3 + 4);
byte b4 = 3 + 4;   //java运算时有常量优化机制
byte b5 = 7;
System.out.println(b3);
System.out.println(
4000
b4);
System.out.println(b5);
}
}

字符与字符串参与运算

class DataTypeConvension{
public static void main(String[] args){
System.out.println('a');    //输出结果a
System.out.println('a' + 1);    //输出结果98,因为有ASCII码表
System.out.println("Hello" + 'a' + 1);     //输出结果Helloa1,任何数据类型用+ 与字符串相连接都会产生新的字符串
System.out.println('a' + 1 + "Hello");     //输出结果98Hello
System.out.println("5 + 5 = " + (5 + 5))     //小括号是为了提升优先级
System.out.println(5 + 5 + " = 5 + 5");     //+在有字符串参与的运算中被称为字符串连接符
System.out.println('0' + 1);    //0---48
System.out.println('A' + 1);    //A---65
}
}

char数据类型

char的取值范围为0到65535

JAVA语言中的字符char中可以存储一个中文汉字,因为java语言用的是Unicode编码,Unicode编码中每个字符占用两个字节,而中文也是占两个字节.

class Demo5_Char {
public static void main(String[] args) {
char c = 'a';
System.out.println(c);
byte b = 100;
char c1 = 97;       //取值范围为0 - 65535
System.out.println(c1);
char c2 = 3;     //输出结果为扑克牌花色,因为ASCII码表.
char c3 = 4;
char c4 = 5;
char c5 = 6;
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
System.out.println(c5);
char c6 = '中';    //char类型是可以存储中文,但只能存储一个中文字.
System.out.println(c6);
}
}

1. 算术运算符的基本方法

什么是运算符—-就是对变量和常量进行操作的符号.

运算符的分类—-算术运算符,赋值运算符,比较(关系或条件)运算符,逻辑运算符,位运算符,三目(元)运算符.

算术运算符—-有+,-,*,/,%,++,–.

注意事项:

+号在java运算中有三种作用,代表正号,加法运算,字符串的连接符.

整数相除只能的到整数,若要的到小数,必须把数据变成浮点数类型.

/ 获取的是除法操作后的商,% 获取的是除法操作后的余数.

运算符 %

当左边的绝对值小于右边的绝对值时,结果是左边;

当左边的绝对值等于右边或是右边的倍数时,结果是0;

当左边的绝对值大于有右边的绝对值时,结果是余数;

% 运算符结果的符号只和左边有关系,与右边无关;

任何一个正整数%2,结果不是0就是1,可以用来当做切换条件.

++:自加,在原有数据基础上+1;

–:自减,在原有数据基础上-1;

class Operator {        //operator 运算符
public static void main(String[] args) {
System.out.println(10 / 3);     //整数相除结果只能是整数
System.out.println(10 / 3.0);     //如果想得到小数,把其中一个数变成小数,另一个数在运算的时候会自动类型提升
System.out.println(-5 % 5);
System.out.println(13 % -5);

class Demo2_Operator {
public static void main(String[] args) {
/* a:单独使用：
放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
b:参与运算使用：
放在操作数的前面，先自增或者自减，然后再参与运算,
放在操作数的后面，先参与运算，再自增或者自减。*/
//单独使用
int a = 3;
a++;                //a = a + 1;
++a;                //a = a + 1;
System.out.println(a);
//参与运算使用
int a = 3;
int b;
b = a++;            //当++在变量后面的时候,会先将变量中的值取出做赋值操作,然后再自身加1
b = ++a;            //当++在变量前面的时候,会先自身加1,然后在将结果赋值
System.out.println("a = " + a);
System.out.println("b = " + b);
}
}

运算符++和–的练习

练习一
分别计算a,b,c的值.
int a = 10;
int b = 10;
int c = 10;
a = b++;
c = --a;
b = ++a;
a = c--;

class Operator{
public static void main(String[] args){
int a = 10;
int b = 10;
int c = 10;
a = b++;　　　　//b = 11,a = 10;
c = --a;    　　　　//a = 9,c = 9;
b = ++a；　　　　//a = 10,b = 10;
a = c--;　　　　    //c = 8,a = 9;
System.out.println("a = "+ a + "b = " + b + "c =　" + c);
}
}

练习二
分别计算x,y的值.
int x = 4;
int y = (x++)+(++x)+(x*10);

class Operator{
public static void main(String[] args){
int x = 4;
int y = (x++)+(++x)+(x*10);    //x++ = 4,++x = 6,x*10 = 60.
System.out.println("x = " + x + ",y = " + y);
}                            //输出结果x = 6,y = 70.
}

练习三
那句会报错?为什么?
byte b = 10;
b++;
b = b + 1;

class Operator{
public static void main(String[] args){
byte b = 10;
b++;                    //b = (byte)(b + 1)
b = b + 1;              //该句会出错,当byte与int进行混合运算的时候,会提升为int类型,两个int相加的结果还是int,赋值给byte会损失精度.
System.out.println("b = " + b);
}
}

2.赋值运算符的基本用法

赋值运算符分类

基本的赋值运算符: = ,把=右边的赋值给左边.

拓展的赋值运算符: +=,-=,*=,/=,%=.(+=是把左边和右边做加法,然后赋值给左边)

class Operator5 {
public static void main(String[] args){
int a = 3;          //把右边的常量值赋值给左边  的变量,左边必须是变量
a += 4;
System.out.println(a);          //输出结果为7
}
}

练习题
看下面的程序是否有问题，如果有问题，请指出并说明理由。
class Test1_Operator {
public static void main(String[] args) {
short s = 1;s = s + 1;      //该程序有错误,当short与int进行运算的时候,会提升为int类型,两个int类型相加的结果也是int类型
short s = 1;s += 1;         //s = (short)(s + 1);
System.out.println(s);
}
}

3.关系运算符的基本方法

关系(比较,条件)运算符包括—- ==,!=,>,>=,<,<=.

注意事项:无论操作简单还是复杂,输出结果都是Boolean类型,即true或false.

class Operator6 {
public static void main(String[] args) {
System.out.println(4 == 3);     //输出结果false
System.out.println(4 != 3);     //true
System.out.println(4 > 4);      //false
System.out.println(4 >= 4);     //true
System.out.println(4 < 3);      //false
System.out.println(4 <= 3);     //false
}
}