java基础——day02-1 数据类型转换与算数运算符

数据类型转换

自动转换

　　自动转换：将取值范围小的类型 自动提升为取值范围大的类型

　　例如：一个int类型变量和一个byte类型变量进行加法运算，结果会返回什么类型呢？

package day02;

public class day02_1 {
    public static void main(String[] args) {
        int a = 1;
        byte b = 2;
        int sum0 = a+b;
//        当写byte sum1的时候 程序会报错 提示无法兼容 因为int超过了byte类型的长度
//        byte sum1 = a+b;
        System.out.println(getType(a));
//        class java.lang.Integer
        System.out.println(getType(b));
//        class java.lang.Byte
        System.out.println(getType(sum0));
//        class java.lang.Integer
    }
    public static String getType(Object value){
        return value.getClass().toString();
    }
}

　　答案：为int，因为byte 类型内存占有1个字节，在和 int 类型运算时会提升为 int 类型 ，自动补充3个字节，因此计算后的结果还是 int 类型。
　　同理：当一个 int 类型变量和一个 double 变量运算时， int 类型将会自动提升为 double 类型进行运算。

转换规则

　　范围小的类型向范围大的类型提升， byte、short、char 运算时直接提升为 int 。
　　byte、short、char ‐‐> int ‐‐> long ‐‐> float ‐‐> double

强制转换

　　使用场景：

　　例1：将1.5赋值到int类型会发生什么

package day02;

public class day02_2 {
    public static void main(String[] args) {
        //将1.5赋值到int类型
        int i = 1.5;
        //编译器会提示无法兼容，因为double占用8个字节，而int只有4个字节，索引int<double
    }
}

　　解决方法：将double类型，强制转换为int类型

package day02;

public class day02_2 {
    public static void main(String[] args) {
        //将1.5赋值到int类型
        //        int i = 1.5;
        //编译器会提示无法兼容，因为double占用8个字节，而int只有4个字节，索引int<double

        //强制转换
        int i = (int)1.5;
        System.out.println(i);
        //输出值为1
    }
}

　　例2：当一个 short 类型与 1 相加，其结果的类型一定会提升

package day02;

public class day02_3 {
    public static void main(String[] args) {
        short s = 1;
//        s = s+1;
        //编译器提示无法兼容 因为short只占2个字节 而int 型的1占四个字节
        s = (short)(s + 1);
        System.out.println(s);
        //输出 2
        System.out.println(getType(s));
        //输出 class java.lang.Short
    }
    public static String getType(Object value){
        return value.getClass().toString();
    }
}

　　解决方法：将int 类型的1 强制转换为short类型。

　　注意：

　　　　1.浮点型转换成整型，直接取消小数点，可能造成精度损失

　　　　2.int型转换成short型，会砍掉2个字节，可能造成数据丢失

运算符

算数运算符

 

　　注意：Java中，整数使用以上运算符，无论怎么计算，也不会得到小数结果，例如：

package day02;

public class day02_4 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a/10*10);
        //运行结果：0
    }
}

　　自增运算（++）:

　　当++在变量前，表示先加后赋值(变量i自己加1，将加1后的结果赋值给result，也就是说i先计算。i和result的结果都是2)

package day02;

public class day02_5 {
    public static void main(String[] args) {
        int i = 1;
        int result = ++i;
        System.out.println(i);
        //结果为2
        System.out.println(result);
        //结果为2
    }
}

　　

　　当++在变量后，表示先赋值再加（变量i先把自己的值1，赋值给变量result，此时变量result的值就是1，变量i自己再加1。i的结果是2，result的结果是1。）

package day02;

public class day02_5 {
    public static void main(String[] args) {
        int i = 1;
        int result = i++;
        System.out.println(i);
        //结果为2
        System.out.println(result);
        //结果为1
    }
}

　　自减运算（--）：

　　其运算顺序与自增运算一致，-- 在前表示先减后赋值，--在后表示先赋值后运算。

　　关于拼接：

　　当“+”符号在字符串中，就表示拼接

package day02;

public class day02_5 {
    public static void main(String[] args) {
        String str1 = "this";
        String str2 = " is ";
        String str3 = "a test";
        System.out.println(str1+str2+str3);
        //运行结果：this is a test
        System.out.println("5+5= "+5+5);
        //运行结果：5+5 = 55
    }
}

赋值运算符

 

 　　定义：赋值运算符，就是将符号右边的值，赋值给左边的变量。

package day02;

public class day02_6 {
    public static void main(String[] args) {
        //赋值运算符
        int a = 5+5;

        //加等于
        int i = 5;
        i+=3;//计算方式 i = i + 5 变量i先加5 再赋值变量i 所以结果为8
        System.out.println(i);

        //减等于
        int i2 = 4;
        i2 -= 3; //计算方式 i2 = i2 - 3 变量i2先减3 再赋值给变量i2 所以结果为1
        System.out.println(i2);

        //乘等于
        int i3 = 3;
        i3 *= 2; //计算方式 i3 = i3 * 2 变量i3先乘以2 再赋值给i3 所以结果为 6
        System.out.println(i3);

        //除等于
        int i4 = 4;
        i4 /= 2; //计算方式 i4 = i4 / 2 变量i4先除以2 再赋值给i4 所以结果为 2
        System.out.println(i4);

        //取余
        int i5 = 5;
        i5 %= 2; //计算方式 i5 = i5 / 2 余数为1 所以结果为1
        System.out.println(i5);
    }
}

比较运算符

 

　　比较运算符：是将两个数据之间进行比较的运算，运算结果都是布尔值，非true即false

package day02;

public class day02_7 {
    public static void main(String[] args) {
        int a= 1,b =2;
        System.out.println(a == b);
        //比较两数据是否相等 因为a < b 不相等 所以返回false

        System.out.println(a > b);
        //比较 左边数据 是否大于 右边数据 因为a < b 所以返回false

        System.out.println(a < b);
        //比较 左边数据 是否小于 右边数据 因为a < b 所以返回true

        System.out.println(a >= b);
        //比较 左边数据 是否大于等于 右边数据 因为a < b 且不等于b 所以返回false

        System.out.println(a <= b);
        //比较 左边数据 是否小于 右边数据 因为a < b 满足条件 所以返回true

        System.out.println(a != b);
        //比较 左边数据 是否不等于 右边数据 因为a < b也不等于b 所以返回true
    }
}

逻辑运算符

 

 

　　逻辑运算符：是用来连接两个布尔类型的运算符，运行结果都是布尔值true或者false

package day02;

public class day2_8 {
    public static void main(String[] args) {
        boolean a = false;
        boolean b = true;
        boolean c = false;
        boolean d = true;

        // && 与运算符 同真为真 为true 与运算 必须左右数据都为真才会为真
        System.out.println(b && d);

        // && 与运算符 一假一真 为false
        System.out.println(a && b);

        // && 与运算符 同假为假 为false
        System.out.println(a && c);

        // || 或运算符 同真为真 为true 或运算 左右数据有一个数据为真 即为真
        System.out.println(a || d);

        // || 或运算符 一真一假 为true
        System.out.println(a || b );

        // || 或运算符 同假为假 为false
        System.out.println(a || c);

        // ! 非运算符 非真为假 为false
        System.out.println(!b);

        // ! 非运算符 非假为真 为true
        System.out.println(!a);
    }
}

三元运算符

 　　三元运算符：类似与if语句

　　格式： 数据类型 变量名 = 布尔表达式？结果1:结果2

　　计算方式：

　　1.布尔类型表达式是true，三元运算符返回结果1，赋值给变量

　　2.布尔类型表达式是false，三元运算符返回结果2，赋值给变量

package day02;

public class day02_9 {
    public static void main(String[] args) {
        int a = 2;
        int b = 4;
        int result;
        result = (a>b)?(result=a):(result=b);
        //此处返回结果result = 4 因为a>b 不成立 所以result = 结果2
        System.out.println(result);

        //对比if语句
        if(a > b){
            result = a;
        }else {
            result = b;
        }
        //同三元运算符一样
        System.out.println(result);
    }
}

 

方法初识

方法

　　方法：我们将代码中一些重复用到的功能抽取出来，把代码单独定义再一个大括号内，形成一个单独的功能模块。当我们需要这个功能的时候，就可以去调用。这样可以实现代码的复用性也解决了代码冗余的现象，

　　定义格式：

　　

 　　定义格式解释：

　　.修饰符：目前固定写法public static。静态方法

　　.返回值类型：目前固定返回void类型。空类型 表示无返回值也不会报错。

　　.方法名：为功能模块起名。

　　.参数列表：暂时无参数。

　　.return:方法结束。因为返回值类型是void，所以可不写return。

　　例如：

package day02;

public class day02_10 {
    //主函数
    public static void main(String[] args) {
        //方法的调用
        FunctionA();
    }

    //定义方法
    public static void FunctionA(){
        System.out.println("this is a function!");
    }
}

　　调用练习：

　　将三元运算符抽取到自定义的方法中并调用

package day02;

public class day02_11 {
    public static void main(String[] args) {
        //此处的a,b变量为实参
      int a = 10;
      int b = 20;
      //打印输出三元运算的结果 20
        System.out.println(SanYuan(a,b));
    }

    //此处的a,b为形参
    public static int SanYuan(int a , int b){
        //定义返回结果
        int result;
        //定义三元运算符做判断 因为传递来的a=10 b=20 a<b 所以返回值应该为b的值20
        result = (a>b)?(result = a):(result = b);
        //返回结果
        return result;
    }
}

　　注意事项：

　　1.方法内不能再定义另外一个方法

package day02;

public class day02_12 {
    public static void main(String[] args) {
        FuncionA();
    }

    public static void FuncionA(){
        //错误写法
        public static void FunctionB(){

        }
    }
}

　　2.方法要定义在类中，main方法外面

package day02;

public class day02_12 {
    public static void main(String[] args) {
        //错误写法 在main函数类定义方法
        public static void FuncionA(){
            
        }
    }
    
}