一.变量的分类：

​ 从书写的位置区分

1.成员变量：

​ 【写在类里面的 和主方法平级】

​ 特点：

1.1作用范围：

​ 在当前类里面所有的方法都能使用成员变量

1.2

​ 成员变量可以不赋值，直接使用，系统会自动分配默认值，分配值根据数据类型不同而不同

​ 整数型默认值是 0

​ 浮点型默认值是 0.0

​ 字符型默认值是 空

​ 布尔型默认值是 false

​ 引用数据类型默认值都是 null

1.3

​ 成员变量不能重名

​ 如果main主方法中使用到成员变量，成员变量必须加上static修饰

​

2.局部变量：

​ 【写在方法里面或者代码块里面】

​ 特点：

​ 2.1只能在当前方法和代码块中使用

​ 2.2局部变量必须要先赋值再使用

​ 2.3局部变量不能重名

3.成员变量和局部变量的注意事项：

​ 3.1局部变量和成员变量可以重名

​ 3.2就近原则：先从小范围开始查找

public class Work02Text {
    //成员变量
    static int a = 10;
    static int num1;
    static byte num2;
    static short num3;
    static long num4;
    static float num5;
    static double num6;
    static char num7;
    static boolean num8;
    static String num9;

    public static void main(String[] args) {
        //局部变量
        int i= 10;
        //方法
        System.out.println(i);

        if (true){
            int i2 = 69;
            System.out.println(i2);
            System.out.println(i);
        }
        if (true){
            System.out.println(i);
        }
        /*
        static int a = 10;
        static int num1;
        static byte num2;
        static short num3;
        static long num4;
        static float num5;
        static double num6;
        static char num7;
        static boolean num8;
        static String num9;
         */

        }
    public void other() {
        int t =10;
        System.out.println(a);
# }
}

二.基础数据类型的转换

为什么需要使用类型转化：

​ boolean不进行数据类型转换

1.隐式转换/自动转换：

​ 1.1把一个小的数据类型赋值给大的数据

​ 1.2特别：char的类型转换 转换的是对应的其表中的数字

​ 1.3无语法

public class Work04DateChange {;

    public static void main(String[] args) {
        byte b = 127;
        short s = b;
        int i =s;
        long l = i;
        float f = l;
        double  d = f;


        //char
        char c = 'a';
        //把字符c赋值给int 实际上是把'a' 对应的数字97 赋值给i2
        int i2 = c;



        int i3 = 117;
        //把数字赋值给 char   实际上 是对应的字符 赋值给 char
        char cc = (char)i3;
        System.out.println(cc);

        float f2 = 255;
        System.out.println(f2);
        System.out.println("----------------------分割线----------------------");

2.强制转换：

​ 2.1把一个大的的数据类型赋值给小的数据类型

​ 2..2语法：数据类型 变量名 = (数据类型)变量名

​ 2.3注意事项：强制转换有风险，可能会存在精度损失； 小数转整数，小数点后的都会舍去，不会进行四舍五入

        double dd= 3.14;
        //语法：数据类型 变量名 = (数据类型)值/变量名; //值可能是更高的类型
        float ff = (float)dd;//没有精度的损失
        long ll = (long)ff;//出现精度的损失
        int ii= (int)ll;
        short ss = (short)ii;
        byte bb = (byte) ss;


        int iii = 137;
        byte bbb = (byte)iii;
        System.out.println(bbb);

    }
}

三.常量的默认类型：

​ 整数常量 ：默认类型是int值 最多只有十位

​ 变量值后面加一个 l / L

​ 浮点常量: 默认类型是double值

​ 通过强制转换赋值

​ float变量值后面加 f/F

​ byte short 以下的值都经过特殊处理

public class Work05DefaultType {
    public static void main(String[] args) {
        //通过强制转换赋值
        float f = (float)3.14;
        //加f显示的告诉jvm 这是一个float值 不是double
        float f2 = 3.14f;

        //12345678912 默认值是int   加L显示的告诉jvm 这是一个long值 不是int
        long l  = 12345678912L;

        System.out.println();
        byte b = 10;
    }
}

​

四.表达式

​ 右边变量

​ 4.1运算顺序和数学一样

​ 4.2

​ 1）当表达式中所有的变量类型小于****int*的时候，运算后的结果都会自动提升为*int****类型。

​ 2) 当表达式中有变量类型大于****int*的时候，运算后的结果以表达式中*精度最高****的为主。

public class Work06Expression {
    public static void main(String[] args) {
        byte byt = 1;
        short s = 2;
        int i = 3;
        long lon = 5l;
        float f = 1.0f;
        double doub = 3.14;


        //1.将上面所有的变量相加，得到一个表达式
        //2.当表达式中有变量类型大于int的时候，运算结果以表达式精度最高的为主
        double sum = byt + s + i + lon + f + doub;
        System.out.println(sum);


        //当表达式中所有的变量类型小于int的时候，运算结果都会自动提升为类型
        int sum2 = byt + s;
        System.out.println(sum2);
    }
}

五.运算符

1.数学运算

​ 【一旦出现字符串就不是数学远算了】

​ + 除了作为数学里的加号，还可以作为拼接符号

)

       //+号的两种用法
        System.out.println(123+123);//作为加法使用
        System.out.println(123+"123"); //作为拼接符号使用
        //计算的表达式里面 按照计算顺序一旦出现了字符串就不再是数学运算
        System.out.println(3+5+"ab");//8ab
        System.out.println("ab"+3+5);//ab35
        System.out.println(3+5+"ab"+3+5);//8ab35

​

​ - 减法

​ ***** 乘法

​ / (运算结果以常量的默认值显示，要想显示小数点位)

public class Work07Operator {
    public static void main(String[] args) {
        System.out.println(10/1);//10
        System.out.println(10/2);//5
        System.out.println(10/3);//3
        System.out.println(10/4);//2
        System.out.println(10/5);//2
        System.out.println(10/6);//1
        System.out.println(10/7);//1
        System.out.println(10/8);//1
        System.out.println(10/9);//1
        System.out.println(10/10);//1
 
    }
}

​ % (取模，取余数)

public class Work07Operator {
    public static void main(String[] args) {

        System.out.println(10%1);//0
        System.out.println(10%2);//0
        System.out.println(10%3);//1
        System.out.println(10%4);//2
        System.out.println(10%5);//0
        System.out.println(10%6);//4
        System.out.println(10%7);//3
        System.out.println(10%8);//2
        System.out.println(10%9);//1
        System.out.println(10%10);//0

 
    }
}

2.自增自减运算

​ 2.1自增自减只能对变量使用（只能用在变量上面，不能用在常量上面）

​ 2.2自增自减运算每次改变的步长为1 其不会改变变量本身的值

​

​ ++在后；先使用/运算再自增 ------------【在表达式里面使用的就是自增后的值】

​ ++在前；先自增再使用/运算 ------------【在表达式里面使用的就是自增前的值，使用结束后再自增】

public class Work08Operator {
    public static void main(String[] args) {
        int a = 5;
        a++;//a=6
        System.out.println(a++);//打印6 运算后结果为7
        System.out.println(a++);//打印7 运算后结果为8


        ++a;
        System.out.println(a++);//打印6 运算后结果为7
        System.out.println(a++);//打印7 运算后结果为8;
        System.out.println(a);
    }
}

​



int x = 3;
int y = x++ + x++ + x++;
int z = ++x + ++X + ++x;

x = 9
y = 12
z = 24

​

3.赋值运算

​ 【把运算结果赋值给变量本身的一种缩写】

​ 结论：不会改变变量本身的数据类型


public class Work09Operator {
    public static void main(String[] args) {
        int i = 10;
        //赋值运算：把运算结果赋值给变量本身的一种缩写

        i+=10;//i=i+10;
        i-=10;//i=i-10;
        i*=10;//i=i*10;
        i/=10;//i=i/10;
        i%=10;//i=i%10;

        System.out.println(i);
    }
}
i=i+10；//会出现编译报错
i+=10;//结论：不会改变变量本身的数据类型
 

4.比较运算

​ 【比较运算的结果是布尔值】


5.逻辑运算

​ 【将多个进行组合性的表达结果】

​ & 与------并且 两边都为true ，结果为true


​ | 或-----或者

​ 

​ ！ 非------取反

​ && 双与 和&意思结果一致 不同点在于具有短路效果 执行效率更高

​ || 双或 和&意思结果一致 不同点在于具有短路效果 执行效率更高

​ 当符号左边的比较运算结果已经可以确定整个结果

​ ^ 异或 两边结果不一样为 true

public class Work10Operator {
    public static void main(String[] args) {
       

        int java =100;
        int php =99;


        System.out.println(java==100  &&  php==100);//false
        //| --或者: 只要有一边为true，结果为true
        //                   true         false
        System.out.println(java==100  ||  php==100);//true
        //取反
        System.out.println(!true);
        System.out.println(!false);

        System.out.println("----------------------------");
        int i = 69;
        //                  false    整个表达已经不可能为true
        System.out.println(i>=100 && i++<=150);
        System.out.println(i);
        //                  true     true
        System.out.println(i>=69 && ++i<=100);

        int z = 10;
        //                  true
        System.out.println(z>=10 || z++<=50);//true
        System.out.println(z);
        //                  false
        System.out.println(z>=20 || z++<=50);


        System.out.println(false ^ false);
    }
}

6.三目运算/三元运算:

​ 写法： x?y:z

​ x: 必须是一个布尔值或者结果为布尔值的表达式【boolean变量，比较运算，逻辑运算】

​ ? 分隔符

​ y: 当X的值为true整个三目运算的结果为y

​ z: 当x的值为false整个三木运算的结果为z

例如：

public class Work11Operator {


    public static void main(String[] args) {
        //判断一个数是否是3的倍数
        int num = 16647;
        //直接输出三目运算的结果
        System.out.println(num%3 ==0?num+"是3的倍数":num+"不是3的倍数");

        String s = num % 3 == 0 ? num + "是3的倍数" : num + "不是的倍数";
        //输出变量
        System.out.println(s);


        int a = 85;
    }
}

public class Work4 {
    public static void main(String[] args) {
        // /*
        //        三目运算可以嵌套使用,
        //            定义成绩分数 判断当前成绩等级
        //                0-59   结果 D
        //                60-69  结果 C
        //                70-89  结果 B
        //                90+    结果 A
        //        */
        int score= 20;
        String  result = score>=90 && score<=100 ?"A": (score>=70 && score<=89
        ? "B":(score>=60 && score<=69 ? "C" : "D"));
        System.out.println(result);
    }
}

7.位运算[了解]

把十进制数字钟转换为二进制

1为true 0为false

&：按位与

|：按位或

^ :

右移三位 就是把非零的数字又移三位 >>

<< :左移三位 就是把非零的数字左移三位

Sannner: 使用的注意事项：

​ 1.尽量Src