澳门新葡11599_www.11599.com_澳门新萄京娱乐11599平台

Java语言逻辑运算澳门新葡11599

日期:2019-11-06编辑作者:澳门新萄京娱乐11599平台
1. 循环
    while 条件:
        代码块(循环体)
        break 彻底停止当前本层循环
        continue 停止当前本次循环,继续执行下一次循环
    else: # 当条件为假的时候会执行else
        代码块
2. 格式化输出
    %s 占位字符串
    %d 占位数字
    int(str) # 字符串转换成int 
    str(int) # int转换成字符串
3. 运算符(难点)
    基本运算:算数运算、⽐较运算、逻辑运算、赋值运算、成员运算、身份运算、位运算.
    (1)算数运算
C#支持的位逻辑运算符如表所示。

后生可畏、Java逻辑运算的品类

澳门新葡11599 1

运算符号

1、概述

  • 逻辑运算是在关系运算根基之上的演算,能管理尤其扑朔迷离的难点。
  • 逻辑运算的结果是true或false。

          (2)比较运算

意义

2、逻辑运算的品种

运算种类 运算符号 运算表达式
与运算(长路运算) & 关系运算1 & 关系运算2
与运算(短路运算) && 关系运算1 && 关系运算2
或运算(长路运算) 关系运算1 丨关系运算2
或运算(短路运算) 丨丨 关系运算1 丨丨关系运算2
非运算 ! !(关系运算)

澳门新葡11599 2

运算对象类型

二、Java逻辑长路短路"与"运算

           (3)赋值运算

运算结果类型

1、概述

与运算的风味:当八个涉及运算的结果都是true时,运算的结果是true,不然是false。

关系运算1 关系运算2 与运算结果
false false false
false true false
true false false
true true true

澳门新葡11599 3

对象数

2、长路与运算

  • 长路与运算的演算符号:&
  • &在两侧都是整数时,是逐位与运算;在两侧是关联运算时,是逻辑运算。
  • 长路与运算会把两侧的涉及运算结果都总括出来。

示例:4<3 & 5*3>12

步骤1、计算4<3,结果是false。
步骤2、计算5*3>12,结果是true。
步骤3、false & true,结果是false。

           (4)逻辑运算

实例

3、短路与运算

  • 窒碍与运算的演算符号:&&
  • 卡住与运算的特征:当运算符侧面的涉嫌运算结果是false时,不再对侧边的涉及运算进行计算。

示例:4<3 & 5*3>12

步骤1、计算4<3,结果是false。
步骤2、false && 5*3>12,结果是false。

澳门新葡11599 4

~

三、Java逻辑长路短路"或"运算

    and 并且,左右两端同时为真,结果才能是真
    or  或者,左右两端至少有一个是真,结果就是真
    not 否,非真即假,非假即真

    ***运算顺序: () => not => and => or
    x or y
    如果x为0则返回y,否则返回x
    [注意]:and和or相反(x and y)

位逻辑运算

1、概述

或运算的特点:当八个事关运算的结果有三个是true时,运算的结果是true,不然是false。

关系运算1 关系运算2 与运算结果
false false false
false true true
true false true
true true true

澳门新葡11599 5

整型,字符型

2、长路或运算

  • 长路或运算的演算符号:|
  • 长路或运算在两侧都以整数时,是逐位或运算;在两侧是关乎运算时,是逻辑运算。
  • 长路或运算会把两侧的涉及运算结果都总结出来。

示例: 5*3>12 | 4<3

步骤1、计算5*3>12,结果是true。
步骤2、计算4<3,结果是false。
步骤3、计算true | false,逻辑运算结果是true。

 

整型

3、短路或运算

  • 卡住或运算的演算符号:||
  • 卡住或运算的本性:当运算符侧边包车型的士关联运算结果是true时,不再对侧面的关系运算实行测算,直接得出true的结果。

示例: 5*3>12 || 4<3

步骤1、计算5*3>12,结果是true。
步骤2、计算true || 4<3,结果是true。
4. 编码
    最早的计算机编码是ASCII。 有英文 数字 特殊字符 8bit => 1byte 没有中文, 后面的编码必须兼容ASCII
    GBK 把中国的文字进行编码. 对ASCII扩充。 16bit  => 2byte 主要包含了中文, 日文, 韩文, 英文(兼容ASCII)
    UNICODE 32bit 兼容各个国家的编码。万国码。 浪费空间  32bit => 4byte
    UTF-8 可变长度的UNICODE。本质是UNICODE。
        英文在UTF-8里面占用1个字节  8bit
        欧洲文字。占用2个字节  16bit
        中文. 占用3个字节   24bit
    UTF-16 ...

    8bit => 1byte
    1024byte => 1kb
    1024kb => 1mb
    1024mb => 1gb
    1024gb => 1tb
    1024tb = > 1

5. in
    判断xxx是否出现在xxxx中

1

四、Java逻辑"非"运算

~a

1、概述

关系运算 非运算结果
false true
true false

&

2、示例

示例:!(5*3>12) 单目运算

步骤1、计算5*3>12,结果是true;
步骤2、!true,逻辑运算结果是false。

位逻辑运算

五、Java逻辑运算优先级

三种逻辑运算的事先级:
非运算最高
附带是与运算

优先级最低的是或运算

示例:5>=7 || 4<5 && !false

步骤1、计算关系运算:5>=7,结果:false;
步骤2、计算关系运算: 4<5,结果:true;
步骤3、计算逻辑非运算:!false,结果:true;
现在变成计算false || true && true的值,由于与运算高于或运算,所以先计算与运算
步骤4、计算逻辑运算:true && true,结果:true;
步骤5、计算逻辑或运算:false || true,结果:true。

2

六、Java逻辑运算案例

【示例-1】键盘输入三个5分制分数,用与运算运算并出示该数是不是为5分制分数。

代码
public class Test19 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("输入5分制分数:");
        int score=scanner.nextInt();
        boolean isFiveScore=score>=0 && score<=5;
        System.out.println(score "是5分制的分数:" isFiveScore);
    }
}
结果一:
输入5分制分数:
5
5是5分制的分数:true
结果二:
输入5分制分数:
6
6是5分制的分数:false

【示例-2】键盘输入二个5分制分数,用或运算运算并显示该数是还是不是为5分制分数。

代码
public class Test20 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("输入5分制分数:");
        int score=scanner.nextInt();
        boolean isnotFiveScore=score<0 || score>5;
        System.out.println(score "不是5分制的分数:" isnotFiveScore);
    }
}
结果一:
输入5分制分数:
5
5不是5分制的分数:false
结果二:
输入5分制分数:
6
6不是5分制的分数:true

【示例-3】键盘输入二个5分制分数,用非运算总括并呈现该数是还是不是为5分制分数。

代码
public class Test21 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("输入5分制分数:");
        int score=scanner.nextInt();
        boolean isFiveScore=!(score<0 || score>5);
        System.out.println(score "是5分制的分数:" isFiveScore);
    }
}
结果一:
输入5分制分数:
4
4是5分制的分数:true
结果二:
输入5分制分数:
7
7是5分制的分数:false

a & b

|

位逻辑运算

2

a | b

^

位逻辑异或运算

2

a ^ b

<< 

左移运算

2

a<<4

>> 

右移运算

2

a>>2

 

1、位逻辑非运算

位逻辑非运算是单指标,唯有三个运算对象。位逻辑非运算按位对运算对象的值进行非运算,即:倘若某个人等于0,就将其生成为1;假如某个人等于1,就将其变化为0。

比方说,对二进制的10010001开展位逻辑非运算,结果等于01101110,用十进制表示正是:

~145极其110;对二进制的01010101开展位逻辑非运算,结果拾贰分10101010。用十进制表示正是~85等于176。

 

2、位逻辑与运算

位逻辑与运算将五个运算对象按位进行与运算。与运算的规行矩步:1与1等于1,1与0等于0。

比如:10010001(二进制)&11110000等于10010000(二进制)。

 

3、位逻辑或运算

位逻辑或运算将多个运算对象按位展开或运算。或运算的准绳是:1或1等1,1或0等于1,

0或0等于0。比如10010001(二进制)| 11110000(二进制)等于11110001(二进制)。

 

4、位逻辑异或运算

位逻辑异或运算将四个运算对象按位举办异或运算。异或运算的平整是:1异或1等于0,

1异或0等于1,0异或0等于0。即:相同得0,相异得1。

比如:10010001(二进制)^11110000(二进制)等于01100001(二进制)。

 

5、位左移运算

位左移运算将全部数按位左移若干位,左移后空出的部分0。比如:8位的byte型变量

byte a=0x65(即二进制的01100101),将其左移3位:a<<3的结果是0x27(即二进制的00101000)。

 

6、位右移运算

 位右移运算将全方位数按位右移若干位,右移后空出的有些填0。譬喻:8位的byte型变量

Byte a=0x65(既(二进制的01100101卡塔 尔(英语:State of Qatar))将其右移3位:a>>3的结果是0x0c(二进制00001100)。

 

在开展位与、或、异或运算时,借使三个运算对象的连串生龙活虎致,则运算结果的种类正是运算对象的体系。比方对五个int变量a和b做与运算,运算结果的类型或许int型。若是四个运算

对象的品种不意气风发致,则C#要对不一样等的连串进行类型调换,产生大器晚成致的连串,然后开展演算。

类型转变的平整同算术运算中整型量的调换则等同。

一、[]
方括号 ([]) 用于数组、索引器和属性,也可用于指针。
1、数组类型是一种后跟 [] 的类型:
int[] fib = new int[100]; //创建一个有100元素的数组
若要访问数组的一个元素,则用方括号括起所需元素的索引:
fib[0] = fib[1] = 1;
for( int i=2; i<100;   i ) fib[i] = fib[i-1]   fib[i-2];// 如果数组索引超出范围,则会引发异常。
2、不能重载数组索引运算符;但类型可以定义采用一个或多个参数的索引器和属性。索引器参数括在方括号中(就像数组索引一样),但索引器参数可声明为任何类型(这与数组索引不同,数组索引必须为整数)。
例如,.NET Framework 定义 Hashtable 类型,该类型将键和任意类型的值关联在一起。
Collections.Hashtable h = new Collections.Hashtable();
h["a"] = 123; // note: using a string as the index
3、方括号还用于指定属性(C# 编程指南):
[attribute(AllowMultiple=true)]
public class Attr 
{
}
4、可以使用方括号来指定指针索引:
unsafe fixed ( int* p = fib )   // p points to fib from earlier example
{
    p[0] = p[1] = 1;
    for( int i=2; i<100;   i ) p[i] = p[i-1]   p[i-2];
}
二、()
除了用于指定表达式中的运算顺序外,圆括号还用于指定强制转换或类型转换:
double x = 1234.7;
int a;
a = (int)x; // cast double to int
三、.
点运算符 (.) 用于成员访问。点运算符指定类型或命名空间的成员。例如,点运算符用于访问.NET Framework 类库中的特定方法:
System.Console.WriteLine("hello");
四、::
命名空间别名限定符运算符 (::),用于查找标识符。它通常放置在两个标识符之间,例如:
global::System.Console.WriteLine("Hello World");
备注:
命名空间别名限定符可以是 global。这将调用全局命名空间中的查找,而不是在别名命名空间中。

五、 
  运算符既可作为一元运算符也可作为二元运算符。
备注:
一元   运算符是为所有数值类型预定义的。对数值类型进行一元   运算的结果就是操作数的值。
为数值类型和字符串类型预定义了二元   运算符。对于数值类型,  计算两个操作数之和。当其中的一个操作数是字符串类型或两个操作数都是字符串类型时,  将操作数的字符串表示形式串联在一起。
委托类型也提供二元   运算符,该运算符执行委托串联。
实例:
using System;
class MainClass
{
    static void Main() 
    {
        Console.WriteLine( 5);        // unary plus
        Console.WriteLine(5   5);     // addition
        Console.WriteLine(5   .5);    // addition
        Console.WriteLine("5"   "5"); // string concatenation
        Console.WriteLine(5.0   "5"); // string concatenation
        // note automatic conversion from double to string
    }
}
六、-
- 运算符既可作为一元运算符也可作为二元运算符。
一元 - 运算符是为所有数值类型预定义的。数值类型的一元 - 运算的结果是操作数的反数。
二元 - 运算符是为所有数值类型和枚举类型预定义的,其功能是从第一个操作数中减去第二个操作数。
委托类型也提供二元 - 运算符,该运算符执行委托移除。
示例:
using System;
class MainClass
{
    static void Main() 
    {
        int a = 5;
        Console.WriteLine(-a);
        Console.WriteLine(a - 1);
        Console.WriteLine(a - .5);
    }
}
七、*
乘法运算符 (*),用于计算操作数的积。另外还用作取消引用运算符,允许读取和写入指针。
备注:
所有数值类型都具有预定义的乘法运算符。
* 运算符还用来声明指针类型和取消引用指针。该运算符只能在不安全的上下文中使用,通过unsafe 关键字的使用来表示,并且需要 /unsafe 编译器选项。取消引用运算符也称为间接寻址运算符。
示例:
using System;
class MainClass
{
    static void Main() 
    {
        Console.WriteLine(5 * 2);
        Console.WriteLine(-.5 * .2);
        Console.WriteLine(-.5m * .2m); // decimal type
    }
}
八、/
除法运算符 (/) 用第二个操作数除第一个操作数。所有数值类型都具有预定义的除法运算符。
using System;
class MainClass
{
    static void Main() 
    {
        Console.WriteLine(-5/2);
        Console.WriteLine(-5.0/2);
    }
}
九、%
模数运算符 (%) 计算第二个操作数除第一个操作数后的余数。所有数值类型都具有预定义的模数运算符。
using System;
class MainClass
{
    static void Main() 
    {
        Console.WriteLine(5 % 2);       // int
        Console.WriteLine(-5 % 2);      // int
        Console.WriteLine(5.0 % 2.2);   // double
        Console.WriteLine(5.0m % 2.2m); // decimal
        Console.WriteLine(-5.2 % 2.0); // double
    }
}
十、&
& 运算符既可作为一元运算符也可作为二元运算符。
备注:
一元 & 运算符返回操作数的地址(要求 unsafe 上下文)。
为整型和 bool 类型预定义了二进制 & 运算符。对于整型,& 计算操作数的逻辑按位“与”。对于 bool 操作数,& 计算操作数的逻辑“与”;也就是说,当且仅当两个操作数均为 true 时,结果才为 true。 
& 运算符计算两个运算符,与第一个操作数的值无关。例如:
int i = 0;
if (false &   i == 1)
{
}
十一、|
二元 | 运算符是为整型和 bool 类型预定义的。对于整型,| 计算操作数的按位“或”结果。对于 bool 操作数,| 计算操作数的逻辑“或”结果;也就是说,当且仅当两个操作数均为 false时,结果才为 false。
using System;
class MainClass
{
    static void Main() 
    {
        Console.WriteLine(true | false); // logical or
        Console.WriteLine(false | false); // logical or
        Console.WriteLine("0x{0:x}", 0xf8 | 0x3f);   // bitwise or
    }
}
十二、^
二元 ^ 运算符是为整型和 bool 类型预定义的。对于整型,^ 将计算操作数的按位“异或”。对于 bool 操作数,^ 将计算操作数的逻辑“异或”;也就是说,当且仅当只有一个操作数为 true时,结果才为 true。
using System;
class MainClass 
{
    static void Main() 
    {
        Console.WriteLine(true ^ false); // logical exclusive-or
        Console.WriteLine(false ^ false); // logical exclusive-or
        // Bitwise exclusive-or:
        Console.WriteLine("0x{0:x}", 0xf8 ^ 0x3f);
    }
}
十三、!
逻辑非运算符 (!) 是对操作数求反的一元运算符。为 bool 定义了该运算符,当且仅当操作数为false 时才返回 true。
using System;
class MainClass 
{
    static void Main() 
{
        Console.WriteLine(!true);
        Console.WriteLine(!false);
    }
}
十四、~
~ 运算符对操作数执行按位求补运算,其效果相当于反转每一位。按位求补运算符是为int、uint、long 和 ulong 类型预定义的。
using System;
class MainClass
{
    static void Main() 
    {
        int[] values = { 0, 0x111, 0xfffff, 0x8888, 0x22000022};
        foreach (int v in values)
        {
            Console.WriteLine("~0x{0:x8} = 0x{1:x8}", v, ~v);
        }
    }
}
十五、=
赋值运算符 (=) 将右操作数的值存储在左操作数表示的存储位置、属性或索引器中,并将值作为结果返回。操作数的类型必须相同(或右边的操作数必须可以隐式转换为左边操作数的类型)。
using System;
class MainClass
{
    static void Main()
    {
        double x;
        int i;
        i = 5; // int to int assignment
        x = i; // implicit conversion from int to double
        i = (int)x; // needs cast
        Console.WriteLine("i is {0}, x is {1}", i, x);
        object obj = i;
        Console.WriteLine("boxed value = {0}, type is {1}",
                  obj, obj.GetType());
        i = (int)obj;
        Console.WriteLine("unboxed: {0}", i);
    }
}
十六、<
所有数值和枚举类型都定义“小于”关系运算符 (<),如果第一个操作数小于第二个操作数,该运算符返回 true,否则返回 false。
using System;
class MainClass
{
    static void Main() 
    {
        Console.WriteLine(1 < 1.1);
        Console.WriteLine(1.1 < 1.1);
    }
}
十七、>
所有数值类型和枚举类型都定义“大于”关系运算符 >,如果第一个操作数大于第二个操作数,它将返回 true,否则返回 false。
using System;
class MainClass
{
    static void Main() 
    {
        Console.WriteLine(1.1 > 1);
        Console.WriteLine(1.1 > 1.1);
    }
}
十八、?:
条件运算符 (?:) 根据布尔型表达式的值返回两个值中的一个。条件运算符的格式如下 
condition ? first_expression : second_expression;

备注:
如果条件为 true,则计算第一表达式并以它的计算结果为准;如果为 false,则计算第二表达式并以它的计算结果为准。只计算两个表达式中的一个。

使用条件运算符,可以更简洁、雅观地表达那些否则可能要求 if-else 结构的计算。例如,为在sin 函数的计算中避免被零除,可编写为
if(x != 0.0) s = Math.Sin(x)/x; else s = 1.0;
或使用条件运算符,
s = x != 0.0 ? Math.Sin(x)/x : 1.0;
十九、  
增量运算符 (  ) 将操作数加 1。增量运算符可以出现在操作数之前或之后:

备注:
第一种形式是前缀增量操作。该操作的结果是操作数加 1 之后的值。
第二种形式是后缀增量操作。该运算的结果是操作数增加之前的值。
数值类型和枚举类型具有预定义的增量运算符。用户定义的类型可重载    运算符。在枚举时通常允许整型运算。
二十、--
减量运算符 (--) 将操作数减 1。减量运算符可以出现在操作数之前或之后:--variable 和variable--。第一种形式是前缀减量操作。该运算的结果是操作数减小“之后”的值。第二种形式是后缀减量操作。该运算的结果是操作数减小“之前”的值。

备注:
数值类型和枚举类型具有预定义的增量运算符。
用户定义的类型可重载 -- 运算符(请参见运算符)。在枚举时通常允许整型运算。
二十一、&&
条件“与”运算符 (&&) 执行其 bool 操作数的逻辑“与”运算,但仅在必要时才计算第二个操作数。
备注:
操作
x && y
对应于操作
x & y
不同的是,如果 x 为 false,则不计算 y(因为不论 y 为何值,“与”操作的结果都为false)。这被称作为“短路”计算。

不能重载条件“与”运算符,但常规逻辑运算符和运算符 true 与 false 的重载,在某些限制条件下也被视为条件逻辑运算符的重载。
二十二、||
条件“或”运算符 (||) 执行 bool 操作数的逻辑“或”运算,但仅在必要时才计算第二个操作数。
备注:
操作
x || y
对应于操作
x | y
不同的是,如果 x 为 true,则不计算 y(因为不论 y 为何值,“或”操作的结果都为true)。这被称作为“短路”计算。

不能重载条件“或”运算符,但规则逻辑运算符和运算符 true 与 false 的重载,在某些限制条件下也被视为条件逻辑运算符的重载。
二十三、<<
左移运算符 (<<) 将第一个操作数向左移动第二个操作数指定的位数。第二个操作数的类型必须是 int。

备注:
如果第一个操作数是 int 或 uint(32 位数),则移位数由第二个操作数的低 5 位给出。
如果第一个操作数是 long 或 ulong(64 位数),则移位数由第二个操作数的低 6 位给出。
第一个操作数的高序位被放弃,低序空位用 0 填充。移位操作从不导致溢出。
用户定义的类型可重载 << 运算符(请参见 operator);第一个操作数的类型必须为用户定义的类型,第二个操作数的类型必须为 int。重载二元运算符时,也会隐式重载相应的赋值运算符(如果有)。
二十四、>>
右移运算符 (>>) 将第一个操作数向右移动第二个操作数所指定的位数。

备注:
如果第一个操作数为 int 或 uint(32 位数),则移位数由第二个操作数的低五位给出(第二个操作数 & 0x1f)。

如果第一个操作数为 long 或 ulong(64 位数),则移位数由第二个操作数的低六位给出(第二个操作数 & 0x3f)。

如果第一个操作数为 int 或 long,则右移位是算术移位(高序空位设置为符号位)。如果第一个操作数为 uint 或 ulong 类型,则右移位是逻辑移位(高位填充 0)。

用户定义的类型可重载 >> 运算符;第一个操作数的类型必须为用户定义的类型,第二个操作数的类型必须为 int。有关更多信息,请参见 operator。重载二元运算符时,也会隐式重载相应的赋值运算符(如果有)。
二十五、==
对于预定义的值类型,如果操作数的值相等,则相等运算符 (==) 返回 true,否则返回 false。对于 string 以外的引用类型,如果两个操作数引用同一个对象,则 == 返回 true。对于string 类型,== 比较字符串的值。

备注:
用户定义的值类型可重载 == 运算符(请参见 operator)。用户定义的引用类型也可重载 == 运算符,尽管在默认情况下,无论对于预定义的引用类型还是用户定义的引用类型,== 的行为都与上面描述的相同。如果重载 ==,则还必须重载 !=。在枚举时通常允许整型运算。
二十六、!=
如果操作数相等,则不等运算符 (!=) 返回 false,否则,返回 true。为所有类型(包括字符串和对象)预定义了不等运算符。用户定义的类型可重载 != 运算符。

备注:
对于预定义的值类型,如果操作数的值不同,则不等运算符 (!=) 返回 true,否则,返回false。对于 string 以外的引用类型,如果两个操作数引用不同的对象,则 != 返回 true。对于 string 类型,!= 比较字符串的值。

用户定义的值类型可重载 != 运算符(请参见 operator)。用户定义的引用类型也可重载 != 运算符,尽管在默认情况下,无论对于预定义的引用类型还是用户定义的引用类型,!= 的行为都与上面描述的相同。如果重载 !=,则还必须重载 ==。在枚举时通常允许整型运算。
二十七、<=
所有数值和枚举类型都定义了“小于等于”关系运算符 (<=),如果第一个操作数小于或等于第二个操作数,则该运算符将返回 true,否则返回 false。
二十八、>=
所有数值类型和枚举类型都定义“大于等于”关系运算符 >=,如果第一个操作数大于或等于第二个操作数,该运算符将返回 true,否则返回 false。
二十九、 =
加法赋值运算符。
备注:
使用  = 赋值运算符的表达式,例如
x  = y
等效于
x = x   y
不同的是 x 只计算一次。  运算符的含义取决于 x 和 y 的类型(例如,对于数值操作数,其含义为相加;对于字符串操作数,其含义为串联)。

不能直接重载  = 运算符,但用户定义的类型可以重载   运算符(请参见 operator)。
三十、-=
减法赋值运算符。
备注:
使用 -= 赋值运算符的表达式,如
x -= y
等效于
x = x - y
不同的是 x 只计算一次。- 运算符的含义取决于 x 和 y 的类型(例如,对于数值操作数,其含义为相减;对于委托操作数,其含义为移除)。

不能直接重载 -= 运算符,但用户定义的类型可重载 - 运算符(请参见 operator)。
三十一、*=
二元乘法赋值运算符。
备注:
使用 *= 赋值运算符的表达式,如
x *= y
等效于
x = x * y
不同的是 x 只计算一次。为数值类型预定义了 * 运算符以执行乘法操作。
不能直接重载 *= 运算符,但用户定义的类型可重载 * 运算符(请参见 operator)。
三十二、/=
除法赋值运算符。
备注:
使用 /= 赋值运算符的表达式,如
x /= y
等效于
x = x / y
不同的是 x 只计算一次。为数值类型预定义了 / 运算符以执行除法操作。
不能直接重载 /= 运算符,但用户定义的类型可重载 / 运算符(请参见 operator)。对于所有复合赋值运算符,隐式重载二元运算符会重载等效的复合赋值。
三十三、%=
模块赋值运算符。
备注:
使用 %= 赋值运算符的表达式,如
x %= y
等效于
x = x % y
不同的是 x 只计算一次。为数值类型预定义了 % 运算符,以计算相除后的余数。
不能直接重载 %= 运算符,但用户定义的类型可重载 % 运算符(请参见运算符(C# 参考))。
三十四、&=
“与”赋值运算符。
备注:
使用 &= 赋值运算符的表达式,如
x &= y
等效于
x = x & y
不同的是 x 只计算一次。& 运算符对整数操作数执行按位逻辑“与”运算,对 bool 操作数执行逻辑“与”运算。
不能直接重载 &= 运算符,但用户定义的类型可重载二元 & 运算符(请参见 operator)。
三十五、|=
“或”赋值运算符。
备注:
使用 |= 赋值运算符的表达式,例如
x |= y
等效于
x = x | y
不同的是 x 只计算一次。| 运算符对整型操作数执行按位逻辑“或”运算,对布尔操作数执行逻辑“或”运算。
不能直接重载 |= 运算符,但用户定义的类型可以重载 | 运算符(请参见 operator)。
三十六、^=
“异或”赋值运算符。
备注:
下列形式的表达式
x ^= y
按如下规则计算:
x = x ^ y
不同的是 x 只计算一次。^ 运算符对整数操作数执行按位“异或”运算,对 bool 操作数执行逻辑“异或”运算。
不能直接重载 ^= 运算符,但用户定义的类型可重载 ! 运算符(请参见 operator)。
三十七、<<=
左移赋值运算符。
备注:
下列形式的表达式
x <<= y
按如下规则计算:
x = x << y
不同的是 x 只计算一次。<< 运算符将 x 向左移动 y 指定的位数。
不能直接重载 <<= 运算符,但用户定义的类型可重载 << 运算符(请参见 operator)。
三十八、>>=
右移赋值运算符。
备注:
下列形式的表达式
x >>= y
按如下规则计算:
x = x >> y
不同的是 x 只计算一次。>> 运算符根据 y 指定的量对 x 进行右移位。
不能直接重载 >>= 运算符,但用户定义的类型可重载 >> 运算符(请参见 operator)。
三十九、->
-> 运算符将指针取消引用与成员访问组合在一起。
备注:
以下形式的表达式 
x->y
(其中 x 为 T* 类型的指针,y 为 T 的成员)等效于
(*x).y
-> 运算符只能在非托管代码中使用。
不能重载 -> 运算符。
四十、??
如果 ?? 运算符的左操作数非空,该运算符将返回左操作数,否则返回右操作数。

 

本文由澳门新葡11599发布于澳门新萄京娱乐11599平台,转载请注明出处:Java语言逻辑运算澳门新葡11599

关键词: 澳门新葡11599

python多线程澳门新葡11599

Python中的三十二线程未有真的兑现多现程!为啥那样说,大家询问二个定义,全局解释器锁(GIL卡塔 尔(阿拉伯语:...

详细>>

如何一步步的用python制作游戏外挂【澳门新葡1

因为那是类的多个主意,所以有个self参数,无视它。这里的img应该传入多个Image对象,可以使读入图像文件后的结果...

详细>>

Python爬取 2019 款口红,告诉你女王节该如何保命

爬虫的薪资     数据分析   在互联网上面,你可以知道很多的东西,都会根据你看的东西,买的东西分析并推荐给你...

详细>>