精华内容
下载资源
问答
  • java运算符引用类
    千次阅读
    2016-02-29 22:03:26

    1.运算符(优先级:1元>2元>3元)

            运算符是用来计算数据的指令。数据可以是常量,也可以是变量。被运算符操作的数成为操作数。

    a).算数运算符

    运算符

    运算规则

    范例

    结果

    +

    正号

    +3

    3

    +

    2+3

    5

    +

    连接字符串

    “中”+“国”

    “中国”

    -

    负号

    int a=3;-a

    -3

    -

    3-1

    2

    *

    2*3

    6

    /

    5/2

    2

    %

    取模

    5/2

    1

    ++

    自增

    int a=1;a++/++a

    2

    --

    自减

    int b=3;a--/--a

    2

    注意:
         加法运算符在连接字符串时要注意,只有直接与字符串相加才会转成字符串
         除法“/”当两边为整数时,取整数部分,舍余数。当两边为浮点型时,按正常规则相除
        “%”为整除取余符号,小数取余没有意义。结果符号与被取余符号相同
        整数做被除数,0不能做除数,否则报错。
        小数做被除数,整除0结果为Infinity,对0取模结果为NaN
        副作用
            一般情况下,运算符不会改变参与计算的变量的值。而是在原有变量值不变的情况下,计算出新的值。
            但是有些操作符会改变参与计算的变量的值,而这种动作叫产生了副作用,比如++,--。
            ++或- -为前缀时,先产生副作用,再使用值
            ++或- -为后缀时,先使用值再产生副作用。

    b).赋值运算符

    运算符

    运算规则

    范例

    结果

    =

    赋值

    int a=2

    2

    +=

    加后赋值

    int a=2,a+=2

    4

    -=

    减后赋值

    int a=2,a-=2

    0

    *=

    乘后赋值

    int a=2,a*=2

    4

    /=

    整除后赋值

    int a=2,a/=2

    1

    %=

    取模后赋值

    int a=2,a%=2

    0

    l  注意:诸如+=这样形式的赋值运算符,会将结果自动强转成等号左边的数据类型。

    c).比较运算符

    又叫关系运算符,即判断两个操作数的大小关系及是否相等关系 

    运算符

    运算规则

    范例

    结果

    ==

    相等于

    4==3

    false

    !=

    不等于

    4!=3

    true

    小于

    4<3

    false

    大于

    4>3

    true

    <=

    小于等于

    4<=3

    false

    >=

    大于等于

    4>=3

    true

    d).逻辑运算符

    运算符

    运算规则

    范例

    结果

    &

    false&true

    false

    |

    false|true

    true

    ^

    异或

    true^flase

    true

    !

    !true

    flase

    &&

    短路与

    false&&true

    false

    ||

    短路或

    false||true

    true

    当使用短路与或者短路或时,只要能判断出结果则后边的部分就不再判断。
    异或表示当两个结果不同时为真,相同时为假

    e).三元运算符

    (条件表达式)?表达式1:表达式2; 
    判断条件表达式:true,运算结果为表达式1;false,运算结果为表达式2  

    2.引用类型:Scanner简介

    1.引用类型使用步骤:

    导入引用类型变量所在包
    使用import来进行导包。
    包是用来组织类结构的。每个类应该都属于某个包下。当前我们的类没有指定包。当业务冗杂之后会建立包来组织数量繁多的类。
     定义引用类型变量并创建实例赋值给变量
    使用引用类型变量调用方法,完成功能

    2.Scanner简介

    Scanner是用来接收键盘录入信息的引用类型。
     所属包:java.util.Scanner
    创建实例格式:Scanner c = new Scanner(System.in);
     方法简介 

    public int nextInt() 用来接收控制台录入的数字

    public String next() 用来接收控制台录入的字符串

    3.Math简介

    Math类是数学工具类,提供了许多数学算法方便数字运算。

     所属包:java.lang.Math  java.lang包下的所有类无需导入,可以直接使用
    创建实例格式:Math比较特殊,不需要创建实例可以直接使用Math.方法的形式完成方法调用
     方法简介
    public static int min(int a,int b) 求两个数的最大值
    public static int max(int a,int b) 求两个数的最小值
    public static long round(double a) 四舍五入
    public static double ceil(double a) 向上取整
    public static double floor(double a) 向下取整

    4.String

    String是引用数据类型的一种,是特殊的引用数据类型,代表字符串类型。
    所属包:java.lang.String
    创建实例格式:String直接使用
    双引号字面值常量即可创建实例
    方法简介
    public int length()用来返回字符串长度
    public String trim()用来去除字符串两端空白
    public String substring(开始索引,结束索引)用来截取大字符串中小字符串的一部分, 包含头不包含尾。


    更多相关内容
  • Java 语言中常用的运算符可分为如下种:Ø算术运算符Ø赋值运算符Ø比较运算符Ø逻辑运算符Ø条件运算符我们试着通过一个简单的例子来看一下运算符的使用吧!当计算两数之和时,需要使用加法运算符。在 Java 中,...

    什么是运算符:

    运算符是一种“功能”符号,用以通知 Java 进行相关的运算。譬如,我们需要将变量 age 的值设置为 20 ,这时候就需要一个“=”,告诉程序需要进行赋值操作。

    Java 语言中常用的运算符可分为如下几种:

    Ø 算术运算符

    Ø 赋值运算符

    Ø 比较运算符

    Ø 逻辑运算符

    Ø 条件运算符

    我们试着通过一个简单的例子来看一下运算符的使用吧!

    当计算两数之和时,需要使用加法运算符。在 Java 中,加法运算符使用“+”表示

    在编辑器中,第 5 行输入:

    int sum = a + b ;

    运行结果为: 两数之和为:36

    1 public classHelloWorld{2 public static voidmain(String[] args) {3 int a=12;4 int b=24;5 int sum = a+b;6 System.out.println("两数之和为:"+sum);7 }8 }

    Java中的算术运算符:

    算术运算符主要用于进行基本的算术运算,如加法、减法、乘法、除法等。

    Java 中常用的算术运算符:

    33cf2086b35f1aa768ff4bfb8c64830a.png

    其中,++ 和 -- 既可以出现在操作数的左边,也可以出现在右边,但结果是不同滴

    例1:

    1 int a = 5;2 int b = ++a; //++出现在左边 让a先执行自增,然后将值赋给变量b

    3 System.out.println("a:"+a);4 System.out.println("b:"+b);

    运行结果:

    782821a11b350f9dd09ee1a9beed03c3.png

    例2:

    1 int a = 5;2 int b = a ++; //++出现在右边 将a的值赋给变量b,然后在执行自增

    3 System.out.println("a:"+a);4 System.out.println("b:"+b);

    运行结果:

    84d998e8b42fbaac70d2d1e7cd9683ec.png

    一定要注意哦!自增和自减运算符只能用于操作变量,不能直接用于操作数值或常量!例如 5++ 、 8-- 等写法都是错误滴!

    PS:% 用来求余数,也称为”取模运算符“

    上个栗子看看:

    1 public classHelloWorld{2 public static voidmain(String[] args) {3 int age1=24; //给定四个人的年龄

    4 int age2=18;5 int age3=36;6 int age4=27;7 int sum = age1+age2+age3+age4; //求取四个年龄的总和

    8 double avg = sum/4; //求取四个年龄的平均值

    9 int minus = age1-age2; //求取 age1 和 age2 的差值

    10 int newAge = -- age1; //求取 age1 自减后的年龄

    11 System.out.println("年龄总和:"+sum);12 System.out.println("平均年龄:"+avg);13 System.out.println("年龄差值:"+minus);14 System.out.println("自减后的年龄:"+newAge);15

    16 }17 }

    运行结果如下:

    90db4ce20792c660af707f188f9a817e.png

    Java中的赋值运算符:

    赋值运算符是指为变量或常量指定数值的符号。如可以使用 “=” 将右边的表达式结果赋给左边的操作数。

    Java 支持的常用赋值运算符,如下表所示:

    e32f9156b1026efc4baf4aca5828d690.png

    Java中的比较运算符:

    比较运算符用于判断两个数据的大小,例如:大于、等于、不等于。比较的结果是一个布尔值( true 或 false )。

    Java 中常用的比较运算符如下表所示:

    5bd8ef845d4b3ff76e6fb1cf983ebccf.png

    注意哦:

    1、  > 、 < 、 >= 、 <= 只支持左右两边操作数是数值类型

    2、  == 、 != 两边的操作数既可以是数值类型,也可以是引用类型

    上个栗子 look look:

    1 public classHelloWorld{2 public static voidmain(String[] args) {3 int a=16;4 double b=9.5;5 String str1="hello";6 String str2="imooc";7 System.out.println("a等于b:" + (a ==b));8 System.out.println("a大于b:" + (a >b));9 System.out.println("a小于等于b:" + (a <=b));10 System.out.println("str1等于str2:" + (str1 ==str2));11 }12 }

    运行结果如下:

    0f470b19bd4fee2856af68c4506dddf1.png

    Java中的逻辑运算符:

    逻辑运算符主要用于进行逻辑运算。Java 中常用的逻辑运算符如下表所示:

    5304d8b848ee51952d2e751e716d6b2c.png

    我们可以从“投票选举”的角度理解逻辑运算符:

    1、 与:要求所有人都投票同意,才能通过某议题

    2、 或:只要求一个人投票同意就可以通过某议题

    3、 非:某人原本投票同意,通过非运算符,可以使其投票无效

    4、 异或:有且只能有一个人投票同意,才可以通过某议题

    当使用逻辑运算符时,我们会遇到一种很有趣的“短路”现象。

    譬如:( one > two ) && ( one < three ) 中,如果能确定左边 one > two 运行结果为 false , 则系统就认为已经没有必要执行右侧的 one < three 啦。

    同理,在( one > two ) || ( one < three ) 中,如果能确定左边表达式的运行结果为 true , 则系统也同样会认为已经没有必要再进行右侧的 one < three 的执行啦!

    栗子如下:

    假设有 A 、 B 、 C 、 D 四个人投票,由他们决定投票是否通过,此时就到了逻辑运算符“大显身手”的时候了。

    1 public classHelloWorld {2 public static voidmain(String[] args) {3 boolean a = true; //a同意

    4 boolean b = false; //b反对

    5 boolean c = false; //c反对

    6 boolean d = true; //d同意

    7 System.out.println((a && b)+"未通过");8 System.out.println((a || b)+"通过");9 System.out.println((!a)+"未通过");10 System.out.println((c ^ b)+"通过");11

    12 }13 }

    结果如下:

    a2919ea730f4dabb34f88ae7d54302ef.png

    Java中的条件运算符:

    条件运算符( ? : )也称为 “三元运算符”。

    语法形式:布尔表达式 ? 表达式1 :表达式2

    运算过程:如果布尔表达式的值为 true ,则返回 表达式1 的值,否则返回 表达式2 的值

    例如:

    879c729e688f34fa22dfc42ccab4b0ca.png

    因为,表达式 8>5 的值为 true ,所以,返回: 8大于5

    Java中的运算符优先级:

    所谓优先级,就是在表达式中的运算顺序。Java 中常用的运算符的优先级如下表所示:

    8dee1fe7e570bd6be950a892913864fc.png

    级别为 1 的优先级最高,级别 11 的优先级最低。譬如,x = 7 + 3 * 2  得到的结果是 13 “先乘后加”嘛!

    PS:大家没必要去死记运算符的优先级顺序,实际开发中,一般会使用小括号辅助进行优先级管理。例如:

    a850b6bd5a7f7d103b49f7bc67c180e6.png

    分析:小括号优先级最高,因此

    1、 执行 a + 18 ,结果为 30

    2、 执行( a + 18 ) % 4 取模,结果为 2

    3、 执行 a * ( ( a + 18 ) % 4 ),结果为 24

    来个栗子练练手吧!   表达式( 11+ 3* 8 ) / 4 % 3 的结果是()

    8f900a89c6347c561fdf2122f13be562.png

    961ddebeb323a10fe0623af514929fc1.png

    答案:2解析:

    第一步:计算3*8,结果为24;第二步:计算11+3*8,结果为35;第三步:计算(11 + 3 * 8) / 4,结果为8;第四步:计算(11 + 3 * 8) / 4 % 3,结果为2

    先自己计算一遍哈

    展开全文
  • 为什么重载运算符要返回自身的引用

    千次阅读 多人点赞 2019-06-26 16:48:27
    为什么重载运算符一定要返回自身引用 结论 可以实现和cout一样连续调用 避免了一次拷贝构造和析构,提升程序性能 正文 重载运算符为什么一定要返回自身的引用的,返回void的不行吗? 返回自身类型不行吗为...

    本文topic
    为什么重载运算符一定要返回自身引用
    结论

    1. 可以实现和cout一样连续调用
    2. 避免了一次拷贝构造和析构,提升程序性能

    正文
    重载运算符为什么一定要返回自身的引用的,返回void的不行吗?
    返回自身类型不行吗为什么一定要返回自身引用呢?

    为了解释清楚这个问题,我们拿赋值运算符举例

    首先定义一个简单的Number类

    class Number
    {
    private:
        int num;
        static int count;//用于计算调用了几次构造函数,包括拷贝构造函数
    public:
    
        Number(int n=0):num(n)//默认参数为零,可以同时当默认构造函数使用
        {
            count++;//每次调用一次加1
            cout<<"Count of constructed class Number: "<<count<<endl;
        }
        
        Number(const Number& other)//自定义拷贝构造函数
        {
            count++;
            num=other.num;
            cout<<"Count of constructed(Copy) class Number:"<<count<<endl;
        }
        
        ~Number()
        {
            cout<<"Destructor has been called"<<endl;
        }
    
        void printNumber()
        {
         	cout<<"num的值:"<<num<<endl;
        }    
    };
    int Number::count=0;//count初始值设为0
    
    
    

    对于Numbe这个类,我们一般都是这样来重载赋值运算符的

    Number& operator=(const Number& other)
    {
    	num=other.num;
    	return *this;
    }
    

    那么为什么一定要返回自身引用呢?
    我们可以将这问题分解为两个问题

    1. 一是为什么要返回自身类型
    2. 而是为什么要还一定要返回自身的引用

    我们可以思考一下,如果没有重载赋值运算符,使用普通的函数,我们让一个Number对象等于另外Number对象是这样的

    void equal(const Number& other)//写在类里面
    {
    	num=other.num;
    }
    

    在main里使用一下

    int main()
    {
    	Number n1(1);
    	Number n2;
    	n2.equal(n1);
    	n2.printNumber();
    }	
    

    输出结果:
    在这里插入图片描述
    equal函数调用成功

    操作符本质上就是函数,那么我们看看能不呢重载一个=的操作符来实现同样的功能
    我们来改造一下equal函数

    void operator=(const Number& other)//只是改了函数名,将“equal”改为“operator=”
    {
    	num=other.num;
    }
    

    调用

    int main()
    {
        Number n1(1);
        Number n2;
        //n2.equal(n1);
        //n2.printNumber();
    
        n2=n1;
        n2.printNumber();
    }
    

    运行结果
    在这里插入图片描述
    赋值操作符调用成功
    那么问题来了,既然void就可以,为什么开头的重载函数要返回Number类型呢?

    如果我们回顾一下int类型的赋值我们可以发现它是可以连续赋值的

    int main()
    {
        int i1=2,i2=2,i3=3;
        i1=i2=i3;  //可以理解为i1=i2,此时i1的值为2,然后i1又等于i3
        cout<<i1<<endl;
    }
    

    运行结果为
    在这里插入图片描述
    此时可以发现(i1=i2)它是有一个返回类型的,返回的类型就是他本身的类型,所以可以实现连续赋值
    而我们写的Numer类就不能实现该连续赋值

    int main()
    {
        Number n1(1),n2(2),n3(3);
        n1=n2=n3;//如果我们这么写,编译器会报错
    }
    
    

    那么改为返回自身类型呢

    Number operator=(const Number& other)
    {
    	num=other.num;
    	return *this;
    }
    
    int main()
    {
        Number n1(1),n2(2),n3(3);
        n1=n2=n3;
        n1.printNumber();// 运行结果值为3
    }
    

    可以发现一旦改为返回自身类型就可以实现连续赋值了
    所以返回自身类型,是为了该操作符能连续使用。

    第二问题,为什么要返回Number类型的引用呢?
    我们可以同时调用一下文章开头返回Number引用的重载运算符和上面写的不带引用的重载运算符,用同样的代码来测试一下有什么区别。
    测试代码均为

    
    int main()
    {
        Number n1(1),n2(2);
        n1=n2;
        n1.printNumber();
    }
    

    首先是不带引用的运行结果
    在这里插入图片描述
    而这是带引用的运行结果在这里插入图片描述
    可以发现带引用的运行结果减少一次拷贝构造和析构。
    那么为什么会减少呢?

    	Number n1(1),n2(2);
        n1=n2;
        n1.printNumber();
    

    因为上面运行代码中,带引用的话,只新建了n1和n2两个对象,当n1=n2的时候,因为返回的n1的引用,所以返回还是n1这个对象。即(n1=n2)的值,还是n1,只不过n1里面的变量值变了。
    而不带引用时,在赋值重载函数中,return *this的时候,用n1拷贝构造了一个临时对象,然后因为没有左值接受这个临时变量,所以又被析构了。即(n1=n2)的值是一个临时变量,刚新建,就被析构了。所以多了一个拷贝构造函数和析构函数,因此返回引用类型会带来了一点性能的提升。

    展开全文
  • 一、基本数据类型种类:内置数据类型引用数据类型1.内置数据类型一共八种基本类型,六个数字类型(四个整数类型,两个浮点型),一个布尔型,一个字符类型。(1)byte:byte数据类型是8位、符号的,以二进制补码表示...

    一、基本数据类型

    种类:

    内置数据类型

    引用数据类型

    1.内置数据类型

    一共有八种基本类型,六个数字类型(四个整数类型,两个浮点型),一个布尔型,一个字符类型。

    (1)byte:

    byte数据类型是8位、有符号的,以二进制补码表示的整数;

    最小值是-128(-2^7);

    最大值是127(2^7-1);

    默认值是0;

    byte 类型用在大型数组中节约空间,可以代替其他整数类型,因为 byte 变量占用的空间只有 int 类型的四分之一(位数);

    例子:byte a = 5,byte b = -100。

    (2)short:

    short数据类型是16位、有符号的以二进制补码表示的整数

    最小值是-32768(-2^15);

    最大值是32767(2^15 - 1);

    默认值是0;

    short 类型也可以像byte那样节省空间。一个short 变量占用的空间只有int 类型的二分之一(位数);

    例子:short a = 30000,short b = -30000.

    (3)int:

    int数据类型是32位、有符号的以二进制补码表示的整数

    最小值是-2,147,483,648(-2^31);

    最大值是2,147,483,647(2^31 - 1);

    默认值是0

    一般的整型变量默认为int 类型;

    例子:int a = 100000,int b = -203982。

    (4)long;

    long 数据类型是 64 位、有符号的以二进制补码表示的整数

    最小值是 -9,223,372,036,854,775,808(-2^63);

    最大值是 9,223,372,036,854,775,807(2^63 -1);

    默认值为0L;

    这种类型主要使用在需要比较大整数的系统上;

    例子: long a = 100000L,Long b = -200000L。

    "L"理论上不分大小写,但是若写成"l"容易与数字"1"混淆,不容易分辩。所以最好大写。

    解释为什么加上L:

    example:

    long l1 = 10000000000L;

    实际上内存中l1只是一个long类型的变量,它存在于向stack(栈)中,数值并不在其中存放,它指向heap(堆)中另一块真正存放数值的内存,加L的目的就是为了让heap中也创建一块long类型所需要的内存,用来来放数值。

    所以说=前后两者其实是在不同的两块内存,只不过有个无形的指针将两者连接起来了。

    以下的float和double同理。

    (5)float:

    float 数据类型是单精度、32位、符合IEEE 754标准的浮点数

    float 在储存大型浮点数组的时候可节省内存空间;

    默认值是 0.0f;

    浮点数不能用来表示精确的值,如货币(有待理解);

    例子:float f1 = 234.5f。

    (6)double:

    double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数

    浮点数的默认类型为double类型;

    double类型同样不能表示精确的值,如货币(有待理解);

    默认值是 0.0d;

    例子:double d1 = 123.4。

    (7)boolean:

    boolean数据类型表示一位的信息

    只有两个取值:true 和 false;

    这种类型只作为一种标志来记录 true/false 情况;

    默认值是 false;

    例子:boolean one = true。

    (8)char:

    char类型是一个单一的 16 位 Unicode 字符

    最小值是 \u0000(即为0);

    最大值是 \uffff(即为65,535);

    char 数据类型可以储存任何字符;

    例子:char letter = 'A';。

    可以用包装类查看内置数据类型的范围,它们被包装在java.lang.内置数据类型里面,最大值:内置数据类型.MAX_VALUE,最小值:内置数据类型.MIN_VALUE,位数:内置数据类型.SIZE

    例如:

    1 //char

    2 System.out.println("基本类型:char 二进制位数:" +Character.SIZE);3 System.out.println("包装类:java.lang.Character");4 //以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台

    5 System.out.println("最小值:Character.MIN_VALUE="

    6 + (int) Character.MIN_VALUE);7 //以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台

    8 System.out.println("最大值:Character.MAX_VALUE="

    9 + (int) Character.MAX_VALUE);

    结果:

    基本类型:char二进制位数:16包装类:java.lang.Character最小值:Character.MIN_VALUE=0最大值:Character.MAX_VALUE=65535

    2.引用数据类型

    在Java中,引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象,指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型,比如 Employee、Puppy 等。变量一旦声明后,类型就不能被改变了。

    对象、数组都是引用数据类型。

    所有引用类型的默认值都是null。

    一个引用变量可以用来引用任何与之兼容的类型。

    例子:Site site = new Site("Runoob")、int[]、String s1=new String(”punkll”)。

    二、运算符

    java运算符分成这几种:

    算术运算符

    关系运算符

    位运算符

    逻辑运算符

    赋值运算符

    其他运算符

    1、先说运算符的优先级

    优先级运算符简介结合性

    1

    [ ]、.、( )

    方法调用,属性获取

    从左向右

    2

    !、~、 ++、 --

    一元运算符

    从右向左

    3

    * 、/ 、%

    乘、除、取模(余数)

    从左向右

    4

    + 、 -

    加减法

    从左向右

    5

    <>、 >>>

    左位移、右位移、无符号右移

    从左向右

    6

    < 、<= 、>、 >=、 instanceof

    小于、小于等于、大于、大于等于,

    对象类型判断是否属于同类型

    从左向右

    7

    == 、!=

    2个值是否相等,2个值是否不等于。

    下面有详细的解释

    从左向右

    8

    &

    按位与

    从左向右

    9

    ^

    按位异或

    从左向右

    10

    |

    按位或

    从左向右

    11

    &&

    短路与

    从左向右

    12

    ||

    短路或

    从左向右

    13

    ?:

    条件运算符

    从右向左

    14

    =、 += 、-= 、*= 、/=、 %=、 &=、 |=、 ^=、 、>= 、>>=

    混合赋值运算符

    从右向左

    2、算术运算符

    假设A=10,B=20。

    操作符描述例子

    +

    加法 - 相加运算符两侧的值

    A + B 等于 30

    -

    减法 - 左操作数减去右操作数

    A – B 等于 -10

    *

    乘法 - 相乘操作符两侧的值

    A * B等于200

    /

    除法 - 左操作数除以右操作数

    B / A等于2

    取余 - 左操作数除以右操作数的余数

    B%A等于0

    ++

    自增: 操作数的值增加1

    B++ 或 ++B 等于 21

    --

    自减: 操作数的值减少1

    B-- 或 --B 等于 19

    ++a和a++的区别在于++a是先运算后赋值(或是进行a表达式的运算),而a++是先赋值(或是进行a表达式的运算)后运算,这个和--a、a--一个道理,切记。

    3、关系运算符

    假设A=10,B=20。

    运算符描述例子

    ==

    检查如果两个操作数的值是否相等,如果相等则条件为真。

    (A == B)为假。

    !=

    检查如果两个操作数的值是否相等,如果值不相等则条件为真。

    (A != B) 为真。

    >

    检查左操作数的值是否大于右操作数的值,如果是那么条件为真。

    (A> B)为假。

    <

    检查左操作数的值是否小于右操作数的值,如果是那么条件为真。

    (A

    >=

    检查左操作数的值是否大于或等于右操作数的值,如果是那么条件为真。

    (A> = B)为假。

    <=

    检查左操作数的值是否小于或等于右操作数的值,如果是那么条件为真。

    (A <= B)为真。

    4、位运算符

    Java定义了位运算符,应用于整数类型(int),长整型(long),短整型(short),字符型(char),和字节型(byte)等类型。

    位运算符作用在所有的位上,并且按位运算。假设a = 60,b = 13;它们的二进制格式表示将如下:

    A =00111100B =00001101-----------------A&b =00001100A |B =00111101A ^B =00110001~A=11000011

    下表列出了位运算符的基本运算,假设整数变量A的值为60和变量B的值为13:

    操作符描述例子

    如果相对应位都是1,则结果为1,否则为0

    (A&B),得到12,即0000 1100

    |

    如果相对应位都是0,则结果为0,否则为1

    (A | B)得到61,即 0011 1101

    ^

    如果相对应位值相同,则结果为0,否则为1

    (A ^ B)得到49,即 0011 0001

    按位取反运算符翻转操作数的每一位,即0变成1,1变成0。

    (〜A)得到-61,即1100 0011

    <<

    按位左移运算符。左操作数按位左移右操作数指定的位数。

    A << 2得到240,即 1111 0000

    >>

    按位右移运算符。左操作数按位右移右操作数指定的位数。

    A >> 2得到15即 1111

    >>>

    按位右移补零操作符。左操作数的值按右操作数指定的位数右移,移动得到的空位以零填充。

    A>>>2得到15即0000 1111

    5、逻辑运算符

    下表列出了逻辑运算符的基本运算,假设布尔变量A为真,变量B为假。

    操作符描述例子

    &&

    称为逻辑与运算符。当且仅当两个操作数都为真,条件才为真。

    (A && B)为假。

    | |

    称为逻辑或操作符。如果任何两个操作数任何一个为真,条件为真。

    (A | | B)为真。

    称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true,则逻辑非运算符将得到false。

    !(A && B)为真。

    短路逻辑运算符

    当使用与逻辑运算符时,在两个操作数都为true时,结果才为true,但是当得到第一个操作为false时,其结果就必定是false,这时候就不会再判断第二个操作了,即使第二个判断它是ture,第一个判断为false时,结果就是false。

    6、赋值运算符

    操作符描述例子

    =

    简单的赋值运算符,将右操作数的值赋给左侧操作数

    C = A + B将把A + B得到的值赋给C

    + =

    加和赋值操作符,它把左操作数和右操作数相加赋值给左操作数

    C + = A等价于C = C + A

    - =

    减和赋值操作符,它把左操作数和右操作数相减赋值给左操作数

    C - = A等价于C = C -

    A

    * =

    乘和赋值操作符,它把左操作数和右操作数相乘赋值给左操作数

    C * = A等价于C = C * A

    / =

    除和赋值操作符,它把左操作数和右操作数相除赋值给左操作数

    C / = A等价于C = C / A

    (%)=

    取模和赋值操作符,它把左操作数和右操作数取模后赋值给左操作数

    C%= A等价于C = C%A

    << =

    左移位赋值运算符

    C << = 2等价于C = C << 2

    >> =

    右移位赋值运算符

    C >> = 2等价于C = C >> 2

    &=

    按位与赋值运算符

    C&= 2等价于C = C&2

    ^ =

    按位异或赋值操作符

    C ^ = 2等价于C = C ^ 2

    | =

    按位或赋值操作符

    C | = 2等价于C = C | 2

    7、条件运算符(?:)

    条件运算符也被称为三元运算符。该运算符有3个操作数,并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

    variable x =(expression)?value iftrue:value iffalse

    变量 x = (表达式) ? 值1 : 值2;

    如果表达式为true就输出值1,表达式为false就输出值2。

    8、instanceof运算符该运算符用于操作对象实例,检查该对象是否是一个特定类型(类类型或接口类型)。

    instanceof运算符使用格式如下:

    (Objectreference variable )instanceof(class/interfacetype)

    (对象引用变量) instanceof (类/接口)

    如果运算符左侧变量所指的对象,是操作符右侧类或接口(class/interface)的一个对象,那么结果为真。

    例如:

    Stringname ="James";booleanresult =name instanceofString;// 由于 name 是 String 类型,所以返回真

    特别的,如果被比较的对象兼容于右侧类型,该运算符仍然返回true。比如继承了基类的子类。

    取材于菜鸟教程和百度百科。

    整数

    [Zhěngshù]

    10764539.html

    Integer

    展开全文
  • 1、为什么要进行的继承与派生? 关于这个话题其实在之前的课程中给大家介绍过,就在《实用C++》第29课 面向对象的程序设计的第⑤个知识点:https://www.cctry.com/thread-289448-1-1.html 继承与派生是C++编程...
  • python重载运算符If you’ve used the + or * operator on a str object in Python, you must have noticed its different behavior when compared to int or float objects: 如果您在Python的str对象上使用+或*...
  • 6种运算符总结

    2021-11-01 20:00:56
    运算符 1.算术运算符 2.赋值运算符 3.比较运算符(关系运算符)4逻辑运算符5.位运算符 6.三元运算符 1.算术运算符% 取模(取余) ++自增1(前)先自增1然后在运算 先运算后取值 ++自增1(后)先运算然后自增1 先取值...
  • C++中常见的运算符重载

    千次阅读 2020-06-02 09:56:00
    文章目录运算符重载重载常见的重载 运算符重载 重载 1,赋予运算符的另一种功能 返回值类型 operator重载的符号(参数) ... //因为我们这个运算符重载是在中,this指针要占一个参数 int operato
  • 这时就必须在C++中重新定义这些运算符,赋予已有运算符新的功能,使它能够用于特定类型执行特定的操作。运算符重载的实质是函数重载,它提供了C++的可扩展性,也是C++最吸引人的特性之一。  运算符重载是通过创建...
  • 运算符重载         运算符重载:即定义一个重载运算符的函数,使指定的运算符不仅能实现原有的功能,而且能实现在函数中指定的新的功能。         运算符重载实质上是函数...
  • 重载运算符

    2021-05-25 12:16:41
    运算符重载的语法 定义一个重载的运算符与定义一个函数类似,只是这个函数的名称必须以operator开头。 运算符重载函数的一般形式为: 类型 类名::operator 重载的运算符(参数表) { 函数体 } 参数的个数...
  • 如果不重载运算符,实际上也可以完成逻辑运算,但是每次需要对函数对象进行运算操作时都要手动实现一次比较麻烦, 重载运算符本质上相等于是对对象的运算封装成了一个operator函数,每次需要运算时直接调用...
  • 运算符重载

    2021-02-19 13:24:50
    1.运算符重载,就是对已运算符重新进行定义,赋予其另一种功能,以适应不同的数据 型,简化操作 让已运算符 适应适应不同的数据类型。 2.运算符重载其实就是定义一个函数,在函数体内实现想要的功能,当...
  • c++运算符重载(复数为例)

    千次阅读 2017-02-17 21:18:23
    我们所知道的运算符有很多,基本上概括了所有的数据,之所以说基本上,还有特殊的情况,我们所知道的运算符并不能直接的进行处理。今天就拿复数的运算作为例子。要运算两个数的和,很简单的a+b,我们使用了“+”,这...
  • 在这里我主要对与对象以及运算符重载这两章谈谈收获。 1.与对象 的数据成员也可以是其他的对象(的组合),但不能自身的对象作为本的成员,而自身的指针和引用可以作为的成员。 在的定义中...
  • ”称为间接成员运算符。总体注解:这个运算符与指向结构(sturct)或联合(union)的指针一起使用,用来指明结构或联合的的成员。假设ptrstr是一个指向结构的指针,member是由该结构模板指定的一个成员。那么ptrstr->...
  • 五种运算符

    千次阅读 2015-01-21 21:16:50
    运算符主要分为以下五种: 1,算术运算符 2,赋值运算符 3,关系运算符 4,逻辑运算符 5,位运算符 算术运算符 字符串加任何数据类型都会变成字符串连接 比如:“abc”+“5”=“abc5”,这是字符...
  • 运算符重载之友元运算符重载

    千次阅读 2019-01-05 21:08:02
    友元运算符重载函数: 把运算符重载函数定义为某个的友元函数。 1、定义友元运算符重载函数的语法形式 (1)在的内部,定义友元运算符重载函数的格式如下: friend 函数类型 operator 运算符(形参表) { 函数体 ...
  • java都哪些运算符及其用法

    千次阅读 2018-01-07 11:25:19
    Java的运算符可分为4:算术运算符、关系运算符、逻辑运算符和位运算符。1.算术运算符 Java的算术运算符分为一元运算符和二元运算符。一元运算符只有一个操作数;二元运算符有两个操作数,运算符位于两个操作数之间...
  • C语言的基本运算符和表达式C 语言是以函数形式提供给用户的,这些函数可方便的调用,并具有多种循环、条件语句控制程序流向,从而使程序完全结构化。这是小编准备的C语言的基本运算符和表达式,快来看看吧。基本...
  • 运算符重载详解

    2020-01-26 14:15:40
    struct node { //定义一个结构体node(节点) ... //node中3个成员变量x,y,len bool operator <(const node &a)const {//重载<操作符。可以对两个node使用<操作符进行比较 return len<a.len; ...
  • C++运算符

    千次阅读 多人点赞 2021-01-15 19:05:58
    + 、- 、* 、/ 解释:运算符 —— 加、减、乘、除 +=、-=、*=、/=、%= 解释:运算符 —— 修改和替代 . 解释:运算符——结构或联合的成员选择 , 解释:1.逗号运算符。1.分隔符,用于分隔函数参数表中的各参数...
  • C++为了增加代码的可读性引入运算符重载,运算符重载是具有特殊函数名的函数,也具有其返回值类型,函数名字以及参数列表,其返回值类型与普通的函数类似。 函数名字为:关键字operator 后面接需要重载的运算符符号 ...
  • C++运算符重载之 日期

    千次阅读 2018-08-04 16:09:54
    学完运算符重载和友元函数,我们就应该学会运用这些函数,而写一个日期的代码基本包含了运算符重载的大部分东西。 接下来就看一看这个日期的到底该怎么写。 首先,简单接介绍一下这个日期的基本功能: // ...
  • 运算符重载的个例子

    万次阅读 多人点赞 2018-08-03 22:45:26
    二元运算符指的是一个运算符有左操作数和右操作数两个对象,比如常见的+、-、*、/等等 1)算术运算符:+、-、*、/、% 2)关系运算符:&lt;=、&gt;=、&lt;、&gt;、!=、== 3)位运算符:^、&...
  • Java运算符

    2021-03-09 16:31:50
    Java语言提供许多操作符。...下面详细介绍:内容大概包括:赋值运算符算数运算符位运算符关系运算符布尔逻辑运算符几个特殊运算符运算符优先级1. 赋值运算符赋值运算符(=)是最常见的了,它将右边的...
  • Java中的六种常用运算符

    千次阅读 2019-06-13 18:09:04
    六种运算符:算术运算符、关系运算符、逻辑运算符、赋值运算符、字符串连接、三目/条件运算符。 (1)算术运算符 包含+、-、*、/、%、++、--。 和数学计算差不多。不同之处如下: <1>除法:当两个整数相除时...
  • LIKE 运算符

    2020-09-22 10:42:00
    在vb2005中运算符大致可以分为5种类型:算术运算符、连接运算符、关系运算符、赋值运算符和逻辑运算符。 目录 1C语言 ▪分类 ▪优先级 ▪左结合性和右结合性 2Word 3php 4JS语言 ▪算术 ▪赋值 ▪字符串 ▪...
  • java中运算符主要:算术运算符,赋值运算符,比较运算符,逻辑运算符,位运算符,三元运算符。其中的位运算符运用比较少,但是时候却是很简便的一种处理数的方法,故了解就好。其它运算,需熟练应用,因为这是...
  • Java运算符运算符的优先级

    千次阅读 2020-09-29 09:19:50
    Java语言中提供了很多运算符来操作变量,现总结以下七种: 赋值运算符 算术运算符 关系运算符 逻辑运算符运算符 三目运算符 instanceof运算符 一、赋值运算符 赋值符号 " = " 语法:变量名 = 表达式; 可以和...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 112,064
精华内容 44,825
关键字:

引用运算符有哪几类