Java基础语法 part3

类型转换

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

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

以上本质都是数字。

public class Demo {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte) i;      // 内存溢出
        double c = i;
        // 强制转换    （类型）变量名   高 --> 低
        // 自动转换     低 --> 高
        /*
        * 低  ------------------------------------------->  高
        byte,short,char --> int --> long --> float --> double
        * */
        /*
        * 注意点：
        * 1、不能对布尔值进行转换
        * 2、不能把对象类型转换为不相干的类型
        * 3、由高到低转换时，需要强制转换；反之，自动转换
        * 4、转换时可能存在两个问题 a、内存溢出，b、精度问题
        * */
        System.out.println(i);  // 128
        System.out.println(b);  // -128
        System.out.println(c);  // 128.0
        System.out.println(28.7);       // 28.7
        System.out.println((int)28.7);  // 28
    }
}

两个重点：

• 有高转低时，需要强制转换；由低转高时，自动转换
• 转换时可能存在的问题：
  • 内存溢出
  • 精度问题

public class Demo1 {
    public static void main(String[] args) {
        // 操作大数据时，注意内存溢出问题
        // JDK7新特性，数字之间可以用下划线_分割，且不被输出
        int money = 10_0000_0000;
        System.out.println(money);  // 1000000000
        int years = 20;
        int total1 = money*years;
        long total2 = money*years;  // 默认是int，先计算好再转换
        long total3 = money*(long)years;
        // int大概在正负21亿之间
        System.out.println(total1);  // -1474836480
        System.out.println(total2);  // -1474836480
        System.out.println(total3);  // 20000000000
    }
}

变量

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

变量作用域

• 类变量
• 实例变量
• 局部变量

public class Demo3 {

    // 类变量（静态变量） static
    static double salary = 2500;

    // 实例对象：从属于对象,可以不初始化
    // 不初始化，会变成这个类型的默认值 0 0.0 null false
    String name;
    int age;

    // main方法
    public static void main(String[] args) {

        // 局部变量：必须声明和初始化值,只在这个{}内有用
        int i = 10;
        System.out.println(i);

        // 用实例对象
        Demo3 demo3 = new Demo3();
        System.out.println(demo3.age);    // 0
        System.out.println(demo3.name);   // null

        // 类变量 static
        System.out.println(salary);
    }
    // 其他方法
    public void add() {
    }
}

常量

初始化后不再变动的值

可理解为一种特殊的变量，它的值被设定后，在程序运行中不允许被改变

利用final

常量名一般使用大写字符

public class Demo4 {
    
    // static 和 final 不区分前后
    static final double PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);
    }
}

变量的命名规范

类成员变量：驼峰 monthSalary

局部变量：驼峰 monthSalary

常量：大写&下划线 MAX_VALUE // 特殊

类名：首字母大写&驼峰 GoodMan // 特殊

方法名：驼峰 monthSalary()

运算符

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
        System.out.println(a/(double)b);  // 0.5
        /*long int short byte 几种类型相互计算时，
        * 如果有long，那么结果为long类型
        * 否则为int类型，哪怕byte和short相互计算也是int，
        * 但如果有double，那么结果为double类型*/
        
        // 关系运算法
        // > < >= <= == !=

        // 自增自减
        /*=======================*/
        int e = 3;
        int f = a++;  // 执行完这段代码后，先给f赋值，再自增
        int g = ++a;  // 执行完这段代码后，先自增，再给g赋值
    }
}

重点！自增自减得位置所带来的执行先后顺序

此外，注意逻辑运算符中的短路运算。

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

a&&b,//如果a为false，那么b不执行
a||b,//如果a为true，那么b不执行

位运算符：&，|，^（异或），~（取反），<<（左移） 相当于 *2 ，>>（右移） 相当于/2

// 位运算效率极高，注意多利用左移右移<<,>>, >>>(逻辑右移)
2*8
2*2*2*2
2<<3

三元运算符

？:

public class Demo03 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        // 字符串连接符 +
        System.out.println(a+b);    // 30
        System.out.println(""+a+b); // 1020
        System.out.println(a+b+""); // 30
    }
}

扩展赋值运算符

+=，-=，*=，/=