java基础语法学习day03---初学者必看详解-向日葵屋

java基础语法学习day03—-初学者必看详解

- 一、数据类型
- 1、基本数据类型
- 2、数据类型转化
- - 2.1、基本数据类型的注意事项
  - 2.2、数据类型的转换
- 二、运算符
- - 1、算术运算符
  - 2、赋值运算符
  - 3、关系运算符
  - 4、连接运算符
  - 5、逻辑运算符
  - 6、三元/目运算符

一、数据类型

1、基本数据类型

java分基本数据类型和引用数据类型
  基本数据类型只有8种
  4个整数2个小数2个非数
1)byte (字节) 1字节  -128~127
  不常用(IO学习时使用)
2)short(短整型) 2字节 -32768~32767
  不常用(和其他语言兼容使用)
3)int  (整型)   4字节  -21亿~21亿
  最常用的类型
4)long (长整型) 8字节  很大
  较常用(int类型不够用时使用)
  当赋值的数值大于int的取值范围时
  需要在这个值的后面加l或L
5)float (单精度) 4字节
  不常用,精度不足
  正常赋值时,
  如果赋小数值,需要在小数值
  后加f或F
6)double(双精度) 8字节
  常用
  精度较高
7)char (字符) 2字节  0~65535
  保存一位字符
  而且有且只有一位
  'a'  --  97
  'A'  --  65
  '0'  --  48
  特殊字符:转义符:\
  '    --  \'
  \    --  \\
8)boolean (布尔)  1字节
  取值只有true或false

2、数据类型转化

byte———short——-int——long——-float———double

char——

自动类型转化（隐式类型的转化）

从小类型到大类型是可以自动完成。
强制类型转化（显式类型的转化）

从大类型转小类型，需要进行强制转化符

(需要转化成的类型)变量

但是这样的话，可能会造成数据精度丢失或者溢出。

2.1、基本数据类型的注意事项

1)java中的数据直接量
在java代码中直接写出的数值
整数直接量是int类型
小数直接量是double类型
2)数据的溢出
当一个数据类型的变量接收了
大于自己范围的数据
就会产生溢出,这个现象不是
我们想看到的,所以了解即可,
不用研究
3)时间偏移量
1970-1-1 00:00
开始到程序运行时经过的毫秒数
long time=System.currentTimeMillis();
4)舍入误差
浮点型的计算可能会发生
计算结果不精确的情况
需要使用今后学习的引用类型解决
现阶段只需要了解这个现象就可以了

案例：

package cn.tedu.day06;
public class DataTypeChange {
    public static void main(String[] args) {
        int x = 5;
        //int---byte
        byte b = 56;
        System.out.println(b);
        //（要强转的类型）变量
        byte b1 = (byte)128;
        System.out.println(b1);
        //1、自动类型的转化
        int x1 = 5;
        int y1 = 6;
        long z = x1 + y1;
        System.out.println(z);//long
        long l1 = 1024l;
        //2、强转的时候，如果数据在转化范围内，就不会发生数据溢出
        int i = (int) l1;//强制转化
        long l2 = 1024l * 1024 * 1024 * 4;
        int i2 = (int)l2;//会发生溢出
        System.out.println(i2);//0  
        double pi = 3.1415926578976588;
        float f = (float) pi;//会造成精度的损失
        System.out.println(f);//3.1415927
        //3、数据类型运算的时候，自动类型的转化
        long hm = 365 * 24 * 60 * 60 * 1000;
        double d = 800 - 600.5;
        System.out.println(d);//199.5
        double d2 = 80 / 100;
        System.out.println(80 / 100);//0
        System.out.println(d2);//0.0
        double d3 = 80.0 / 100;
        System.out.println(d3);//0.8
        //多种基本数据类型参与运算的时候，结果会发生自动类型的转化。
    }
}

Byte/char/short——>int
- int直接量可以直接赋值给byte、char和short，只要不超过表示的范围。
  
  char c = 65;
  byte b = 45;
  short s = 23;
- byte、char、short三种类型参与运算的时候，先进行转化为int类型，再参与运算。

2.2、数据类型的转换

1)java中运行计算的原则
java中只允许相同数据类型的数据
发生计算,计算结果还是这个类型

2)自动类型转换(隐式类型转换)
当不同数据类型的数据发生计算时
java系统会自动将较小的数据类型
转换成较大的数据类型
,计算结果是较大的数据类型

小大
byte short int long float double
char
1.float类型比long类型大
2.byte\short\char计算结果都是int
3)强制类型转换(显式类型转换)
由程序员编写代码
将一个数据转成指定的类型
(<类型>)<变量\数值>
double d=12.5;
int i=(int)d;//12.5–>12
强制类型转换可能造成精度丢失
当两个不同数据类型的数据计算时
想要较小的数据类型的结果

二、运算符

1、算术运算符

+ - *  /
%
++ -- 
    package cn.tedu.day06;
/**
 * 运算符
 * @author zhangjian
 *
 */
public class OperatorDemo {
    public static void main(String[] args) {
        //1.算术运算符
        System.out.println(3 + 2);//5
        System.out.println(3 - 2);//1
        System.out.println(3 * 2);//6
        System.out.println(3 / 2);//1
        //发生异常-java.lang.ArithmeticException 算术异常
        //System.out.println(3 / 0);
        //% 参与运算的时候，结果的正负与%符号左边的正负有关系。
        System.out.println(5 % 3);//2
        System.out.println(-5 % 3);//-2
        System.out.println(-5 % -3);//-2
        System.out.println(5 % -3);//2
        //++ --
        int x = 5;
        x++;//x = x + 1;
        System.out.println(x);//6
        ++x;//x = x + 1;
        System.out.println(x);//7
        x--;
        System.out.println(x);//6
        --x;//x = x - 1;
        System.out.println(x);//5
        //a++  后增
        /*
         * 当a++后增,参与运算的时候，先进行参与运算，后进行自增。
         */
        int a = 6;
        int b = a++;
        System.out.println("a = " + a + ",b = " + b);//a = 7,b = 6
        /*
         * ++m 前增
         * 当++前增，参与运算的时候，先进行自增，再参与运算。
         */
        int m = 6;
        int n = ++m;//先进行++m，得到m=7，后将m=7赋值给n,得到n=7
        System.out.println("m = " + m + ",n = " + n);//7 7
        int p = 6;
        int q = p--;
        System.out.println("p = " + p + ",q = " + q);//5 6
        int i = 8;
        int j = 7;
        i = --j;//i = 6; j = 6
        System.out.println("i = " + i + ",j = " + j);
        j = ++i;//i = 7;j = 7;
        System.out.println("i = " + i + ",j = " + j);
    }
}

2、赋值运算符

= 赋值运算符，用于对变量进行赋值。把=右边的值赋值给左边的变量。

OperatorDemo01

复合的赋值运算符

-=
*=

package cn.tedu.day07;
/**
 * 赋值运算符：=
 * @author zhangjian
 */
public class OperatorDemo01 {
    public static void main(String[] args) {
        //
        int num = 19, index;
        System.out.println(num);
        System.out.println(index = num % 3);//1
        System.out.println(index);//1
        int x, y, z;
        x = y = z = 66;
        System.out.println(z);//66
        //复合赋值运算
        x += 5;//计算的时候：x = x + 5;
        System.out.println(x);//x=71
        x -= 5;//x = x - 5;
        System.out.println(x);//x = 66
    }
}

3、关系运算符

用来判断数据之间的大小关系。

包括：大于、小于、等于(==)、大于等于(>=)、小于等于、不等于(!=)六种运算符。

关系运算符的判断结果为：boolean类型的。关系成立结果为true，关系不成立结果为false。

OperatorDemo02

package cn.tedu.day07;
/**
 * 关系运算符：
 * @author zhangjian
 *
 */
public class OperatorDemo02 {
    public static void main(String[] args) {
        int max = 30;
        int num1 = 6;
        boolean b1 = max > 35;//false
        boolean b2 = num1 % 2 == 0;//true
        boolean b3 = num1 % 2 != 0;//false
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
    }
}

4、连接运算符

使用 + 进行字符串的连接。

字符串：双引号引起来的 “ ”

OperatorDemo03

package cn.tedu.day07;
/**
 * 连接运算符：+
 * @author zhangjian
 *
 */
public class OperatorDemo03 {
    public static void main(String[] args) {
        //love520
        System.out.println("love520");
        int num = 1314;
        //love1314
        System.out.println("love" + num);//love1314
        //love1314520  ---- love1314 + 520 ---love1314520
        System.out.println("love" + num + 520);
        //love1834  ()优先级  优先计算括号里面的
        System.out.println("love" + (num + 520));
        System.out.println(520 + "love");//520love
        System.out.println(520 + 1314 + "love");//1834love
        System.out.println(520 + (1314 + "love"));//5201314love
        String msg = "love";
        msg = 520 + 1314 + msg + 521 + 1314;
        System.out.println(msg);//1834love5201314
        msg = "love";
        msg = 520 + (1314 + msg + 521) + 1314;
        System.out.println(msg);//5201314love5211314
    }
}

5、逻辑运算符

建立在关系运算之上的，包括：与&& 或 || 非 |

运算结果为：boolean类型的。

变量b1	变量b2	b1&&b2	b1\|\|b2	!b1
true	True	True	True	False
True	False	False	True	false
False	True	False	True	True
False	false	False	False	true

使用&&运算符：

两个boolean类型的值，参与&&运算的时候，只有两边都为true的时候，结果才为true；

真真为真。

OperatorDemo04

package cn.tedu.day07;
/**
 * && || ！
 * 逻辑运算符：
 * @author zhangjian
 *
 */
public class OperatorDemo04 {
    public static void main(String[] args) {
        int score = 58;
        //小明参加考试，如果考试成绩在80到100之间，奖励个四大名著一部。
        //  80 <= score <= 100
        boolean b = score >= 80 && score <= 100;
        //score >= 80  score <= 100 关系运算  boolean  
        System.out.println(b);//false
        //会唱歌或者会跳舞
        boolean sing = true;
        boolean dance = false;
        boolean b2 = sing || dance;
        System.out.println(b2);
        int x = 5;
        boolean b4 = sing || x++ > 3;
        System.out.println(b4);
        System.out.println(x);
        /*int m = 100;
        int n = 200;
        boolean b5 = (m > n) || (m++ > 200);
        System.out.println(b5);//false
        System.out.println(m);*/
        //短路逻辑
        int m = 100;
        int n = 200;
        boolean b5 = (m > n) && (m++ > 200);
        System.out.println(b5);//false
        System.out.println(m);//m = 100,不执行
        //! 非
        boolean isRain = true;
        boolean b7 = !isRain;
        System.out.println(b7);
    }
}