第四天1

类型转换

运算中，不同类型的数据先转化为同一类型，然后进行运算。

低 ------------------------------------------------------------------------->高

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

 package com.kuang.base;
 ​
 public class Demo05 {
     public static void main(String[] args) {
         int i = 128;
         double b = (double)i; //内存溢出
 ​
         //强制类型转换   （类型）变量名    高--低
         //自动类型转换                     低--高
 ​
         System.out.println(i);   //128
         System.out.println(b);   //128.0
 ​
         /*
         注意点：
         1.不能对布尔值进行转换
         2.不能把对象类型转换为不相干的类型
         3.在把高容量转换到低容量的时候，强制转换
         4.转换的时候可能存在内存溢出，或者精度问题！
          */
 ​
         System.out.println("======================");
         System.out.println((int)23.7);   //23
         System.out.println((int)-45.89f);  //-45
 ​
         System.out.println("======================");
         char c = 'a';
         int d = c+1;
         System.out.println(d);   //98
         System.out.println((char)d);  //b
     }
 }
 package com.kuang.base;
 ​
 public class Demo06 {
     public static void main(String[] args) {
         //操作比较大的数的时候，注意溢出问题
         //JDK7的新特性，数字之间可以用下划线分割
         int money = 10_0000_0000;  //下划线不会被输出
         int years = 20;
         int total = money*years; //-1474836480，计算时溢出了
         long total2 = money*years;//默认是int，转换前已经存在问题了
 ​
         long total3 = money*((long)years);//先把一个数转换为long
         System.out.println(total3);
     }
 }

 

变量

变量是可以变化的量

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

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

type varName [=value] [{,varName[=value]}];

//数据类型 变量名 = 值 ; 可以使用逗号隔开来声明多个同类型变量

注意事项：

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

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

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

 

 package com.kuang.base;
 ​
 public class Demo07 {
     public static void main(String[] args) {
         //int a,b,c;
         //int a=1,b=2,c=3;  //程序可读性
         String name = "qinjiang";
         char x = 'X';
         double pi = 3.14;
     }
 }

变量作用域

  • 类变量

  • 实例变量

  • 局部变量

 package com.kuang.base;
 ​
 public class Demo08 {
 ​
     //类变量  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 com.kuang.base.Demo08();
         Demo08 demo08 = new Demo08();
         System.out.println(demo08.age);
         System.out.println(demo08.name);
 ​
         //类变量  static
         System.out.println(salary);
     }
 ​
     //其他方法
     public  void add(){
 ​
     }
 }

 

常量 final

初始化之后不能再改变值！不会变动的值。

常量名一般使用大写字符

//修饰符，不存在先后顺序

 package com.kuang.base;
 ​
 public class Demo09 {
 ​
     //修饰符，不存在先后顺序
     static final double PI =3.14;
     // final static double PI =3.14;
 ​
     public static void main(String[] args) {
         System.out.println(PI);
     }
 }

变量的命名规范

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

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

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

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

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

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

 

运算符

Java语言支持如下运算符：

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

  • 赋值运算符：=（赋值）

  • 关系运算符：>，<，>=，<=，==（等于），!=instanceof（不等于）

  • 逻辑运算符：&&（与），||（或），!（非）

上面四个需要记住，下面三个只需了解

  • 位运算符：&，|，^，~，>>，<<，>>>

  • 条件运算符：?，:

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

 

下面图片只说了上面三个运算符

 package com.kuang.operator;
 ​
 //*是导入这个包下所有的类
 import com.kuang.base.*;
 ​
 public class Demo01 {
     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/b);//此处应=0.5，但是int只输出0
         System.out.println(a/(double)b);//0.5
 ​
     }
 }
 package com.kuang.operator;
 ​
 public class Demo02 {
     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
         System.out.println(b+c+d);//Int
         System.out.println(c+d);//Int
     }
 }
 package com.kuang.operator;
 ​
 public class Demo03 {
     public static void main(String[] args) {
         //关系运算符返回的结果：正确，错误   布尔值（true false）
         // if
 ​
         int a = 10;
         int b = 20;
         int c = 21;
 ​
         //取余，模运算
         System.out.println(c%a);// c/a  21/10=2...1
 ​
         System.out.println(a>b);//false
         System.out.println(a<b);//trur
         System.out.println(a==b);//false
         System.out.println(a!=b);//true
     }
 }
 package com.kuang.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);//4
         //a++  a=a+1
         int c = ++a;//执行完这行代码前，先自增，再给c赋值
 ​
         System.out.println(a);//5
         System.out.println(b);//3
         System.out.println(c);//5
 ​
         //幂运算 2^3=2*2*2=8 很多运算，我们会使用一些工具类来操作
         double pow = Math.pow(2,3);
         System.out.println(pow);//8.0
     }
 }

 

包机制

包机制

红字：举例：com.baidu.www

 

posted @ 2021-03-07 21:45  Ehua  阅读(41)  评论(0)    收藏  举报