Java学习笔记（二）:数据类型和运算符（2）

最新推荐文章于 2024-09-16 21:37:07 发布

飞起

最新推荐文章于 2024-09-16 21:37:07 发布

阅读量341

点赞数

分类专栏： java学习文章标签： java

本文链接：https://blog.csdn.net/tent2012/article/details/52068805

版权

java学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、基本数据类型

整型：byte short int long;整型数据默认占32位，type a=1;是正确的，但是long a=123456789123;则是错误的，必须用long a=123456789123L;注意用L声明是long类型。
浮点型：float 声明时需加f，如
float a=1.5f；或者float =(float)1.5;使用强制类型转换；
double 浮点型数据默认就是double类型。
字符型：char,他也可以算成是整型
boolean
java中二进制、八进制、十六进制分别已0b/0B、0、0x/0X开头。
byte b=0b11101001;输出的值为-23，
因为byte是八位的，因为第一位表示正负，1表示负，所以他是补码，先要转化为反码，再转化为原码
1110 1001 补码减一，得到反码
1110 1000 符号位不变，其他位取反得到原码
10010111 结果就是-23
char类型，是一种整型，值得范围是0-2的16次方

package love;

public class CharTest
{
    public static void main(String[] args)
    {
        // 直接指定单个字符作为字符值
        char aChar = 'a';
        // 使用转义字符来作为字符值
        char enterChar = '\r';
        // 使用Unicode编码值来指定字符值
        char ch = '\u9999';
        char zhang = 24352;
        System.out.println(zhang);
        // 将输出一个'香'字符
        System.out.println(ch);
        // 定义一个'疯'字符值
        char zhong = '张';
        // 直接将一个char变量当成int类型变量使用
        int zv = zhong;
        System.out.println(zv);
        // 直接把一个0～65535范围内的int整数赋给一个char变量
        char c = 97;
        System.out.println(c);
    }
}

二、基本类型转换

自动类型转换
强制类型转换

package love;
public class NarrowConversion
{
    public static void main(String[] args)
    {
        int iValue = 233;
        // 强制把一个int类型的值转换为byte类型的值
        byte bValue = (byte)iValue;
        // 将输出-23
        System.out.println(bValue);
        double dValue = 3.98;
        // 强制把一个double类型的值转换为int
        int tol = (int)dValue;
        // 将输出3
        System.out.println(tol);
    }
}

看的出来，233的二进制数的第一位变成了符号位，所以成了-23

表达式类型的自动提升

package love;
public class AutoPromote
{
    public static void main(String[] args)
    {
        // 定义一个short类型变量
        short sValue = 5;
        // 下面代码将出错：表达式中的sValue将自动提升到int类型，
        // 则右边的表达式类型为int，将一个int类型赋给short类型的变量将发生错误。
        // sValue = sValue - 2;
        byte b = 40;
        char c = 'a';
        int i = 23;
        double d = .314;
        // 右边表达式中在最高等级操作数为d（double型）
        // 则右边表达式的类型为double型,故赋给一个double型变量
        double result = b + c + i * d;
        // 将输出144.222
        System.out.println(result);
        int val = 3;
        // 右边表达式中2个操作数都是int，故右边表达式的类型为int
        // 因此，虽然23/3不能除尽，依然得到一个int整数
        int intResult = 23 / val;
        System.out.println(intResult); // 将输出7
        // 输出字符串Hello!a7
        System.out.println("Hello!" + 'a' + 7);
        // 输出字符串104Hello!
        System.out.println('a' + 7 + "Hello!");
    }
}
这里的最后三行很像，但是结果不一样，这个区别比较大

三、运算符

算术运算符
+-* / % ++ - -
z 除法，两个都是整数结果也是整数，如果有一个是浮点数据，则结果也是浮点数据，并且此时0.0和0可以作为为除数。如5.0/0 和5/0.0都是正确的表达式，结果都是正无穷大。
%求余

package IntegerValTest;
public class ModTest
{
    public static void main(String[] args)
    {
        double a = 5.2;
        double b = 3.1;
        double mod = a % b;

        System.out.println(mod); // mod的值为2.1
        System.out.println("5对0.0求余的结果是:" + 5 % 0.0); // 输出非数:NaN
        System.out.println("-5.0对0求余的结果是:" + -5.0 % 0); // 输出非数:NaN
        System.out.println("0对5.0求余的结果是:" + 0 % 5.0); // 输出0.0
        System.out.println("0对0.0求余的结果是:" + 0 % 0.0); // 输出非数:NaN
        // 下面代码将出现异常：java.lang.ArithmeticException: / by zero
        System.out.println("-5对0求余的结果是:" + -5 % 0);
    }
}

++和- -

package IntegerValTest;

public class jiahaoceshi {
    public static void main (String[] args){
        int a =6;
        int b=4;
        int c=a++ + ++b;
        //此时a的值为7，b的值为5，但是计算c的时候，a的值为6加上了已经执行了++的b，也就是5，所以5+5=11.而不是7+5=12
        System.out.println(a+"\n"+b);
        System.out.println(c);
        //还有一种情况就是使用|，例如
        int e =6;
        int f=4;
        System.out.println(e++>5|++f<5);
        //输出结果为7和5
        System.out.println(e+"\n"+f);
        //   |和||的区别在于前者不断路，所有的表达式都会执行，而||发现前者满足条件后，后面的就不再执行了
        int g =6;
        int h=4;
        System.out.println(g++>5||++h<5);
        //输出结果为7和4
        System.out.println(g+"\n"+h);
    }

}

int a =6;
int b=4;
int c=a++ +++b;
System.out.println(a,b);

其他有点难度的算法：

package IntegerValTest;
public class MathTest
{
    public static void main(String[] args)
    {
        double a = 4096; // 定义变量a为4096
        double n=12;
        // 对a开12次方，结果为2.0
        double b = Math.pow(a , 1/n);
        System.out.println(b); // 输出b的值。
        // 求a的平方根，并将结果赋给c
        double c = Math.sqrt(a);
        System.out.println(c); // 输出c的值。
        // 计算随机数,返回一个0～1之间的伪随机数。
        double d = (int)(Math.random()*10+15);
        System.out.println(d); // 输出随机数d的值
        // 求1.57的sin函数值：1.57被当成弧度数
        double e = Math.sin(1.5758);
        System.out.println(e); // 输出接近1
    }
}

位运算符

按位非
按位非也叫做补，一元运算符NOT“~”是对其运算数的每一位取反。
例如，数字42，它的二进制代码为： 00101010
经过按位非运算成为
11010101

按位与
按位与运算符“&”，如果两个运算数都是1，则结果为1。其他情况下，结果均为零。
看下面的例子： 00101010 42 &00001111 15
00001010 10

按位或
按位或运算符“|”，任何一个运算数为1，则结果为1。
如下面的例子所示： 00101010 42 | 00001111 15
00101111 47

按位异或
按位异或运算符“^”，只有在两个比较的位不同时其结果是 1。否则，结果是零。
00101010 42 ^ 00001111 15
00100101 37

左移运算符
左移运算符<<使指定值的所有位都左移规定的次数。它的通用格式如下所示：
value << num 如果value是整型int，如果num的值大于32则，减去32再移位，如果是double类型同理

右移运算符
右移运算符>>使指定值的所有位都右移规定的次数。它的通用格式如下所示：
value >> num 右移运算符在左移时位数填充规则是原来二进制的首位是什么就加什么如11001100右移一位就变成11100110

无符号右移运算符>>>
他的规则就是填充时加0，如11001100无符号右移一位就变成01100110

逻辑运算符

&&
&
|
||
!
^当两个操作数不同时才返回true，否则返回false

三目运算符

<条件表达式>?<情况1>:<情况2>;条件表达式为true则执行情况1，否则执行情况2，三目运算符可以嵌套，还可以使用if结构来代替三目运算符，if结构的代码快的代码块的大括号最好不要省略，
如下代码：

package IntegerValTest;



public class IfTest
{
    public static void main(String[] args)
    {
        // 定义变量b ，并为其赋值
        int b = 5;
        if (b > 4)
            // 如果b>4，执行下面的执行体，只有一行代码作为代码块
            System.out.println("b大于4");
        else
            // 否则，执行下面的执行体，只有一行代码作为代码块
            b--;
            // 对于下面代码而言，它已经不再是条件执行体的一部分，因此总会执行。
            System.out.println("b不大于4");

        // 定义变量c ，并为其赋值
        int c = 5;
        if (c > 4)
            {c--;
            System.out.println("c大于4");
            }
        else
            System.out.println("c不大于4");
    }
}