2021-7-15

@java

变量，常量，作用域，运算符

变量

int a=1,b=3,c=3;//数据类型 变量名  =  值；可以用逗号隔开来声明多个同类型变量

注意事项

1. 每个变量都必须有类型，可以是基本类型，也可以是引用类型。
2. 变量名必须是合法的标识符
3. 变量声明必须是一条完整的语句，因此每一个声明都需要用英文的分号结束

public class demo6 {
    public static void main(String[] args) {
        //int a=1,b=2,c=3 一般不这样定义变量，保证程序的可读性
        //要养成良好的习惯
        String name = "laoli";
        char x = 'x';
        double pi = 3.14;
    }
}

变量作用域

1. 类变量
2. 实例变量
3. 局部变量

public class Demo7 {
    //类变量
    static double salary = 2500;//从属Demo7 随之而来随之而去
    //属性，变量
    //实例变量，从属于对象（这里面就相当于从属于demo7），如果不自行初始化，那么默认值一般为0，0.0
    //布尔值默认为false,除了基本类型，其余的都是null
    String name;
    int age;
    //main 方法
    public static void main(String[] args) {
        int i = 1;//局部变量在方法里面，必须声明和初始化值
        System.out.println(i);
        Demo7 demo7 = new Demo7();//输入 new当前类，然后ALT+回车快捷定义。 new Demo7（）；
        //现在就可以使用demo7调用实例变量了
        System.out.println(demo7.age);
        System.out.println(demo7.name);
        System.out.println(salary);
    }
}

常量

1. 常量初始化后不能再改变值！不会变动。
2. 常量是一种特殊的变量，设定后在程序运行中不允许被改变 final 常量名 = 值；
3. 常量名一般使用大写字符

变量的命名规范

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

运算符

1. 算数运算符 +，-，*，/，%，++，–
2. 赋值运算符 = a=10 把10赋值给a
3. 关系运算符 >,<,>=,<=,== ,!= instanceof
4. 逻辑运算符 &&,||,! 与或非
5. 位运算符 &，|，^,~,>>,<<,>>>
6. 条件运算符 ？：
7. 扩展关系运算符 +=，-=，*=，/=

算数运算符

public class Demo1 {
    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);
        System.out.println(a-b);
        System.out.println(a*b);
        //System.out.println(a/b);//结果是错的  因为类型不对，所以需要强制转换
        System.out.println(a/(double)b);
    }
}

public class Demo2 {
    public static void main(String[] args) {
        long a = 123456123456L;
        int b = 123;
        short c = 10;
        byte d = 8;
        //以下结果看7.14日各类型优先级博客
        System.out.println(a+b+c+d);//输出结果为Long类型 123456123597
        System.out.println(b+c+d);//输出结果为int类型 141
        System.out.println(c+d);//输出结果为int类型 18
    }
}```
## 关系运算符

```java
public class Demo3 {
    public static void main(String[] args) {
        //关系运算符 返回结果只有false和true两种
        int a = 10;
        int b = 20;
        int c = 11;
        //取余
        System.out.println(c%a);
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a!=b);
    }
}

关于自增自减运算符
重点为++在前还是++在后（–同理）

public class Demo4 {
    public static void main(String[] args) {
        //++ -- 自增自减
        int a = 3;
        int b = a++;
        //++在后，先给b赋值，然后自加一
        System.out.println(a);//输出结果为4
        //++在前，先自加一，再给C赋值
        int c = ++a;
        System.out.println(a);//输出结果为5
        System.out.println(b);//输出结果为3
        System.out.println(c);//输出结果为5
        //幂运算
        //Math 里面有各种各样的操作
        double pow = Math.pow(3,2);
        System.out.println(pow);//9.0
    }
}

逻辑运算符

public class Demo5 {
    public static void main(String[] args) {
        //与and 或or 非!(取反)
        boolean a = true;
        boolean b = false;

        System.out.println("a && b:"+(a&&b));//与运算 两个都为真，才都真
        System.out.println("a || b:"+(a||b));//或运算 只要有一个为真，即是真
        System.out.println("!(a && b):"+!(a&&b));//取反
        /*
        小tips
        当&&前为false时，&&后面的语句不会执行，直接跳过
        例子如下
         */
        int c = 4;
        boolean d = c<3 && c++<5;
        System.out.println(d);//毋庸置疑是错误的，因为c不小于3
        System.out.println(c);//输出结果为4，证明c++的自增没有执行
    }
}

位运算

public class Demo6 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101
        A&B 0000 1100 同位置 同为1结果为1 否则为0
        A/b 0011 1101 同位置 同为0结果为0 否则为1
        A^B 0011 0001 同位置 相同为0 否则为1
        ~B  1111 0010 取反


        位运算  效率特别高
        << *2
        >> /2
        0000 0000 0
        0000 0001 1
        0000 0010 2
        0000 0100 4
        ...........
         */
        System.out.println(2<<3);//输出结果为16
    }
}

条件运算符 和 扩展运算符（统称为偷懒运算符）

public class Demo7 {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        a+=b;//a = a+b
        System.out.println(a);//3
        a-=b;//a = a-b
        System.out.println(a);//1
        //字符串链接 +,有一方前面有String类型进行连接，后面的话不会改变
        System.out.println(""+a+b);//12
        System.out.println(a+b+"");//3
        //三元运算符
        //x ? y : z
        //如果x==true，则结果为y，否则为z
        int score = 60;
        int score1 = 50;
        String type = score <60 ?"不及格":"及格";
        System.out.println(type);//及格
        String type1 = score1 <60 ?"不及格":"及格";
        System.out.println(type1);//不及格
    }
}