java中的运算符与类型调换,java运算符转变

java的各体系型转变取外汇总,java类型调换取外汇总

java类型转变 Integer String Long Float Double Date 

1哪些将字串 String 转变来整数 int? 
A. 有三个章程: 
1). int i = Integer.parseInt([String]); 或 
i = Integer.parseInt([String],[int radix]); 
2). int i = Integer.valueOf(my_str).intValue(); 
注: 字串转成 Double, Float, Long 的主意完全相仿. 

2 怎样将整数 int 转变来字串 String ? 

A. 有叁种方法: 
1.) String s = String.valueOf(i); 
2.) String s = Integer.toString(i); 
3.) String s = “” + i; 
注: Double, Float, Long 转成字串的方法完全相近. 

package cn.com.lwkj.erts.register;  
import java.sql.Date;  
public class TypeChange {  
   public TypeChange() {  
   }  
   //change the string type to the int type  
   public static   int stringToInt(String intstr)  
   {  
     Integer integer;  
     integer = Integer.valueOf(intstr);  
     return integer.intValue();  
   }  
   //change int type to the string type  
   public static String intToString(int value)  
   {  
     Integer integer = new Integer(value);  
     return integer.toString();  
   }  
   //change the string type to the float type  
   public static   float stringToFloat(String floatstr)  
   {  
     Float floatee;  
     floatee = Float.valueOf(floatstr);  
     return floatee.floatValue();  
   }  
   //change the float type to the string type  
   public static String floatToString(float value)  
   {  
     Float floatee = new Float(value);  
     return floatee.toString();  
   }  
   //change the string type to the sqlDate type  
   public static java.sql.Date stringToDate(String dateStr)  
   {  
     return   java.sql.Date.valueOf(dateStr);  
   }  
   //change the sqlDate type to the string type  
   public static String dateToString(java.sql.Date datee)  
   {  
     return datee.toString();  
   }  
   public static void main(String[] args)  
   {  
     java.sql.Date day ;  
     day = TypeChange.stringToDate("2003-11-3");  
     String strday = TypeChange.dateToString(day);  
     System.out.println(strday);  
   }  

} /* 何问起 hovertree.com */

JAVA中常用数据类型调换函数 
虽说都能在JAVA API中找到,整理一下做个备份。 
string->byte 
Byte static byte parseByte(String s)  
byte->string 
Byte static String toString(byte b) 
char->string 
Character static String to String (char c) 
string->Short 
Short static Short parseShort(String s) 
Short->String 
Short static String toString(Short s) 
String->Integer 
Integer static int parseInt(String s) 
Integer->String 
Integer static String tostring(int i) 
String->Long 
Long static long parseLong(String s) 
Long->String 
Long static String toString(Long i) 
String->Float 
Float static float parseFloat(String s) 
Float->String 
Float static String toString(float f) 
String->Double 
Double static double parseDouble(String s) 
Double->String 
Double static String toString(Double) 

++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
数据类型 
着力项目有以下多样: 
int长度数据类型有:byte(8bits)、short(16bits)、int(32bits)、long(64bits)、 
float长度数据类型有:单精度(32bits float)、双精度(64bits double) 
boolean类型变量的取值有:ture、false 
char数据类型有:unicode字符,十三位 
相应的类类型:Integer、Float、Boolean、Character、Double、Short、Byte、Long 
转移原则 
从低精度向高精度转换 
byte 、short、int、long、float、double、char 
注:七个char型运算时,自动调换为int型;当char与别的类型运算时,也会先活动调换为int型的,再做任何项指标活动转变 
中央类型向类类型转变 
正向调换:通过类包装器来new出三个新的类类型的变量 
Integer a= new Integer(2); 
反向调换:通过类包装器来转变 
int b=a.intValue(); 
类品种向字符串调换 
正向转变:因为每种类都是object类的子类,而全数的object类都有一个toString()函数,所以通过toString()函数来调换就可以 
反向转变:通过类包装器new出二个新的类类型的变量 
eg1: int i=Integer.valueOf(“123”).intValue() 
评释:上例是将一个字符串转形成二个Integer对象,然后再调用那个指标的intValue()方法重临其对应的int数值。 
eg2: float f=Float.valueOf(“123”).floatValue() 
注明:上例是将一个字符串转形成一个Float对象,然后再调用这一个目的的floatValue()方法再次回到其相应的float数值。 
eg3: boolean b=Boolean.valueOf(“123”).booleanValue() 
注明:上例是将三个字符串转产生一个Boolean对象,然后再调用那个目的的booleanValue()方法重返其对应的boolean数值。 
eg4:double d=Double.valueOf(“123”).doublue() 
注解:上例是将二个字符串转形成一个Double对象,然后再调用那几个指标的doublue()方法重返其对应的double数值。 
eg5: long l=Long.valueOf(“123”).longValue() 
表达:上例是将三个字符串转化成一个Long对象,然后再调用那几个目的的longValue()方法重临其相应的long数值。 
eg6: char=Character.valueOf(“123”).charValue() 
证实:上例是将一个字符串转造成贰个Character对象,然后再调用那些目的的charValue()方法重返其对应的char数值。 
大旨类型向字符串的转变 
正向转变: 
如:int a=12; 
String b;b=a+””; 
反向转变: 
由此类包装器 
eg1:int i=Integer.parseInt(“123”) 
证实:此措施只好适用于字符串转形成整型变量 
eg2: float f=Float.valueOf(“123”).floatValue() 
表达:上例是将三个字符串转产生三个Float对象,然后再调用这些指标的floatValue()方法再次回到其对应的float数值。 
eg3: boolean b=Boolean.valueOf(“123”).booleanValue() 
说明:上例是将三个字符串转化成三个Boolean对象,然后再调用那几个指标的booleanValue()方法再次回到其对应的boolean数值。 
eg4:double d=Double.valueOf(“123”).doublue() 
证实:上例是将二个字符串转化成三个Double对象,然后再调用那么些目的的doublue()方法重临其相应的double数值。 
eg5: long l=Long.valueOf(“123”).longValue() 
评释:上例是将二个字符串转化成叁个Long对象,然后再调用这几个目标的longValue()方法再次回到其相应的long数值。 
eg6: char=Character.valueOf(“123”).charValue() 
表明:上例是将贰个字符串转产生四个Character对象

推荐:

java类型调换 Integer String Long Float Double Date 1怎样将字串 String
转变到整数 int? A. 有八个艺术: 1)….

java中的运算符与类型转变,java运算符调换

java对象类型转变和多态性,java对象调换多态

Java数据类型和类型转变,java数据类型转变

Java的数据类型分为主旨数据类型和援引数据类型

  图片 1

 

Java 程序在运行时,需要在内存中的分配空间。为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。

   图片 2

   
      
 栈(stack):在函数中定义的风流洒脱对中坚类型的变量和对象的援引变量都在函数的栈内部存款和储蓄器中分配。在Windows下,栈是向低地址扩张的数据结构,
                  
 是一块三回九转的内部存储器的区域。那句话的情致是栈顶之处和栈的最大体积是系统预先规定好的,在WINDOWS下,栈的分寸是2M(也许有 
                  
 的乃是1M,不问可见是二个编写翻译时就规定的常数),假如申请的上空超越栈的多余空间时,将唤起overflow。因而,能从栈得到的半空中很小。
 
        
        堆(heep):
堆内部存款和储蓄器用来存放由new创立的指标和数组,堆是向高地址扩张的数据结构,是不总是的内部存储器区域。那是由于系统是用链表来储存 
                    
的悠闲内部存款和储蓄器地址的,自然是不三番五次的,而链表的遍历方向是由低地址向高地址。堆的大大小小受限于Computer体系中有效的设想内存。总之,

        堆获得的半空中相比灵活,也非常大。 

   方法区:用于贮存类的新闻。

   本地点法栈:给C/C++的native原生底层方法予以辅助。

   PC寄存器:给CPU用。

 

堆与栈之间的联系:当在一段代码块定义一个变量时,Java就在栈中为这个变量分配内存空间,当超过变量的作用域后,
                               Java会自动释放掉为该变量所分配的内存空间,该内存空间可以立即被另作他用。   
                          
                            在堆中产生了一个数组或对象后,还可以在栈中定义一个特殊的变量,让栈中这个变量的取值等于
                          数组或对象在堆内存中的首地址,栈中的这个变量就成了数组或对象的引用变量。引用变量就相
                          当于是为数组或对象起的一个名称,以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。 
                          引用变量是普通的变量,定义时在栈中分配,引用变量在程序运行到其作用域之外后被释放。而数组和对象本身在堆中分配,
                          即使程序运行到使用 new 产生数组或者对象的语句所在的代码块之外,数组和对象本身占据的内存不会被释放,
                          数组和对象在没有引用变量指向它的时候,才变为垃圾,不能在被使用,但仍然占据内存空间不放,
                          在随后的一个不确定的时间被垃圾回收器收走(释放掉)。

                          栈中的变量指向堆内存中的变量,这就是 Java 中的指针!

 

数据类型的调换

  数据类型的转变分为隐式类型调换和展现类型调换,差距在于节制大小(如int的界定-2^16~2^16-1,注意这里相比较的并非所占字节)的调换方向,也正是衍生和变化转型和向下转型。

  隐式类型调换便是向上转型,属于自行转换,,如:

                int a=50;
             long b=a;            

 

  显示类型转变就是向下转型,属于强制调换,表示范围大的向范围小的数据类型实行转移,如:

         long a=50;
            int b=(int) a;

 

  

Java的数据类型分为大旨数据类型和引用数据类型 Java
程序在运转时,须要在内存中的分配空间。…

#进制转换

ord(x)                 #将一个字符转换为它的整数值    
hex(x)                 #将一个整数转换为一个十六进制字符串    
oct(x)                 #将一个整数转换为一个八进制字符串

#类型转换
int(x [,base ])        #将x转换为一个整数    
long(x [,base ])       #将x转换为一个长整数    
float(x)               #将x转换到一个浮点数    
complex(real [,imag ]) #创建一个复数    
str(x)                 #将对象 x 转换为字符串    
repr(x)                #将对象 x 转换为表达式字符串    
eval(str)              #用来计算在字符串中的有效Python表达式,并返回一个对象    
tuple(s)               #将序列 s 转换为一个元组    
list(s)                #将序列 s 转换为一个列表    
chr(x)                 #将一个整数转换为一个字符    
unichr(x)              #将一个整数转换为Unicode字符    

类型转换: 

    从小到大的排序 自动类型转变(隐式转变)
  小的数据类型与大的数据类型实行演算的时候,结果会活动转变大的种类
  byte char short –>int –>long –>float –>double
  注意事项:byte char short 相互之间不转变他们插手运算首先转变为int类型

格式:范围大的数据类型 变量 = 范围小的数量类型值

强制类型调换(展现转换)
  能够忍受精度缺失的景色下 可以把大类型的数据强制转产生小类型的数据
格式:范围小的数据类型 变量 = (范围小的数据类型) 范围大的数据类型

指标类型转变

分成向上转型和向下转型(强制对象转型)。 向上转型是子对象向父对象转型的进度,举个例子猫类转变为动物类;向下转型是挟持转型完毕的,是父对象强制调换为子对象。 那和基础数据类型的改变是相通的,byte在急需时会自动转变为int(向上转型),int能够强制转型为byte(向下转型)。

对于指标转型来讲, 升高转型后子对象独有的分子将不得访谈 。 意思是,在要求一头动物时,能够把猫当做贰只动物传递,因为猫承继自动物,猫具备动物的具备属性。但提升转型后,猫不再是猫,而是被当做动物对待,它和煦仅有的性质和章程就不可以见到了。换句话说,向上转型后,只好识别父对象中的内容。

能够通过”援用变量 instanceof
类名”的不二秘诀来推断引用变量 所指向的靶子 是或不是属于某些类,也正是说”对象是否某类”,举例声宾博(Nutrilon)个猫类对象的援引”Cat
c”,然后”c instanceof
Animal”表述的情致是”对象c是风流洒脱种动物呢?”对于instanceof重回true的目的,都得以转移为类对象,只不过有个别恐怕要求强制调换。

前行转型能够活动举办,那本正是符合逻辑的,狗类承继自动物类,它自己就是二只动物,由此在须要动物类的时候,丢一头狗过去就能够活动演变转型成动物类。但那时狗已经不是狗,而是动物,所以狗独有的成员不再可以预知。

强制调换的秘籍和基本功数据类型强制调换同样,都以在待转变对象前拉长目的项目,比方将动物a强制转换为狗d: Dog d = (Dog)a 。

上面是三个目标类型转变的示范,很好地剖判了是或不是转型、转型后是不是访问些成员等等。

class Animal {
    String name;
    Animal(String name) {this.name = name;}
}

class Cat extends Animal {
    String eyecolor;
    Cat(String name,String color) {super(name); this.eyecolor = color;}
}

class Dog extends Animal {
    String furcolor;
    Dog(String name,String color) {super(name); this.furcolor = color;}
}

public class OCast {
    public static void main(String [] args) {
        Animal a = new Animal("animal");
        Cat c = new Cat("cat","blue");
        Dog d = new Dog("dog","black");

        System.out.println( a instanceof Animal);//return true
        System.out.println( c instanceof Animal);//return true
        System.out.println( d instanceof Animal);//return true
        System.out.println( a instanceof Cat);   //return false

        System.out.println(a.name); //return animal
        a = new Dog("yellowdog","yellow");       //object Dog upcast to Animal
        System.out.println(a.name);              //return yellowdog
        System.out.println(a instanceof Animal); //return true
        System.out.println(a instanceof Dog);    //return true
        //System.out.println(a.furcolor);        //error! because a was regarded as Animal
        Dog d1 = (Dog)a;     // because "a instanceof Dog" is true,so force cast Animal a to Dog
        System.out.println(d1.furcolor);         //return yellow
    }
}

对于地点的 a = new Dog("yellowdog",yellow) ,a是Animal类型,但这个时候 它指向的是Dog对象。也正是说它是Dog,所以也是Animal类 ,所以 a instanceof Animal); 和 a instanceof Dog; 都以true,那是它的”指针”决定的。 但因为它的门类是Animal类型,类型决定了能积攒什么样的多寡,对于早就存在的但不切合项目标数据都是不可以预知的,所以Animal类型决定了它一定要见到Dog对象中的Animal部分 。如下图:

图片 3

既是能够发展转型,协作instanceof的逻辑推断,就能够兑现很好的扩充性。比如,动物类的sing(Animal
a)方法需求的是叁个动物类,能够给它三只狗d,那时会发展转型(好似要求double类型却给了多少个int数据风流倜傥致),纵然转型了,但狗d的实在引用仍然为Dog对象,于是 if (a instanceof Dog) 决断为真,则调用能反映狗sing()方法特殊性的语句。假设传递一只猫,if剖断一下并调用能反映猫sing()方法特殊性的言语。那样,任何时候想增添八只动物,都只须要追加一条if语句就能够了。见上面包车型大巴示范:

class Animal {
    String name;
    Animal(String name) {
        this.name = name;
    }
}

class Cat extends Animal {Cat(String name) {super(name);}}
class Dog extends Animal {Dog(String name) {super(name);}}

public class TestCast {
    public static void main(String [] args) {
        TestCast t = new TestCast(); 
        Animal a = new Animal("animal");
        Animal c = new Cat("cat");
        Animal d = new Dog("dog");
        t.sing(a);t.sing(c);t.sing(d);
    }

    void sing(Animal a) {
        if ( a instanceof Cat) {
            Cat cat = (Cat)a;
            System.out.println("cat is singing");
        } else if(a instanceof Dog) {
            Dog dog = (Dog)a;
            System.out.println("dog is singing");
        } else {
            System.out.println("not an instance of animal");
        }
    }
}

即使未有对象转型,那么Dog里要定义二回sing(),Cat里也要定义一回sing()。要加进多个动物类,动物类里也还要定义一次sing()。未来就方便多了,直接在sing()方法内部校勘if语句就可以了。

在乎,下面的sing()方法不属于Animal或其他子类的法子,而是独立定义在其它类里进行调用的。

 

运算符的概念:  

  对常量和变量实行操作的标记称为运算符

多态

迈入转型就算在料定程度上提升了可扩充性,但增进的品位并不太高。以提升转型为根基,java的多态实现的扩张性越来越好更利于。

多态也叫动态绑定或后期绑定,它是实行时期实行的绑定,而非编写翻译时期的绑定(那是静态绑定或称为中期绑定)。

多态的准绳是:当发展转型后,调用一个被重写的主意时,本该调用的是父类方法,但骨子里却会动态地调用子类重写后的章程。实际上,编写翻译时期绑定的着实是父类方法,只可是在执行时期动态转调子类对应措施。

比方,Animal类的sing()方法,Cat和Dog类都重写了sing()方法。当需求贰个Animal对象时,传递了二个Cat类,那么将调用Cat的sing()方法。动态绑定的逻辑正如上面包车型地铁代码相仿:

void sing(Animal a) {
    if ( a instanceof Cat) {
        Cat cat = (Cat)a;
        System.out.println("cat is singing");
    } else if(a instanceof Dog) {
        Dog dog = (Dog)a;
        System.out.println("dog is singing");
    } else {
        System.out.println("not an instance of animal");
    }
}

以下是贰个多态的例证:

class Animal {
  private String name;
  Animal(String name) {this.name = name;}

  public void sing(){System.out.println("animal sing...");}
}

class Cat extends Animal {
  private String eyeColor;
  Cat(String n,String c) {super(n); eyeColor = c;}

  public void sing() {System.out.println("cat sing...");}
}

class Dog extends Animal {
    private String furColor;
    Dog(String n,String c) {super(n); furColor = c;}

    public void sing() {System.out.println("dog sing...");}
}

class Lady {
    private String name;
    private Animal pet;
    Lady(String name,Animal pet) {this.name = name; this.pet = pet;}
    public void myPetSing(){pet.sing();}
}

public class DuoTai {
    public static void main(String args[]){
        Cat c = new Cat("catname","blue");
        Dog d = new Dog("dogname","black");
        Lady l1 = new Lady("l1",c);
        Lady l2 = new Lady("l2",d);
        l1.myPetSing();
        l2.myPetSing();
    }
}

编写翻译后的奉行结果为:

cat sing...
dog sing...

在上头的亲自去做中,Lady类的构造方法和她调用sing()方法的代码为:

Lady(String name,Animal pet) {this.name = name; this.pet = pet;}
public void myPetSing(){pet.sing();}

若果组织出Lady对象的pet是Cat对象c,那一个c首先会发展转型为Animal类,也正是说Lady的pet属性即使针对的是”Cat
c”对象,但它一定要看到里面包车型客车父对象Animal部分。那么 myPetSing(pet.sing();) 方法自然会调用Animal类的sing()方法。 以上进度是编译器所以为的经过,也是静态绑定或前期绑定的历程。

但编写翻译达成后,尽管pet属性只可以看到Animal部分,但实际上在施行时pet.sing()却换转变为实施c.sing()。就也就是做了三回对象类型强制转变 Cat petx = (Cat)pet 。 那是动态绑定或中期绑定的历程,也号称多态。

事实上,对象在被new出来后,它所提到到的方法都位居code
segment内部存款和储蓄器区中的贰个措施列表中,这么些列表中带有了子类、父类的办法,只然而有些时候不可以知道的点子不恐怕去调用。当施行顺序时,内部的体制能够从点子列表中找寻觅最契合条件的秘技并实践它。

贯彻多态的技巧的关键点在于:

  • (1). 定义一个父类引用f,并将其目标个性类对象,即开展发展转型 ;
  • (2). 重写父类的章程,并应用父类引用f去援引那个办法。那样就能够面向父类进行编制程序 。

正如上面的演示中,将pet定义为Animal类而非具体的子类,并在艺术中调用pet.sing()。如此注重,就不需求思量pet到底是Cat/Dog,在扩充功效扩大增添Bird类时,完全不用再校正Lady类的这段代码。

再例如,父类Animal,子类Dog,方法sing()。

class Animal {public void sing(A);}
class Dog extends Animal {public void sing(B);}

public class Test {
    Animal a = new Dog();  //父类引用变量a指向子对象Dog,此时将向上转型
    a.sing();              //使用父类引用变量a引用被重写的方法sing(),执行时将动态绑定到Dog的sing()
}


欢迎加入学习交流群569772982,大家一起学习交流。

对象类型转变分为发展转型和向下转型(强制对象转型)。向上转型是子对象向父对象转型的过…

表明式的概念:

  用运算符把常量连接起来相符java语法的架势就能够称作表明式

  常用的运算符:算术运算符 赋值运算符 关系运算符 逻辑运算符 安慕希运算符

算数运算符: + – * / % ++ —
在java中多个int型数据开展除法运算获得的结果也是int 直接砍掉小数点

代码演示:
public static void main(String[] args) {

  int a = 10;
  int b = 20;

  System.out.println(a + b); // 30
  System.out.println(a – b); // -10
  System.out.println(a * b);// 200
  System.out.println(a / b);// 0
  System.out.println(1/2.0);//0.5
  System.out.println(1/3);//0
  System.out.println(2/3);//0
  System.out.println(“===========================”);
  // 当字符串与数字中间使用+的时候 表示链接 最后获得贰个新的字符串
  int d = 10;
  System.out.println(“嘿嘿”+10);//嘿嘿10
  System.out.println(“嘿嘿”+10+10);//嘿嘿1010
  System.out.println(“嘿嘿”+(10+10));//嘿嘿20
  System.out.println(10+10+”嘿嘿”);//20嘿嘿

  System.out.println(“===========================”);
  System.out.println(10%3);// 求余 取余数 (取模)
  System.out.println(7%2);// 1
  System.out.println(“======================”);
  // ‘a’ —> 97 ‘b’—> 98
  // ‘A’ —> 65
  // ‘0’—> 48
  System.out.println(‘a’ + 10);// 107
  System.out.println(‘A’ + 10);// 75
  System.out.println(‘0’ + 10);// 58
  System.out.println((char)(‘a’ + 1));//b

}

++运算符:

  当++ 运算符单独使用的时候 无论++符号在变量的左侧依旧左手都表示对这几个变量自增1
  当++运算符合营使用的时候, 若是++符号在变量的右手,
重申的是先改造(自增1)再合营,
  如若在变量的动手,重申先合营再转移(自增1)

— 运算符:

当– 单独采用的时候 无论–在变量的左侧依旧左边,
都表示对这几个变量进行自减1
当– 合营的利用的时候, 借使– 在变量的侧面, 重申的是先更改(自减1)
再合作,
借使在变量的左边,强调先合作再改造(自减1)
代码演示:
public static void main(String[] args) {

    int b = 10;
    System.out.println(b++);//10
    System.out.println(b);// 11
    System.out.println(“==================”);
    int c = 20;
    System.out.println(–c);// 19
    System.out.println(c);// 19

    int d = 30;
    System.out.println(d–);//30
    System.out.println(d);// 29
}

赋值运算符:

骨干的赋值运算符:=
恢宏的赋值运算符:+= -= *= /= %=
把左边手和右臂的结果赋值给左边
小心:左侧不可能是常量
富含了一个强制类型调换
好处:更高效
代码演示:
public static void main(String[] args) {

  int a = 10;
  a+=2; // a = a + (2) — > a = 10 + (2) —> a = 12
  System.out.println(a);// 12

  int b = 20;
  b-=2; // b = b – (2) —> b = 18
  System.out.println(b);//18

  short c = 10;
  //c = (short)(c + 10); // short = short + int —> short = int
  c+=10;
  System.out.println(c);//20

}

 

关系运算符:

==(等于) !=(不对等) >(大于) <(小于) >=(大于等于)
<=(小于等于)
涉及运算符的都以boolean型 要么正是true 要么便是false
代码演示:
public static void main(String[] args) {
// TODO Auto-generated method stub
  int a = 10;
  int b = 20;
  int c = 10;

  System.out.println( a == b);// false
  System.out.println( a == c);// true
  System.out.println(“======================”);
  System.out.println( a != b);// true
  System.out.println( a != c);// false
  System.out.println(“======================”);
  System.out.println( a >= b);// false
  System.out.println( a >= c);// true
  System.out.println(“======================”);
  System.out.println( a <= b);// true
  System.out.println( a <= c);// true  
  System.out.println(“======================”);
  System.out.println( a > b); // false
  System.out.println( a > c);// false
  System.out.println(“======================”);
  System.out.println( a < b);// true
  System.out.println( a < c);// false
  System.out.println(“======================”);

}

 

逻辑运算符:

逻辑运算符用于连接布尔表达式 最终的结果值为布尔型
在java中不可以写成3<x<6 应该写成x>3&&x<6
与: & 运算准绳: 就算两侧有一面为false那漫天表明式的结果就为false ,
独有两侧同一时候为true 结果才为true
或: | 运算法规: 假若两侧有二个为true那全部表明式的结果就为true ,
独有两侧同不经常候为false ,结果才为false
非: ! 运算准绳: 真变假 假变真
异或: ^ 运算法规: 两侧同样为false,分化为true
代码演示:
public static void main(String[] args) {

  System.out.println(true & true ); // T
  System.out.println(false & true );// F
  System.out.println(true & false );// F  
  System.out.println(false & false );// F
  System.out.println(“=========================”);
  System.out.println(true | true ); // T
  System.out.println(false | true );// T
  System.out.println(true | false );// T
  System.out.println(false | false );// F
  System.out.println(“=========================”);
  System.out.println(!true);// F
  System.out.println(!false);// T
  System.out.println(“=========================”);
  System.out.println(true ^ true ); // F
  System.out.println(false ^ true );// T
  System.out.println(true ^ false );// T
  System.out.println(false ^ false );// F

}

短路与: &&
短路或: ||
利润:效能越来越高
短路与: &&
  基本的运算准绳跟 & 类似 , 分化在于 ,
如果侧面为false,侧边不施行,直接把结果false
短路或: ||
  基本运算法则 跟 | 相像, 差异在于, 假若侧面为true ,侧边不推行,
直接把结果true再次回到
元正表明式:
表达式1 ? 结果1 : 结果2

进行流程:
先去总结表明式1的结果
借使结果为真 则赶回结果1 , 不然 再次来到结果2
代码演示:(获取五个数中山大学数。)
(int x=3,y=4,z;z = (x>y)?x:y;//z变量存款和储蓄的正是七个数的大运。)
public class Demo09Operator {
public static void main(String[] args) {
    int a = 10;
    int b = 20;
    int c = (a > b) ? a : b;
    System.out.println(“c:” + c);
  }
}

(比超级多少个数据是或不是生机勃勃致)
public class Demo10Operator {
public static void main(String[] args) {
// 定义七个int类型的变量
    int a = 10;
    int b = 20;

    boolean flag = (a == b) ? true : false;
    // boolean flag = (a == b);
    System.out.println(flag);
  }
}

(获取多少个整数中的最大值)
public class Demo11Operator {
public static void main(String[] args) {
// 定义八个int类型的变量
    int a = 10;
    int b = 30;
    int c = 20;

// 先相比四个整数的大值
    int temp = ((a > b) ? a : b);
    int max = ((temp > c) ? temp : c);
    System.out.println(“max:” + max);
  }

}

类型转变: 从小到大的排序 自动类型转变(隐式转变)
小的数据类型与大的数据类型进行演算的时…

相关文章