Java学习记录第六天

类型转换

• 由于java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。

低—————————————————>高

byte,short,char --> int --> long --> float --> double

• 运算中，不同类型的数据先转换成同一类型，然后进行运算。

public class Demo {
    public static void main(String[] args) {
        //强制转换   （类型）变量名   高--低
        int i=128;
        byte b=(byte)i;
​
        //自由转换    低--高
        /*int i=128;
        double b=i;*/
        System.out.println(i);
        System.out.println(b);
    }
}

结果：强制转换 128 -128

自由转换 128 128.0

注意点：

1. 不能对布尔值进行转换

2. 不能把对象类型转换为不相干的类型

3. 在把大容量转换成低容量的时候，强制转换

转换的时候可能存在内存溢出，或者精度问题

System.out.println((int)23.7); //23
System.out.println((int)-15.89f); //-15
char c='a';
int d=c+1;
System.out.println(d); // 98
System.out.println((char) d); // b

小技巧：数字之间可以用下划线分割，方便查看，输出不变

int money=10_0000_0000;
System.out.println(money);

操作比较大的数的时候，注意溢出问题

public class Demo {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money=10_0000_0000;
        int years =20;
        int total1=money*years;
        System.out.println(total1);//-1474836480,计算的时候就溢出了
​
        long total2=money*years;
        System.out.println(total2);//默认是int，转换之前已经存在问题了
​
        long total3=money*((long)years);
        System.out.println(total3);//先把一个数转换为long
    }
}

变量

定义：可以变化的量

public class Demo {
    public static void main(String[] args) {
       //int a,b,c
       //int a=1,b=1,c=1
       String name="yun";
       char x='X';
       double pi=3.14;
    }
}

变量作用域

• 类变量

• 实例变量

• 局部变量

public class Variable{
   static int allClick=0;    //类变量
   String str="hello word";  //实例变量
   
   public void method(){
       int i=0;  //局部变量
   }
}

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

变量的命名规范

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

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

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

• 常量：大写字母和下划线：MAX_VALUE

• 类名：首字母大写和驼峰原则：Man，GoodMan

• 方法名：首字母小写和驼峰原则：run（），runRun（）

常量

• 定义：初始化后不能再改变值

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

  final 常量名=值;
  final double PI=3.14;

• 常量名一般使用大写字符

public class Demo7 {
    static final double PI=3.14;
​
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

运算符

Java语言支持如下运算符：

• 算数运算符：+ ，- ， * ，/ ，%（取余），++ ，--

  public class Demo8 {
      public static void main(String[] args) {
          //二元运算符
          //Ctrl + D :复制当前行到下一行
          int a=10;
          int b=20;
          int c=25;
          int d=25;
  ​
          System.out.println(a+b);//30
          System.out.println(a-b);//-10
          System.out.println(a*b);//200
          System.out.println(a/(double)b);//0.5
      }
  }

  public class Demo9 {
      public static void main(String[] args) {
          long a=123123123123123L;
          int b=123;
          short c=10;
          byte d=8;
  ​
          System.out.println(a+b+c+d);//Long  123123123123264
          System.out.println(b+c+d);//int  141
          System.out.println(c+d);//int  18
      }
  }     

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

结果：4 5 3 5

• 赋值运算符：=

• 关系运算符：> , < , >= , <= , == , != instanceof

  public class Demo10 {
      public static void main(String[] args) {
          //关系运算符返回结果：  正确，错误   布尔值
  ​
          int a=10;
          int b=20;
          int c=21;
          
          System.out.println(a%b);// 1  取余  模运算
          System.out.println(a>b);//false
          System.out.println(a<b);//true
          System.out.println(a==b);//false
          System.out.println(a!=b);//true
      }
  }

• 逻辑运算符：&& , || , !

  public class Demo12 {
      public static void main(String[] args) {
          //与（and） 或(or)   非（取反）
          boolean a=true;
          boolean b=false;
  ​
          System.out.println("a&&b:"+(b&&a));//逻辑与运算：两个变量都为真，结果才为真
          System.out.println("a||b:"+(b||a));//逻辑或运算：两个变量有一个为真，则结果才为真
          System.out.println("!(a&&b):"+!(b&&a));//如果是真则变为假，如果是假则变为真
  ​
          //短路运算
          int c=5;
          boolean d=(c<4)&&(c++<4);
          System.out.println(d);
          System.out.println(c);
  ​
      }
  }

  结果：false true true false 5

• 位运算符：& , | , ^ , >> , << , >>>(了解)

  public class Demo13 {
      public static void main(String[] args) {    
      
      /*
      * A=0011 1100    
      * B=0000 1101
      * --------------------
      * A&B=0000 1100    两个都为1才为1  （与）
      * A|B=0011 1101    两个都为0才为0   （或）
      * A^B=0011 0001    相同是0，不相同是1  （异或）
      * ~B=1111 0010    
      
      * 算2*16怎么样最快？
      * 2*8=16 2*2*2*2
      * 效率及高！！！
      * <<   *2   （左移）
      * >>   /2   （右移）
      
       */
          System.out.println(2<<3);// 16
      }
  }

• 条件运算符：? :

  public class Demo5 {
      public static void main(String[] args) {
          //x ? y : z
          //如果x==ture,则结果为y,否则结果为z
  ​
          int score =80;
          String type =score<60 ?"不及格":"及格";//必须掌握
          //if
          System.out.println(type);
      }
  }

• 拓展赋值运算符：+= ，-= , *= , /=

  public class Demo14 {
      public static void main(String[] args) {
          int a = 10;
          int b = 20;
  ​
          a+=b;// a=a+b
          a-=b;// a=a-b
          System.out.println(a);
  ​
          //字符串连接符  + ,String
          System.out.println(""+a+b);//先变字符串  1020
          System.out.println(a+b+"");//先计算  30
  ​
      }
  }

  拓展Math

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

运算符优先级

在 Java 中，运算符按照优先级顺序进行计算。以下是常见的运算符按照优先级从高到低的顺序：

　　1. 一元运算符(从右向左)：++、--、+(正号)、-(负号)、!(逻辑非)、~(按位取反)

　　2. 算术运算符：*、/、%(取模)

　　3. 加法和减法运算符：+、-

　　4. 移位运算符：<<(左移)、>>(带符号右移)、>>>(无符号右移)

　　5. 关系运算符：<、>、<=、>=、instanceof

　　6. 相等运算符：==、!=

　　7. 位运算符：&(按位与)、^(按位异或)、|(按位或)

　　8. 逻辑运算符：&&(逻辑与)、||(逻辑或)

　　9. 条件运算符(三元运算符)：? :

　　10. 赋值运算符：=, +=, -=, *=, /=, %=, <<=, >>=, >>>=, &=, ^=, |=

　　需要注意的是，运算符的优先级决定了它们的计算顺序，但在需要时可以使用括号来改变运算的顺序。

视频讲解地址： Java基础10：三元运算符及小结_哔哩哔哩_bilibili