Java SE 学习记录02

@学习记录

开始学习Java

遵从同学的指导，从Java se开始学习

黑马的JavaSE零基础入门

day02-01 数据类型转换

public class HelloWorld {  
    public static void main(String[] args) {
        /*
        当数据类型不一样时，将发生数据类型转换

        自动类型转换（隐式）
        1.特点：代码不需要进行特殊处理，自动完成
        2.规则：数据范围从小到大

        强制类型转换（显示）
         */
        System.out.println(1024); // 这是一个整数，默认是int
        System.out.println(3.14); // 这是一个浮点数，默认是double

        // 左边是long类型，右边是默认的int类型，左右不一样
        // 一个等号代表赋值，将右边的int常量，交给左边long变量进行存储
        // int --> long,符合数据范围从小到大的要求
        // 这一行代码发生了自动类型转换
        long num1 = 100;
        System.out.println(num1); // 100

        // 左边是double类型，右边是float类型，左右不一样
        // float --> double,符合数据范围从小到大的要求
        // 也发生了自动类型转换
        double num2 = 2.5F;
        System.out.println(num2); // 2.5

        // 左边是float类型，右边是long类型，左右不一样
        // long --> float,符合数据范围从小到大的要求
        // 也发生了自动类型转换
        float num3 = 30L;
        System.out.println(num3); // 30.0

        /*
        强制类型转换
        1.特点：代码需要进行特殊的格式处理，不能自动完成
        2.格式：范围小的类型 范围小的变量名 = （范围小的类型）原本范围大的数据

        注意事项：
        1.强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出
        2.byte/short/char这三种类型都可以发生数学运算，例如加法
        3.byte/short/char这三种类型在运算的时候，都会被首先提升为int类型，然后再计算
        4.boolean类型不能发生类型转换
         */
        // 左边是int类型，右边是long类型，左右不一样
        // long --> int,不符合数据范围从小到大的要求
        // 不能发生自动类型转换
        int num4 = (int)100L;
        System.out.println(num4);

        int num5 = (int)6000000000L;
        System.out.println(num5); // 1705032704 数据溢出

        // double --> int,强制类型转换
        int num6 = (int)3.5;
        System.out.println(num6); // 3 精度损失，不是四舍五入，所有的小数位都会被舍弃掉

        char zifu1 = 'A'; // 这是一个字符变量，里面是大写字母A
        System.out.println(zifu1+1); // 66，也就是A被当成了65
        // 计算机的底层会用一个数字代表字符A,就是65
        // 一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字

        byte num7 = 40; // 注意，右侧的数值大小不能超过左侧的类型范围
        byte num8 = 50;
        // byte + byte --> int + int --> int
        int result = num7 + num8;
        System.out.println(result); // 90

        short num9 = 60;
        // byte + short --> int + int --> int
        // int强制转换为short，必须保证逻辑上真实大小本来就没有超过short范围
        short result2 = (short)(num7 + num9);
        System.out.println(result2); // 100
    }
}

day02-04 ASCII编码表

48 - ‘0’
65 - ‘A’
97 - ‘a’

day02-05 算术运算符_四则运算与取模运算

public class HelloWorld {  
    public static void main(String[] args) {
        /*
        运算符：进行特定操作的符号
        表达式：用运算符连起来的式子

        四则运算：
        加：+
        减：-
        乘：*
        除：/

        取模（取余数）：%

        首先计算得到表达式的结果，然后再打印输出这个结果
        对于一个整数的表达式来说，除法用的是整除，整数除以整数，结果仍然是整数，只看商，不看余数
        只有对于整数的除法来说，取模运算符才有余数的意义

        注意事项：
        1.一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种
         */

        // 两个常量之间可以进行数学运算
        System.out.println(20+30);

        // 两个变量之间也可以进行数学运算
        int a = 20;
        int b = 30;
        System.out.println(a-b); // -10

        // 变量和常量之间可以混合使用
        System.out.println(a*10); // 200

        int x = 10;
        int y = 3;
        int result = x / y;
        System.out.println(result); // 3

        int result2 = x % y;
        System.out.println(result2); // 1

        // int + double --> double + double --> double
        double result3 = x + 2.5;
        System.out.println(result3); // 12.5
    }
}

day02-06 算术运算符_加号的多种用法

public class HelloWorld {  
    public static void main(String[] args) {
        /*
        四则运算中，加号有三种常见的用法：
        1.对于数值而言，是加法
        2.对于字符char类型而言，在计算前，char会被提升成int，然后再计算
        3.对于字符串String（首字母大写，并不是关键字）而言，代表字符串的连接操作
        任何数据类型和字符串进行连接的时候，结果都会变成字符串
         */

        // 字符串类型的变量基本使用
        // 数据类型 变量名称 = 数据值；
        String str1 = "Hello";
        System.out.println(str1); // Hello
        System.out.println(str1 + "World"); // HelloWorld

        String str2 = "Java";
        // String + int --> String
        System.out.println(str2 + 20); // Java20

        // 优先级问题
        // String + int + int
        // String       + int
        // String
        System.out.println(str2 + 20 + 30); // Java2030

        System.out.println(str2 + (20 + 30)); // Java50
    }
}

day02-07 算术运算符_自增自减运算符

public class HelloWorld {  
    public static void main(String[] args) {
       /*
        自增运算符：++
        自减运算符：--

        使用方式：
        1.单独使用
        2.混合使用

        使用区别：
        1.单独使用时，前++和后++没有任何区别
        2.在混合使用时，有【重大区别】
            A.如果是【前++】，那么变量立刻加一，再使用【先加后用】
            B.如果是【后++】，那么先使用变量本来的数值，再让变量+1【先用后加】

         注意事项：
         只有变量才能使用自增、自减运算符，常量不可发生改变，不能用
         */

        int num = 10;
        System.out.println(num); // 10
        ++num;
        System.out.println(num); // 11
        num++;
        System.out.println(num); // 12
        System.out.println("=================");

        // 和打印操作混合的时候
        int  num2 = 20;
        System.out.println(++num2); // 混合使用，先加后用，21
        System.out.println(num2); // 21
        System.out.println("=================");

        int num3 = 30;
        System.out.println(num3++); // 先用后加，30
        System.out.println(num3); // 31
        System.out.println("=================");

        // 和赋值操作混合
        int num4 = 40;
        int result1 = --num4;
        System.out.println(result1); // 39
        System.out.println(num4); // 39
        System.out.println("=================");

        int num5 = 50;
        int result2 = num5--;
        System.out.println(result2); // 50
        System.out.println(num5); // 49
        System.out.println("=================");

        int x = 10;
        int y = 20;
        int result3 = ++x + y--;
        System.out.println(result3); // 11+20=31
        System.out.println(x); // 11
        System.out.println(y); // 19
    }
}

day02-08 赋值运算符

package com;

public class Demo01 {
    public static void main(String[] args){
        /*
        赋值运算符分为：
        基本赋值运算符：=
        复合赋值运算符：
        +=   a += 1 相当于 a = a + 1
        -=   b -= 4 相当于 b = b - 4
        *=   c *= 5 相当于 c = c * 5
        /=   d /= 6 相当于 d = d / 6
        %=   e %= 7 相当于 e = e % 7

        注意事项：
        1.只有变量才能使用赋值运算符，常量不能进行赋值
        2.复合赋值运算符中隐含了一个强制类型转换
         */

        int a = 5;
        a += 5;
        System.out.println(a); // 10

        int x = 10;
        x %= 3;
        System.out.println(x); // 1

        byte num = 30;
        num +=5;
        // num = byte + int
        // num = int + int
        // num = num
        // num = (byte)int
        System.out.println(num); //35
    }
}

day02-09 比较运算符

package com;

public class Demo01 {
    public static void main(String[] args){
        /*
        比较运算符：
        >
        <
        >=
        <=
        ==
        !=

        注意事项：
        1.比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false
        2.如果进行多次判断，不能连着写
         */

        System.out.println(10>5); // true
        int num1 = 10;
        int num2 = 12;
        System.out.println(num1 < num2); // true
        System.out.println(num2 >= 100); // false
        System.out.println(num2 <= 100); // true
        System.out.println("======================");

        System.out.println(10 == 10); // true
        System.out.println(10 != 20); // true
        System.out.println(10 != 10); // false
    }
}

day02-10 逻辑运算符

package com;

public class Demo01 {
    public static void main(String[] args){
        /*
        逻辑运算符
        与  &&
        或  ||
        非  !

        &&,||具有短路效果，如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能

        注意事项：
        1.逻辑运算符只能用于boolean值
        2.与、或需要左右各有一个boolean值，但是取反只要有一个boolean值
        3.与、或两种运算符，如果有多个条件，可以连续写
        
         */

        System.out.println(true && false); // false
        // true && true --> true
        System.out.println(3 < 4 && 10 > 5); // true
        System.out.println("======================");

        System.out.println(true || false); //true
        System.out.println(false || false); // false
        System.out.println("======================");

        System.out.println(true); // true
        System.out.println(!true); // false
        System.out.println("======================");

        int a = 10;
        // false && ... --> false
        System.out.println(3 > 4 && ++a < 100); // false
        System.out.println(a); // 10
        System.out.println("======================");

        int b = 20;
        // true || ... --> true
        System.out.println(3 < 4 || ++b <100); // true
        System.out.println(b); // 20
    }
}

day02-11 三元运算符

package com;

public class Demo01 {
    public static void main(String[] args){
        /*
        一元运算符：只需要一个数据就可以进行操作的运算符，例如：取反，自增，自减
        二元运算符：需要两个数据就才进行操作的运算符，例如：加法，赋值
        三元运算符：需要三个数据就才进行操作的运算符

        格式：
        数据类型 变量名称 = 条件判断 ？ 表达式A ： 表达式B；

        注意事项：
        1.必须同时保证表达式A和表达式B都符合左侧数据类型的要求（赋值时的要求，输出语句不要求）
        2.三元运算符的结果必须被使用（赋值或输出）
         */

        int a = 10;
        int b = 20;
        int max = a > b ? a : b;
        System.out.println("最大值：" + b);
        System.out.println(a > b ? a : b);
    }
}

day02-12 方法入门

package com;

/*
定义一个方法的格式
public static void 方法名称（）{
    方法体
}

方法名称的命名规则和变量一样，使用小驼峰
方法体：大括号当中可以包含任何条语句

注意事项：
1.方法定义的先后顺序无所谓
2.方法的定义不能产生嵌套包含关系
3.方法定义后，不会执行，如果想执行，一定要对方法进行【调用】

如何调用方法，格式：

方法名称（）；
 */

public class Demo02 {
    public static void main (String[] args){
        farmer(); // 调用农民的方法
        seller(); // 调用商贩的方法
        cook(); // 调用厨子的方法
        me(); // 调用我的方法
    }

    // 农民伯伯
    public static void farmer(){
        System.out.println("播种");
        System.out.println("浇水");
    }

    // 小商贩
    public static void seller(){
        System.out.println("运输");
        System.out.println("抬价");
    }

    // 厨子
    public static void cook(){
        System.out.println("洗菜");
        System.out.println("切菜");
    }

    // 我
    public static void me(){
        System.out.println("吃");
    }
}

编译器的常量优化
赋值操作中，若等号右侧是若干个常量，编译器直接将计算得到结果。

注意事项：
一旦表达式中有变量参与，那么就不能进行这种优化了。

short a = 2;
short b = 3;
// short + short --> int + int --> int,左右数据类型不符
short result = a + b; // 编译报错
short result2 = 2 + 3; // 编译成功