java的基础语法（中）

java的基础语法（中）

类型转换

• 由高到低，强制换换：（类型）变量名（定义时操作）

• 由低到高，自动转换

• 注意点：

1. 不能对布尔值进行转换
2. 不能把对象类型转换成不相干类型
3. 把高容量转化成低容量时强制转换
4. 转化时可能出现内存溢出

public class demo04 {
    public static void main(String[] args) {
        int i=128;
        byte b=(byte)i;//内存溢出
        double m=i;
        //由高到低      强制转换:     (类型)变量名
        //由低到高      自动转换

        System.out.println(i);
        System.out.println(b);
        System.out.println(m);
        /*
        1.不能对布尔值进行转换
        2. 不能把对象类型转化成不相干类型
        3.在把高容量转化成低容量时强制转换
        4.转换时可能出现内存溢出，或精度问题！
         */
        System.out.println("===================================================================");

        System.out.println((int)25.6);//25
        System.out.println((int)-223.4f);//-223
        System.out.println("===================================================================");

        char c='a';//a=97
        int d=c+1;
        System.out.println(d);
        System.out.println((int)c);//输出97
        System.out.println((char)d);//输出b

5. 操作比较大的数时注意溢出问题

• JDK7新特性，数字之间可以用下划线分割
• 记住每种数据类型的容量
• 溢出时，把任意一个变量转化成高容量，结果就能正确输出

public class demo05 {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money=10_0000_0000;
        int years=20;
        int total=money*years;
        System.out.println(total);
        long total2=money*years;//前两个结果不正确，可见溢出了
        System.out.println(total2);//默认是int，转换之前已经出现问题了
        long total3=((long)money)*(years);//把任意一个变量转化成long，结果就能正确输出
        long total4=(money)*((long)years);//把任意一个变量转化成long，结果就能正确输出
        System.out.println(total3);//正确输出
        System.out.println(total4);//正确输出 
    }
}

变量、常量、作用域

变量

• 变量是可以变化的量
• Java是一种强类型语言，每个变量都必须的声明其类型
• Java变量是程序中最基本的存储单元，其中包括变量名、变量类型和作用域
• 不建议在一行里定义多个值
• 类型分为基本类型和引用类型

public class Demo07 {
    //类变量
    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 Demo07()
        Demo07 demo07=new Demo07();
        System.out.println(demo07.age);
        System.out.println(demo07.name);

        //类变量 static
        System.out.println(salary);
    }
}

常量

• 不变的量
• 用final和final double
• 修饰符不存在先后顺序

public class Demo08 {
    //修饰符，不存在先后顺序；

    static final double PI=3.14;
    final static double PI0=3.14;
    public static void main(String[] args) {

    }
}

变量的命名规范

public class Demo09 {

    public static void main(String[] args) {
        /*变量的命名规范
        1. 所有变量、方法、类名：见名知意
        2.类成员变量：首字母小写和驼峰原则//eg：monthSalary  lastName
        3.局部变量：首字母小写和驼峰原则
        4.常量：大写字母和下划线 MAX_VALUE
        5.类名：首字母大写和驼峰原则 Demo
        6.方法名：首字母小写和驼峰原则 run（） runRun（）
         */

    }
}

基本运算符

java语言支持的运算符

• 算数运算符：+、-、*、/、%、++、–

• 赋值运算符：=

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

• 逻辑运算符：&&，||，！

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

• 条件运算符：？：

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

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

  public class Operator02 {
      public static void main(String[] args) {
          long a=1212121212121L;
          int b=132;
          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
          //有long输出long
          //没有long，都默认输出int
      }
  }
  

  public class Operator03 {
      public static void main(String[] args) {
          //关系运算符：正确、错误 布尔值
          int a=10;
          int b=21;
  
          System.out.println(a>b);
          System.out.println(a<b);
          System.out.println(a==b);
          System.out.println(a!=b);
          System.out.println(b%a);//取余运算、模运算
      }
  }
  

自增自减（及初识math类）

• 加号位置不同，执行顺序不同

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


        System.out.println(a);//输出5
        System.out.println(b);//输出3
        System.out.println(c);//输出5

        System.out.println("=======================================================================");
        //初识math类
        //幂运算   2^3=8  //很多运算，我们会用一些工具来操作！
        double pow=Math.pow(2,3);
        System.out.println(pow);
    }
}