Java基本语法笔记2021/9/14

• Java八大基本数据类型
• 常量
• 运算符

public class Hello {
    public static void main(String[] args) {
        //输出一个hello world
        System.out.println("Hello, World!");
        Hello h = new Hello();
        //h.dataType();  //八大基本数据类型
        //h.variable();  //常量
        h.operator();  //运算符
    }

    //==============八大基本数据类型=====================
    public void dataType() {
        //整数
        int num1 = 10;  //占4个字节，范围-2147483648~2147483647   32位
        byte num2 = 20; //占1个字节，范围-128~127
        short num3 = 30; //占2个字节，范围-32768~32767
        long num4 = 30L; //占8个字节，范围  64位

        //小数：浮点数
        float num5 = 10.1f; //占4个字节
        double num6 = 10.2; //占8个字节

        //字符
        char name = '哈'; //占2个字节
        String name1 = "哈哈哈";
        //字符串，String不是关键字，是类

        //布尔值：是非
        boolean flag = true; //占一位，1字节 = 8位
        //boolean flag = false;

        //引用数据类型：类，接口，数组

        //整数扩展：（进制）二进制0b 八进制0 十六进制0x
        int i = 10;
        int i1 = 010;   //八进制0
        int i2 = 0x10;  //十六进制0x  0~9 A~F 16
        System.out.println(i);    //10
        System.out.println(i1);   //8
        System.out.println(i2);   //16
        //==================================
        //浮点数扩展
        //==================================
        //float  有限  离散  舍入误差  大约  接近但不等于
        //double
        //最好完全避免使用浮点数进行比较!!
        //最好完全避免使用浮点数进行比较!!
        float f = 0.1f;
        double d = 1.0 / 10;
        System.out.println(f == d);//false

        float d1 = 23121212f;
        double d2 = d1 + 1;
        System.out.println(d1 == d2);//true

        //==================================
        //浮点数扩展
        //==================================
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);        //a
        System.out.println((int) c1);  //97
        System.out.println(c2);        //中
        System.out.println((int) c2);  //20013
        //所有的字符本质还是数字
        //编码 Unicode表：（97=a  65=A）2字节 0~65536

        // U0000 ~UFFFF
        char c3 = '\u0061';
        char c4 = '\u0055';
        System.out.println(c3); //a
        System.out.println(c4); //U
        //转义字符：\t,\n

        //类型转换
        //低→高  byte,short,char → int → long → float → double
        //强制类型转换   高 → 低
        //自动类型转换   低 → 高
        int x = 128;
        byte b = (byte) x;
        double y = x;          //低 → 高不用强制转换
        System.out.println(x); //128
        System.out.println(b); //-128   内存溢出
        System.out.println(y); //128.0
        /*
        注意点：
        1. 不能对布尔值进行转换
        2. 不能把对象类型转换成不相干的类型
        3. 在把高容量转换到低容量的时候，强制转换
        4. 转换的时候可能存在内存溢出，或者精度问题
         */
        System.out.println((int) 23.7);   //23
        System.out.println((int) -45.89f);//-45

        char c = 'a';
        int q = c + 1;
        System.out.println(q);       //98
        System.out.println((char) q); //b

        //操作比较大的时候注意溢出问题
        int money = 10_0000_0000; //数字之间可以用下划线分割
        int years = 20;
        int total = money * years;
        System.out.println(total);  //-1474836480   溢出
        long total2 = money * years;
        System.out.println(total2);  //默认是int,转换之前已经出现问题   -1474836480   溢出
        long total3 = money * (long) years;
        System.out.println(total3);  //20000000000
    }

    //===================常量=====================
    public void variable() {
        final double PI = 3.14;
        System.out.println(PI);
    }

    //===================运算符=====================
    public void operator() {
        //复制当前行到下一行 ctrl+alt+down
        //复制当前行到上一行 ctrl+alt+up
        //删除当前行  ctrl+d
        long a = 1515161616546L;
        int b = 128;
        short f = 12;
        byte d = 8;
        double e = 25;
        char c = 'a';
        // 含有高容量数据类型参与运算的结果的数据类型为高容量数据类型; 低于int的其他数据类型参与运算的结果类型都为int
        System.out.println(getType(a + b + c + d + e));  //class java.lang.Double
        System.out.println(getType(a + b + c + d));      //class java.lang.Long
        System.out.println(getType(b + c + d));          //class java.lang.Integer
        System.out.println(getType(c + d));              //class java.lang.Integer
        System.out.println(b + c);                          //128 + 97 = 225
        System.out.println(getType(b + c));              //class java.lang.Integer
        System.out.println(c + f);                          //12 + 97 = 109
        System.out.println(getType(c + f));              //class java.lang.Integer

        //++ --自增 自减
        int x = 3;
        int y = x++;  //x先自增，再赋值给y
        System.out.println(x);  //4
        int z = ++x;  //x先赋值给z,再自增
        System.out.println(y);  //3
        System.out.println(z);  //5

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

        //逻辑运算符: 与（and）  或（or）  非（取反）
        boolean p = true;
        boolean q = false;
        System.out.println("p&&q:" + (p && q));       //false
        // 短路：先判断q为false, 就不判断P了
        System.out.println("p&&q:" + (q && p));       //false
        System.out.println("p||q:" + (p || q));       //true
        System.out.println("!(p&&q):" + (!(p && q))); //true

        //短路实验
        int w = 5;
        boolean u = (w < 4) && (w++ > 1);
        System.out.println(u);  //false
        System.out.println(w);  //5  没有进行自增

        //位运算：&, |, ^(异或),  ~, >>, <<, >>>
        /*
        A =    0011 1100
        B =    0000 1101
        ------------------------------
        A&B=   0000 1100
        A|B=   0011 1101
        A^B=   0011 0001
        ~B=    1111 0010

        2*8 = 16  2*2*2*2=16
        效率极高！！！
        << 左移  相当于*2
        >> 右移  相当于/2
        0000 0000   0
        0000 0001   1
        0000 0010   2
        0000 0100   4
        0000 1000   8
        0001 0000   16
         */
        System.out.println(2 << 3);  //16  相当于2*2*2*2

        //字符串连接符  + ， String
        int m = 10;
        int n = 20;
        System.out.println("" + m + n);  //1020  ""在前，则将m和n先转成String,再与“”进行连接
        System.out.println(m + n + "");  //30    ""在后，则m+n依旧进行运算后，再与“”进行连接
        //三元运算符
        int score = 80;
        String type = score < 60 ? "不及格" : "及格";
        System.out.println(type);   //及格

    }

    //获取变量的数据类型
    private static String getType(Object a) {
        return a.getClass().toString();
    }
}

• 变量

//==================变量==================
public class Variable {

    //类变量  static
    static double salary=2500;
    //实例变量：从属于对象；如果不自行初始化，这个类型的默认值 0  0.0
    //布尔值：默认是false
    //除了基本类型，其余的默认值都是null
    String name;
    int age;

    public static void main(String[] args){
        //局部变量：必须声明和初始化值
        int i =10;
        System.out.println(i);

        //使用实例变量时
        Variable vab =new Variable();
        System.out.println(vab.name); //null
        System.out.println(vab.age);  //0
        //类变量可直接使用
        System.out.println(salary);   //2500.0
    }
}