Java数据类型、基本数据类型、基本数据类型的转换、运算符、条件语句、循环

Java数据类型、基本数据类型、基本数据类型的转换、运算符、条件语句、循环,第1张

目录

数据类型

基本数据类型

基本数据类型的转换

运算符

条件语句

循环

数据类型
  • java之中每个数据必须指定类型,指导JVM内存分配

  • 分为基本类型和引用类型两类

  • 基本类型有八种:byte short int long char float double boolean

  • 引用类型:除了基本类型的八种剩下的都是应用类型。

基本数据类型
  • 基本数据类型共有8种

数值: byte:一个字节

short:两个字节

int : 四个字节

long :八个字节

float :四个字节

double 八个字节

字符 : char:两个字节

  • 计算机表示字符的方式:编码表 ,字符在编码表中对应不同的数字 ASCII码中 如:a~z:97~122

  • java使用的是Unicode编码表

  • char类型参与算数运算:使用的是对应编码表中的数值来计算。

布尔: boolean 逻辑值 只有true/false关键字表示

基本数据类型的转换

我们在做运算的过程中,要求运算的数据必须要一致

  • 八种基本类型除boolean都可以进行类型转换

  • 转换有默认转换、强制转换、隐式转换

  • 默认转换:容量小的可以自动转换成容量大的,参与混合运算时小容量会自动转换为大容量char、byte、short--->int --->long--->float---->double

    char、byte、short(这三者不会相互转换)--->int 在计算时会默认转换成int类型

  • 强制转换:容量大的转换为容量小的

    会出现的问题:1.数据溢出 2.精度降低

  • 隐式转换:+=、-=、*=、/=、%=

public class Hello {
    public static void main(String[] args) {
        short a = 5;
        a = (short) (a + 5);  //5为int 首先会自动转换为int运算 需要强制转换为short
        a += 5;  // 隐式转换
    }
}
  • 要注意的float 小数二进制底层储存结构与整数不同、4进制的float比8进制的long储存范围还大

    public class Hello {
        public static void main(String[] args) {
            //浮点型float 小数二进制底层储存结构与整数不同 4进制的float比8进制的long储存范围还大
            float e = 12.23f;
            long f =(long) e;   //float转long需要强制转换
    ​
            long l = 1234L;
            float fe = l;       //long转float默认转换
        }
    }
运算符
  • 算数运算符:

    +:加法和字符串连接 数值+字符串=字符串

    -:减法:数值与数值

    *:乘法:数值与数值

    /:数值与数字

    %:取余 数值与数值

    ++自增

    -- 自减

    注意:++在前先增后运算 ++在后先运算后加 --与++原理相同

    public class Hello {
        public static void main(String[] args) {
            int a=1;
            int qwe,wer;
            qwe = a++ + 1; //qwe为2 a为2
            wer = ++a + 1; //wer为4 a为3
            System.out.println(qwe);
            System.out.println(wer);
            System.out.println(a);
        }
    }

  • 比较运算符号: > < >= <= == !=

  • 逻辑运算符: &&(短路与) ||(短路或) &(逻辑与) |(逻辑或) ! ^(逻辑异或)

注意 &&与 & 的区别:

逻辑与& 与 短路与&&区别: 当前面的表达式为假时 && 不会运行后面的表达式 &在前面的表达式为假时 后面的表达式会运行

|| 与 | 的区别:

逻辑或| 与 短路或||区别: 当前面的表达式为真时 || 不会运行后面的表达式 |在前面的表达式为真时 后面的表达式会运行

public class Hello {
    public static void main(String[] args) {
        int a = 12;
        int b = 10;
        int c = 23;
        System.out.println(ab || b++b | b++

逻辑异或

public class Hello {
    public static void main(String[] args) {
        //逻辑运算符号  | & ! ||(短路) &&(短路) ^(逻辑异或)
        //逻辑与& 与 短路与 &&
        int a = 12;
        int b = 10;
        int c = 23;
        //逻辑异或 前后逻辑值相同时为false 前后逻辑值不同时为true
        System.out.println(a>b ^ ac); // false ^ false false
    }
}
  • 位运算符 >> << >>> & | ^

    public class Hello {
        public static void main(String[] args) {
            short a = 5 ;
            int b = 5;
            int c = 30;
            if((b&1)==0){       //用位&判断奇偶数
                System.out.println("b偶数");
            }else{
                System.out.println("b为奇数");
            }
            //位(比特位)运算 <<左移   >>右移  >>>无符号右移 & | ~ ^
            //左移
            int i = 3;
            int in = 4;
            System.out.println(i & in); //与不同取0 全1为1 结果为0
            /*
                0000 0011
                0000 0100
                0000 0000
             */
            System.out.println(i ^ in);//异或相同取0 不同取1  结果为7
            /*
                0000 0011
                0000 0100
                0000 0111
             */
            System.out.println(i | in); //或有1取1 全0为0  结果为7
            /*
                0000 0011
                0000 0100
                0000 0111
             */
            System.out.println(i<<1); //左位移1位 结果为6
            /*  0000 0011
                0000 0110
             */
            System.out.println(i>>1); //右位移1位 结果为1
            /*
                0000 0011
                0000 0001
             */
            int i2 = -6;
            System.out.println(i2>>1);
            System.out.println(i2>>>1); //>>>无符号位移要注意负数 最高位会补0;
            i = i ^ in;
            in = i ^ in;    //使用异或来 交换两个数字
            i = i ^ in;
            System.out.println(i);
            System.out.println(in);
            //~非 每一位取反
            System.out.println(~i);
        }
    }

  • 条件运算符: (条件)?表达式1:表达式2

    public class Hello {
        public static void main(String[] args) {
            short a = 5 ;
            //(条件表达式)?符合执行:不符合执行;
            String st = (a<30)?"OK":"不OK";
            System.out.println(st);
        }
    }

  • 赋值运算 = += -= *= /= %=

    重点:隐式转换

    public class Hello {
        public static void main(String[] args) {
            short a = 5;
            a = (short) (a + 5);  //5为int 首先会自动转换为int运算 需要强制转换为short
            a += 5;  // 隐式转换
        }
    }

条件语句

if(){ } if(){ }else{ }

if(){ }else if(){ }else{ }

switch(表达式){

case 值: 代码块 break;

....

default: 默认代码块;

}

重点:if() 后面若没有加大括号则if只作用紧挨着的第一条语句

循环

循环要素:

  • 变量初始化

  • 循环条件

  • 循环语句

  • 变量的迭代

while(条件){ }

do{ }while(条件)

for(变量初始化; 条件; 变量更新){

循环体

}

欢迎分享,转载请注明来源:内存溢出

原文地址: https://outofmemory.cn/langs/719554.html

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-04-25
下一篇 2022-04-25

发表评论

登录后才能评论

评论列表(0条)