认识java以及java基础相关相关知识点更新(第二天)

于 2022-08-26 10:33:44 发布
阅读量260 收藏 2
点赞数 1
文章标签： java jvm servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Zyf15156243165/article/details/126499686
版权
本文介绍了Java的基础知识，包括数据类型、标识符的使用，详细讲解了如何通过Scanner类接收键盘输入。此外，还讨论了算术运算符、自增自减运算符、赋值运算符、关系运算符、逻辑运算符、三元运算符及其优先级，并通过示例展示了各种运算符的运用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

        1.数据类型

        2.标识符(就是给类.方法.变量等起的名字)

        3.键盘录入(java帮我们写好了一个类叫scanner,这个类就可         以 接收键盘输入的数字)

                步骤一:导包(scanner这个类在哪)

                import java.util.scanner;(导包的动作必须写在类定义上边)

                步骤二:创建对象(表示我们准备用scanner这个类) 

                Scanner sc = new Scanner(System. in)(只有sc是变量名,可以变,其他的都不可以变)

                步骤三:接收数据(真正开始干活)

                int i =sc.netInt()(只有I是变量名,可以变,其他都不可以变)

               

运算符:对自变量或者变量操作的符号

表达式:用运算符把自变量或者变量连接起来,符合java语法的式子,称之为表达式

            不同的运算符连接的表达式体现的是不同的表达式

            举例:          int a = 10;

                              int b = 20;

                              int c = a + b;

                        +  :是运算符,并且是算术运算符

                        a+b  :是表达式,由于+是算术运算符,所以这个表达式是算术表达式

六种运算符以及运算符的优先级

        1.算术运算符

        2.自增自减运算符

        3.赋值运算符

        4.关系运算符

        5.逻辑运算符

        6.三元运算符

1.算术运算符(+ - * / %)

public class arithmeticoperatordemo1{
        public static void main(String[] args){
                System.out.println(3+2);

                System.out.println(3-2);

                System.out.println(3*2);

                System.out.println(1.1+1.01);

                System.out.println(1.3-1.01);

                System.out.println(1.1*1.01);

                System.out.println(1.1+1.1);
}
}

结论1:在代码中,如果有小数点参与计算,结果有可能不精确.

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

                //除法

                System.out.println(10/2);   //5

                System.out.println(10/3);   //3

                System.out.println(10.0/3);   //3.3333333333335

                //取模,取余,实际上也是除法运算,只不过得到的是余数而已.

                System.out.println(10%2);  //0

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

                //应用场景

                //1.可以用取模来判断,A是否能被B整除

                //A%B  10%3

                //2.可以判断A是否是一个偶数

                //A%2,如果结果为0,那么证明A是偶数,如果结果为1,那么证明A为基数

                //3.斗地主发牌,有三个玩家

                //每张牌都定义一个序号

                //拿序号%3,如果结果为1,则发给第一个玩家

                //如果结果为2,则发给第二个玩家

                //如果结果为0,则发给第三个玩家

                          
}
}

结论1:整数参与计算,结果只能得到整数

结论2:小数参与计算,结果可能不精确

练习1:数值拆分

        需求:键盘录入一个三位数,将其拆分为个位.十位.百位后,打印在控制台

        公式总结:

        个位:数值%10

        十位:数值/10%10

        百位:数值/100%10

package zyf.it.test;

import java.util.Scanner;

public class test1 {
    public static void main(String[] args) {
        //键盘录入一个三位数,获取其中的个位.十位.百位

        //1.键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个三位数");
        int number = sc.nextInt();
        //或许个位.十位.百位
        //公式:
        //个位:数字%10
        //十位:数字/10%10
        //百位:数字/100%10
        //千位:数字/1000%10
        //...
        int ge = number%10;
        int shi = number/10%10;
        int bai = number/100;
        System.out.println(ge);
        System.out.println(shi);
        System.out.println(bai);
    }
}

//"+"操作的三种情况
//1.数字相加
//2.字符串相加
//3.字符相加

        //1.数字相加
        //结论:数字进行运算时,数据类型不一样不能运算,要转成一样的,才能进行运算
        //eg:     int a = 10;                int a =10;
        //        double b = 12.3;           double b = 20.0;
        //        double c = a + b;          double c = a + b;

        //类型转换的分类:
        //1.隐式转换:取值范围小的数值-->取值范围大的数值
        //2.强势转换:大-->小
        //1.隐式转换(自动类型提升)
        //隐式转换的两种提升规则:
            //1.取值范围小的和取值范围大的进行运算时,小的会提升为大的,再进行运算
            //2.byte short char 三种类型的数据再进行运算时,会直接先提升为int,然后再进行运算
                //  byte a =10;
                //  byte b =20;
                //  int c = a + b;
            //取值范围:byte<short<int<long<float<double  

        
        //2.强制转换:如果把一个取值范围大的数值,赋值给一个取值范围小的变量
        //          是不允许直接赋值的,如果一定要这么做就需要加入强制转换
        //格式:目标数据类型 变量名 =(目标数据类型)被强转的数据
package zyf.it.summary;

//"+"操作的三种情况
//1.数字相加
//2.字符串相加
//3.字符相加

        //1.数字相加
        //结论:数字进行运算时,数据类型不一样不能运算,要转成一样的,才能进行运算
        //eg:     int a = 10;                int a =10;
        //        double b = 12.3;           double b = 20.0;
        //        double c = a + b;          double c = a + b;

        //类型转换的分类:
        //1.隐式转换:取值范围小的数值-->取值范围大的数值
        //2.强势转换:大-->小

public class summary1 {
    public static void main(String[] args) {
        //1.隐式转换(自动类型提升)
        //隐式转换的两种提升规则:
            //1.取值范围小的和取值范围大的进行运算时,小的会提升为大的,再进行运算
            //2.byte short char 三种类型的数据再进行运算时,会直接先提升为int,然后再进行运算
                //  byte a =10;
                //  byte b =20;
                //  int c = a + b;
            //取值范围:byte<short<int<long<float<double

        int a = 10;
        double b = a;
        System.out.println(b);

        byte b1 = 10;
        byte b2 = 20;
        int result = b1 + b2;
        System.out.println(result);

        int i = 10;
        long n = 100L;
        double d = 20.0;
        System.out.println(i + n + d);

        byte c = 10;
        short f = 20;
        long g = 100L;
        System.out.println(c + f + g);
        //2.强制转换:如果把一个取值范围大的数值,赋值给一个取值范围小的变量
        //          是不允许直接赋值的,如果一定要这么做就需要加入强制转换
        //格式:目标数据类型 变量名 =(目标数据类型)被强转的数据
        double a1 = 12.3;
        int a2 =(int) a1;
        System.out.println(a2);

        //强转转换有可能导致数据错误
        int c1 = 200;
        byte c2 =(byte) c1;
        System.out.println(c2);

        byte d1 =10;
        byte d2 =20;
        byte result1 =(byte) (d1+d2);
        System.out.println(result1);

    }


}
//字符串的"+"操作
//当"+"操作中出现字符串时,这个"+"是字符串的连接符,而不是算术运算符了,会将前后的数据拼接,并生成一个新的字符串
//eg:  "123"+123 -->"123123"
//     1+99+"朱亚方" -->"100朱亚方"(连续进行"+"操作时,从左到右逐个执行)
package zyf.it.summary;


import java.util.Scanner;

//字符串的"+"操作
//当"+"操作中出现字符串时,这个"+"是字符串的连接符,而不是算术运算符了,会将前后的数据拼接,并生成一个新的字符串
//eg:  "123"+123 -->"123123"
//     1+99+"朱亚方" -->"100朱亚方"(连续进行"+"操作时,从左到右逐个执行)
public class summary2 {
    public static void main(String[] args) {
        System.out.println(1.2+"abc");//1.2abc
        System.out.println("abc" + true);//abctrue
        System.out.println('中' + "abc" +true);//中abctrue
        int age = 18;
        System.out.println("我的年级是" + age + "岁");//我的年级是18岁
        System.out.println("我的年级是" + "age" + "岁");//我的年级是age岁
        System.out.println(1 + 2 + "age" + 2 + 1);//3age21


        //数值拆分2.0
        Scanner sc =new Scanner(System.in);
        System.out.println("请输入一个三位数");
        int number = sc.nextInt();
        int ge = number%10;
        int shi = number/10%10;
        int bai = number/100;
        System.out.println("个位是:" + ge);
        System.out.println("十位是:" + shi);
        System.out.println("百位是:" + bai);
    }

}

                                 

//字符相加
//2.byte short char 三种类型的数据再进行运算时,会直接先提升为int,然后再进行运算
//当 字符+字符/字符+数字 时,会将字符通过ASCII码表查询到对应的数字再进行计算
package zyf.it.summary;


//字符相加
//2.byte short char 三种类型的数据再进行运算时,会直接先提升为int,然后再进行运算
public class summary3 {
    public static void main(String[] args) {
        //当 字符+字符/字符+数字 时,会将字符通过ASCII码表查询到对应的数字再进行计算
        char c = 'a';
        int result = c + 0;
        System.out.println(result);//97

        System.out.println(1 + 'a');//98
        System.out.println('a' + "abc");//aabc  只要有字符串参与计算,他做的就是拼接操作

    }
}

2.自增自减运算符

//2.自增自减运算符
//      符号      作用      说明
//      ++         加     变量的值加1
//      --         减     变量的值减1
    //注意事项:++和--既可以放在变量的前面也可以放在变量的后面
    //++和--无论写在变量的前面还是后面,单独写一行结果是一样的(单独使用)
package summary;


//2.自增自减运算符
//      符号      作用      说明
//      ++         加     变量的值加1
//      --         减     变量的值减1
    //注意事项:++和--既可以放在变量的前面也可以放在变量的后面

public class summary1 {
    public static void main(String[] args) {
        //++和--无论写在变量的前面还是后面,单独写一行结果是一样的(单独使用)
        int a =10;
        ++a;
        System.out.println(a);//11

        int b = 10;
        b++;
        System.out.println(b);//11
        ++b;
        System.out.println(b);//12
        b--;
        System.out.println(b);//11
        --b;
        System.out.println(b);//10

        //应用场景1  年纪
        int age = 1;
        age++;
        System.out.println(age);//2
        //应用场景2  淘宝购物车
        //应用场景3  美女的个数


        //参与计算
        int c = 10;
        int d = c++;
        System.out.println(d);//10
        System.out.println(c);//11
        //(先用后加的情况)
        int e = 10;
        int f = ++e;
        System.out.println(e);//11
        System.out.println(f);//11
        //(先用后加的情况)


        int x = 10;
        int y = x++;
        int z = ++x;
        System.out.println("x:"+x);//12
        System.out.println("y:"+y);//10
        System.out.println("z:"+z);//12
    }
}

                                

3.赋值运算符

//赋值运算符
    //  符号      作用              说明
    //   =        赋值          int a = 10; 将10赋值给变量a
    //  +=       加后赋值        a+=b,将a+b的值给a
    //  -=       减后赋值        a-=b,将a-b的值给a
    //  *=       乘后赋值        a*=b,将a*b的值给a
    //  /=       除后赋值        a/=b,将a/b的值给a
    //  %=      取模后赋值       a%=b;将a%b的值给a
package summary;


//赋值运算符
    //  符号      作用              说明
    //   =        赋值          int a = 10; 将10赋值给变量a
    //  +=       加后赋值        a+=b,将a+b的值给a
    //  -=       减后赋值        a-=b,将a-b的值给a
    //  *=       乘后赋值        a*=b,将a*b的值给a
    //  /=       除后赋值        a/=b,将a/b的值给a
    //  %=      取模后赋值       a%=b;将a%b的值给a
public class summary2 {
    public static void main(String[] args) {
        int a =10;
        int b =20;
        a+=b;
        System.out.println(a);///30
        System.out.println(b);//20

        //细节:+= -= *= /= %= 底层都影藏了一个强制类型转换
        short s = 1;
        //把左边和右边的进行相加,得到结果2,再赋值给左边的变量
        s+=1;
        //等同于: s = (short)(s + 1);
        System.out.println(s);//2
    }
}

                

4.关系运算符   

//关系运算符
//(关系运算符/比较运算符)的分类
//      ==      a==b,判断a和b的值是否相等,成立为true,不成立你为false
//      !=      a!=b,判断a和b的值是否不相等,成立为true,不成立为false
//      >       a>b,判断a是否大于b,成立为true,不成立为false
//      >=      a>=b,判断A是否大于等于b,成立为true,不成立为false
//      <       ........................
//      <=      ........................
//注意事项:关系运算符的结果都是boolean类型,要么true,要么false  
package summary;


//关系运算符
//(关系运算符/比较运算符)的分类
//      ==      a==b,判断a和b的值是否相等,成立为true,不成立你为false
//      !=      a!=b,判断a和b的值是否不相等,成立为true,不成立为false
//      >       a>b,判断a是否大于b,成立为true,不成立为false
//      >=      a>=b,判断A是否大于等于b,成立为true,不成立为false
//      <       ........................
//      <=      ........................
//注意事项:关系运算符的结果都是boolean类型,要么true,要么false
public class summary3 {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        int c = 20;
        System.out.println(a==b);//true
        System.out.println(a==c);//false
    }
}

        相关例题(关系运算符)

package summary;

import java.util.Scanner;

public class summary3test1 {
    /*需求:您和您的对象正在餐厅里约会,
    键盘录入两个整数,表示你和你对象衣服的时髦度.(手动录入0-10之间的整数,不能录其他)
    如果你的时髦度大于你对象的时髦度,相亲成功,输出true,
    否则输出flase
     */
    public static void main(String[] args) {
        //1.键盘录入两个整数表示衣服的时髦度
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入我们自己的衣服的时髦度");
        int myfashion = sc.nextInt();
        System.out.println("请输入你对象衣服的时髦度");
        int girlfashion = sc.nextInt();

        //2.把我衣服的时髦度和女孩的时髦度进行对比就行了
        boolean result = myfashion > girlfashion;

        //3.打印结果
        System.out.println(result);

    }
}

5.逻辑运算符

//逻辑运算符
//在数学中,一个数据x,大于5,小于15,我们可以这样来进行表示:5<x<15.
//在java中,需要将上面的式子先进行拆解,再进行合并表达
//拆解为x>5和x<15.
//合并为x>5&x<15.
//      符号              作用              说明
//       &              逻辑与(且)      并且,两边都为真,结果才为真（两边都要满足）
//       |              逻辑或(或)      或者,两边都为假,结果才为假（两边满足一个）
//       ^              逻辑异或        相同为true,不同为flase
//       !              逻辑非                 取反
package summary;


//逻辑运算符
//在数学中,一个数据x,大于5,小于15,我们可以这样来进行表示:5<x<15.
//在java中,需要将上面的式子先进行拆解,再进行合并表达
//拆解为x>5和x<15.
//合并为x>5&x<15.
//      符号              作用              说明
//       &              逻辑与(且)      并且,两边都为真,结果才为真（两边都要满足）
//       |              逻辑或(或)      或者,两边都为假,结果才为假（两边满足一个）
//       ^              逻辑异或        相同为true,不同为flase
//       !              逻辑非                 取反
public class summary4 {
    public static void main(String[] args) {
        //并且&
        System.out.println(true & true);//ture
        System.out.println(true & false);//flase
        System.out.println(false & true);//flase
        System.out.println(false & false);//flase

        //或者|
        System.out.println(true | true);//true
        System.out.println(true | false);//true
        System.out.println(false | true);//true
        System.out.println(false | false);//flase


        //场景应用1
        //QQ的账号密码登录
        //账号正确&密码正确

        //场景应用2
        //有房或者有车  有房并且有车

        //异或^(明政局，男男，女女，男女)
        System.out.println(true ^ true);//flase
        System.out.println(false ^ true);//true
        System.out.println(true ^ false);//true
        System.out.println(false ^ false);//flase

        //逻辑非  取反
        //取反的感叹号不要写多次，要么不写，要么只写一次.
        System.out.println(!true);//false
        System.out.println(!false);//true


    }
}

   5.1短路逻辑运算符

//短路逻辑运算符(为什么会有短路逻辑运算符)
//eg1:       判断账号   &&     判断密码
//          1.账号正确       需要判断密码
//          2.账号错误        无需判断密码

//eg2:          房子    ||       车子
//          1.如果没房          需要看车
//          2.如果有房          无需看车

//              符号      作用          说明
//              &&      短路与        结果与&相同,但有短路效果
//              ||      短路或        结果与|相同,但有短路效果

//注意事项:
//& |,无论左边是false还是true,右边都需要执行
//&& ||,如果左边能确定表达式的结果,右边不执行
//&&,左边为false,右边不管真假,整个表达式一定是false
//||,左边为true,右边不管真假,整个表达式一定是true
//以后最常用的逻辑运算符:&&  ||  !
package summary;


//短路逻辑运算符(为什么会有短路逻辑运算符)
//eg1:       判断账号   &&     判断密码
//          1.账号正确       需要判断密码
//          2.账号错误        无需判断密码

//eg2:          房子    ||       车子
//          1.如果没房          需要看车
//          2.如果有房          无需看车

//              符号      作用          说明
//              &&      短路与        结果与&相同,但有短路效果
//              ||      短路或        结果与|相同,但有短路效果

public class summary5 {
    public static void main(String[] args) {
        //1.&&
        System.out.println(true && true);//true
        System.out.println(true && false);//false
        System.out.println(false && true);//flase
        System.out.println(false && false);//flase
        //2.||
        System.out.println(true || true);//true
        System.out.println(false || true);//ture
        System.out.println(true || false);//true
        System.out.println(false || false);//false

        //3.短路逻辑运算符具有短路的效果
        //简单理解:当左边的表达式能确定最终的结果,那么右边就不会参与运行了
        int a = 10;
        int b = 10;
        boolean result = ++a<5 && ++b<5;
        System.out.println(result);//false
        System.out.println(a);//11
        System.out.println(b);//10


        //注意事项:
        //& |,无论左边是false还是true,右边都需要执行
        //&& ||,如果左边能确定表达式的结果,右边不执行
        //&&,左边为false,右边不管真假,整个表达式一定是false
        //||,左边为true,右边不管真假,整个表达式一定是true
        //以后最常用的逻辑运算符:&&  ||  !

    }
}

相关例题(短路逻辑运算符)

package summary;

import java.util.Scanner;

public class summary5test1 {
    /*需求:数字6是一个真正伟大的数字,键盘录入两个整数
            如果其中一个为6,那么最终结果输出为true,
            如果他的和为6的倍数,那么最终结果输出为true,
            其他情况为false
     */
    //分析:
    //1.键盘录入两个整数
    // 变量a 变量b

    //2.a==6  ||   b==6   ||  (a+b)%6==0
    //如果满足其中一个条件,那么就可以输出ture
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个整数");
        int number1 = sc.nextInt();
        System.out.println("请输入第二个整数");
        int number2 = sc.nextInt();

        //可以短路运算符去连接三个判断
        boolean result = number1 == 6 || number2 == 6 || (number1 + number2) % 6 == 0;
        System.out.println(result);
    }
}

6.三元运算符

//三元运算符(三元表达式)
//格式: 关系表达式?表达式1:表达式2;
//eg:求两个值的最大值
//      int max = a > b ? a : b;            (把三元运算符的结果赋值给一个变量)
//      System.out.println(a > b ? a : b);      (把三元运算符的结果直接打印出来)
//计算规则: 首先计算关系表达式的值
//         如果为true,表达式1的值就为运算结果
//         如果为false,表达式2的值就为运算结果
package summary;


//三元运算符(三元表达式)
//格式: 关系表达式?表达式1:表达式2;
//eg:求两个值的最大值
//      int max = a > b ? a : b;            (把三元运算符的结果赋值给一个变量)
//      System.out.println(a > b ? a : b);      (把三元运算符的结果直接打印出来)
//计算规则: 首先计算关系表达式的值
//         如果为true,表达式1的值就为运算结果
//         如果为false,表达式2的值就为运算结果
public class summary6 {
    public static void main(String[] args) {
        //需求:使用三元运算符,或许两个数的较大值

        //分析:
        //1.定于两个变量记录两个整数
        int number1 = 10;
        int number2 = 20;

        //2.使用三元运算符获取两个整数的较大值
        //格式:     关系表达式? 格式1:格式2;
        //整个三元运算符的结果必须要被使用
        int max = number1 > number2 ? number1 : number2;
        System.out.println(max);
    }
}

6.1相关例题1(三元运算符)

package summary;

import java.util.Scanner;

public class summary6test1 {
    public static void main(String[] args) {
        /*需求:动物园有两只老虎,两只老虎的体重分别通过键盘录入获得,
        请用程序实现判断两只老虎的体重是否相同
         */


        //分析:
        //1.键盘录入两只老虎的体重
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一只老虎的体重");
        int number1 = sc.nextInt();
        System.out.println("请输入第二只老虎的体重");
        int number2 = sc.nextInt();

        //2.比较
        //true false
        //相同 不同
        //System.out.println(number1 == number2);
        String result = number1 == number2 ? "相同" : "不同";
        System.out.println(result);
    }
}

6.2相关例题2(三元运算符)

package summary;

public class summary6test2 {
    public static void main(String[] args) {
        /*需求:一个寺庙里住着三个和尚,已知他们的身高分别为150cm,210cm,165cm,
        请用程序实现获取这三个和尚的最高身高.
         */

        //1.定义三个变量记录三个和尚的身高
        int height1 = 150;
        int height2 = 210;
        int height3 = 165;

        //2.拿第一个和尚跟第二个和尚做比较;
        //  再拿结果跟第三个和尚作比较
        int temp = height1 > height2 ? height1 : height2;
        int max = temp > height3 ? temp : height3;
        System.out.println(max);

        //ctrl + alt + L 自动格式化代码
    }
}

7.算术符的优先级

package summary;


//运算符的优先级
public class summary7 {
    public static void main(String[] args) {
//运算符的通用写法
        int a = 10;
        int b = 20;
        int c = 30;
        System.out.println((a + b) * c);//谁加小括号谁的优先级就高

    }
}

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值