Day8补学类型转换，学习变量常量运算符

day8 补学

类型转换

public class demo4 {
    public static void main(String[] args){
        //操作比较大的时候，注意溢出问题
        //JDK新特性，数字之间可以用下划线分割，不会被输出
        int money=10_0000_0000;
        int years=20;
        int total=money*years;//结果是-1474836480，计算的时候溢出了
        System.out.println(total);//默认是int类型，转换之前已经存在问题了

再使用long类型看看结果：

public class demo4 {
    public static void main(String[] args){
        //操作比较大的时候，注意溢出问题
        //JDK新特性，数字之间可以用下划线分割，不会被输出
        int money=10_0000_0000;
        int years=20;
        int total=money*years;//结果是-1474836480，计算的时候溢出了
        long total1=money*years;
        
        System.out.println(total);//默认是int类型，转换之前已经存在问题了
    }

}

得到结果还是：

-1474836480

之前默认的是int类型，后面的money和years相乘也是int型相乘

使用类型转换，将其中一个int型数字转换为long类型：

public class demo4 {
    public static void main(String[] args){
        //操作比较大的时候，注意溢出问题
        //JDK新特性，数字之间可以用下划线分割，不会被输出
        int money=10_0000_0000;
        int years=20;
        int total=money*years;//结果是-1474836480，计算的时候溢出了
        long total1=money*years;
        
        long total2=money*((long)years);

        System.out.println(total2);//默认是int类型，转换之前已经存在问题了
    }

}

得出正确结果：

20000000000

变量

定义：就是可以变化的量。

Java是一种强类型语言，每个变量都必须声明其类型。

Java变量是程序中最基本的存储单位，其必要素包括变量名，变量类型和***作用域***。

注意事项

变量名必须是合法的标识符

每个变量都有类型，类型可以是基本类型，也可以是引用类型

变量声明是一条完整的语句，因此每一个声明都必须以分号结束

//数据类型  变量名=值；可以使用逗号隔开来声明多个同类型变量（不建议）。

变量作用域

类变量

实例变量

局部变量

public class demo6 {
    
    //属性：变量
    
    //实例变量：在类里面在方法外面使用，从属于对象；如果不自行初始化，运行结果是这个类型的默认值  0  0.0
    //布尔值初始值：默认值是false
    //除了基本类型，其余初始值都是null
    
    //main方法
    public static void println(String[] args){
          //局部变量：必须声明和初始化值，只在方法里面用
        int i=10;
        System.out.println(i);
        
        //变量类型  变量名字=new demo6();
        
    }
    
}

public class 1{
    static int a=1;  //类变量
    String bcd="hello,world"; //实例变量
    
    public void method(){
        int i=4;     //局部变量
    }
}

常量

定义：初始化后不能改变的值。

所谓常量可以理解成一种特殊变量，它的值被设定后，在程序运行过程中不允许被改变。

常量名一般使用大写字符

final 常量名=值    final double AB=3.11111

public class demo7 {    
//修饰符，不存在先后顺序   
 static final double AB=3.1111;   
    public static void main(String[] args){  
       System.out.println(AB);   
        }
       }

变量的命名规范

所有变量、方法、类名：见名知意

类成员变量：首字母小写和驼峰原则：monthSalary，除了第一个单词以外，后面的单词首字母大写

局部变量：首字母小写和驼峰原则

常量：大写字母和下划线

类名：首字母大写和驼峰原则

方法名：首字母小写和驼峰原则

运算符

算术运算符

package operator;
public class demo01 {   
 public static void main(String[] args){ 
        //二元运算
        int a=10;
        int b=20;
        int c=25; 
        int d=30; 
        System.out.println(a+b); 
        System.out.println(a-b);
        System.out.println(a*b);       
        System.out.println(a/b);   
   }
     }

输出结果：

30
-10
200
0

第四个a/b应该是等于0.5，但是它们是int类型，所以输出结果是0。

将它换为double类型，就能得到小数

package operator;public class demo01 {    
public static void main(String[] args){        
   //二元运算        
   int a=10;        
   int b=20;       
   int c=25;        
   int d=30;        
   System.out.println(a+b);        
   System.out.println(a-b);        
   System.out.println(a*b);        
   System.out.println(a/(double)b);    
}
}

输出结果：

30
-10
200
0.5    

赋值运算

package operator;public class Demo02 {    
public static void main(String[] args){        
   long a=1222333333333332L;        
   int b=145;        
   short c=20;        
   byte d=1;        
   System.out.println(a+b+c+d);//结果是Long类型        
   System.out.println(b+c+d);//结果是Int类型        
   System.out.println(c+d);//结果是Int类型    
}
}

输出结果：

1222333333333498
166
21

没有long时，所有非int类型转为int类型

关系运算

package operator;public class Demo03 {    
public static void main(String[] args) {        
   //关系运算符返回的结果： 正确，错误   布尔值        
   int a=10;        
   int b=20;        
   System.out.println(a>b);        
   System.out.println(a<b);        
   System.out.println(a==b);    
}
}

输出结果：

false
true
false

package operator;
public class Demo04 {    public static void main(String[] args) {
        //++ -- 自增 自减，一元运算符
        int a=3;
        int b=a++;
        //执行完这行代码后，先给b赋值，再自增       
        //a++   a=a+1;        
        System.out.println(b);        
        //a++   a=a+1;        
        int c=++a;
        //执行完这行代码前，先自增，再给b赋值        
        System.out.println(c);    
        }
        }

b=3,c=5

package operator;public class Demo04 {    
public static void main(String[] args) {        
    //++ -- 自增 自减，一元运算符        
    int a=3;        
    int b=a++;//执行完这行代码后，先给b赋值，再自增        
    //a++   a=a+1;        

    System.out.println(a);        
    //a++   a=a+1;        
    int c=++a;
    //执行完这行代码前，先自增，再给b赋值        
    System.out.println(c);    
}
}

a=4,c=5

幂运算

 //幂运算        double pow =Math.pow(3,2);        System.out.println(pow);

逻辑运算符

  //与  或  非      
  boolean a=true;      
  boolean b=false;   
     
  System.out.println("a && b:"+(a&&b));//逻辑与运算：两个变量都为真，结果才为true  
  System.out.println("a || b:"+(a||b));//逻辑或运算：两个变量有一个为真，则结果才为true    
  System.out.println("!(a && b):"+!(a&&b));//如果是真，则变为假，如果是假则变为真

输出结果：

a && b:false
a || b:true
!(a && b):true

短路运算

        int c=5;        
        boolean d=(c<5)&&(c++<4);        
        System.out.println(d);        
        System.out.println(c);

输出结果：

false5

因为d是错误的，d中的c不小于4，前面要是假的，后面的就不执行。

位运算

 A = 0011 1100       
 B = 0000 1101        
 A&B = 0000 1100 如果是00，01就是0，如果是11，就是1，位运算是根据位置来运算       
 A|B = 0011 1101 如果是00就是0，如果有1就是1        
 A^B = 0011 0001 相同为0，不同为1        
 ~B = 1111 0010 与原代码相反        2*8=16        <<  *2        >>  /2

<< *2,>> /2

0000 0000  0
0000 0001  1
0000 0010  2
0000 0011  3
0000 0100  4
0000 1000  8

System.out.println(2<<3);

输出结果为16

条件运算符

        //三元运算符        
        // x ? y : z       
        //如果x==true,则结果为y,否则结果为z        
        int score =70;        
        String type = score <60 ?"不及格":"及格";        
        System.out.println(type);

扩展运算符

 a+=b;//a=a+b

字符串连接符

        int a=10;
        int b=20;                
        //字符串连接符  +  ， String       
        System.out.println(""+a+b);        
        System.out.println(a+b+"");

输出结果：

10
20
30

第一行中""这个虽然没有打字，但它是String类型的，先执行字符串，所以就把它拼接起来了。

第二行是先进行的预算