Java中的变量和数据类型

变量代码练习

package JavaLearn;

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

        //第一步：声明变量  准备一个容器用来装指定类型的数据
        // 数据类型 变量名;
        byte num1;

        //第二步：赋值，即“将数据存储至对应的内存空间”  将数据装到容器中
        //变量名 = 数据;
        num1 = 100;

        //第三步：使用变量，即“取出数据使用”  你要想操作数据，只需要操作变量名即可
        System.out.println("num1");//输出语句中，双引号里面的内容直接输出在控制台
        System.out.println(num1);//输出语句中，输出的是变量名，会将变量中存储的数据输出
        System.out.println("num1:"+num1);//num1:100

        //重新给变量存储数据
        num1 = 120;
        System.out.println("num1:"+num1);

        //第一步和第二步可以合并写：声明变量和给变量赋值可以合并写
        //数据类型 变量名 = 数据;
        short num2 = 200;
        //第三步：使用变量，即“取出数据使用”  你要想操作数据，只需要操作变量名即可
        System.out.println("num2="+num2);//num2=200

    }
}

package JavaLearn;

public class Demo02 {
    public  static  void main(String[]args){
        //声明8大数据类型变量并输出变量中的值
        byte num1 = 100;
        short num2 = 200;
        int num3 = 300;
        long num4 = 400L;//整数类型默认是int类型，在这里使用小写l或者大写L来标识400是long类型

        float num5 = 12.5F;//浮点数类型默认是 double类型，在这里使用小写f或者大写F来标识12.5是float类型
        double num6 = 22.5;

        //字符型：使用单引号阔起来，单引号中只能写一个英文字或者一个中文汉字
        char ch1 = 'q';
        char ch2 = '你';

        //布尔型：布尔型只有两个数据，true和false
        boolean bool1 = true;
        boolean bool2 = false;

        System.out.println("num1"+num1);
        System.out.println("num2"+num2);
        System.out.println("num3"+num3);
        System.out.println("num4"+num4);
        System.out.println("num5"+num5);
        System.out.println("num6"+num6);
        System.out.println("ch1"+ch1);
        System.out.println("ch2"+ch2);
        System.out.println("bool1"+bool1);
        System.out.println("bool2"+bool2);

        //字符串类型：String，使用双引号括起来，在双引号中可以输入0~n个字符
        String str1 = "";
        String str2 = "q";
        String str3 = "asjfhwehfwhfewuhfhfiuewhf";
        System.out.println("str1="+str1);
        System.out.println("str2="+str2);
        System.out.println("str3="+str3);

    }
}

package JavaLearn;

public class Demo03 {
    public  static  void main(String[]args){
        //声明一个int类型的变量，将100存储在变量中
        int num1 = 100;
        System.out.println("num1="+num1);//num1=100
        //修改num1变量中存储的数据为200
        num1 = 200;
        System.out.println("num1="+num1);//num1=100

        /*
         * 使用final修饰的变量为常量在，值不能修改
         *   常量命名时，所有的字母都要大写
         *   常量名由多个单词组成时，多个单词之间使用下划线分隔
         *   常量名要做到见名知意
         *   常量一般在声明的时候就赋值（也可以声明常量和赋值分开做）
         * */
        final int NUM2 = 300;
        System.out.println("NUM2="+NUM2);
        //NUM2 =400;

        final String STUDENT_NAME = "张三";

        final int NUM3;
        NUM3 = 500;
        System.out.println("NUM3="+NUM3);

    }
}

package JavaLearn;

//使用Scanner的第一步：导包   从其他目录（文件夹）中将要使用的代码拿过来
import java.util.Scanner;
public class Demo04 {
    public static void main(String[] args) {
        //需求：从键盘中输入你的姓名和年龄
        //第二步：创建Scanner类对象（固定写法，当前会写即可）
        Scanner scanner = new Scanner(System.in);//scanner这个名称你可以随便定义

        /*
         * 通过创建的Scanner对象scanner调用不同的代码，可以获取不同类型的数据
         *   next()：获取String类型的数据
         *   nextInt()：获取int类型的数据
         *   nextDouble()：获取double类型数据
         *
         * */
        System.out.println("请输入你的姓名：");
        String name = scanner.next();
        System.out.println("请输入你的年龄：");
        double age = scanner.nextDouble();

        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

package JavaLearn;
import java.util.Scanner;

public class Demo05 {

    public static void main(String[] args) {

        //先创建Scanner对象
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入你的年龄：");
        int age =scanner.nextInt();
        System.out.println("age="+age);
    }

}

数据类型转换代码练习

package JavaLearn2;

public class Demo01 {
    public static void main(String[] args) {
        byte num1 = 100;

        //自动类型转换：将小范围类型变量直接赋值给大范围类型变量
        int num2 = num1;
        System.out.println("num2=" + num2);

        int num3 = 130;
        //强制类型转换：将大范围类型变量赋值给小范围类型变量，需要进行强制类型转换，强制类型转换有可能造成数据溢出（数据精度丢失）---数据不准确
        byte num4 = (byte) num3;
        System.out.println("num4=" + num4);
    }
}

package JavaLearn2;

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

        byte num1 =100;
        int num2 =200;
        //两个不同类型的整数在做运算时，小范围类型的数据会自动转换为大范围类型的数据，然后再做运算
        int num3 =num1+num2;
        //将运算结果赋值给小范围类型变量时，需要进行强制类型转换
        byte num4 =(byte)(num1+num2);
    }
}

运算符代码练习

赋值运算符

package JavaLearn3;

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

        //赋值运算符：=
        //数据类型 变量名 = 表达式;
        //表达式就是符号（如加号、减号）与操作数（如b，3等）的组合  例如3+5  a*b

        //将整数10存储到int类型变量中
        int num1 = 10;

        //将整数3+5的结果存储在int类型变量中
        int num2 =3+5;
        System.out.println("num2="+num2);

        int a = 100;
        int b = 200;
        int num3 =a+b;
        System.out.println("a+b="+num3);
    }
}

package JavaLearn3;

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

        int num1 = 8;
        int num2 = 9;
        System.out.println("交换前：");
        System.out.println("num1="+num1);
        System.out.println("num2="+num2);

        //声明一个临时变量用来中转数据
        int temp=num1;
        num1=num2;
        num2=temp;
        System.out.println("交换后：");
        System.out.println("num1="+num1);
        System.out.println("num2="+num2);

    }
}

算术运算符?

package JavaLearn3;

public class Demo03 {
    public static void main(String[] args) {
        /*
         * 算术运算符：
         *   基本算术运算符：
         *       + - * /(除法运算符) %(取模运算符/取余运算符) ++(自增运算符) --(自减运算符)
         *   复合算术运算符
         *   += -= *= /= %=
         *
         * */

        int num1 = 20;
        int num2 = 3;

        int result1 =num1+num2;
        System.out.println("num1+num2="+result1);

        int result2 =num1-num2;
        System.out.println("num1-num2="+result2);

        int result3 =num1*num2;
        System.out.println("num1*num2="+result3);

        int result4 =num1/num2;
        System.out.println("num1/num2="+result4);

        int result5 =num1%num2;
        System.out.println("num1%num2="+result5);

        System.out.println("------------------------------");

        /*
         * ++、--运算符
         *   对于单个变量来说，++或者--在变量前或者变量后，变量都会自增1或者自减1
         *   ++或者--修饰的变量参与了其它运算：
         *       ++或者--在变量后面，变量先去参与运算，参与完运算再自增1或者自减1
         *       ++或者--在变量前面，变量先自增1或者自减1，然后使用自增1或者自减1后的结果去参与运算
         *
         * */
        int a =100;
        System.out.println("a="+a);//a=100
        // a++;
        ++a;
        System.out.println("a="+a);//a=101

        System.out.println("------------------------------");

        int b = 200;
        System.out.println("b="+b);//b=200
        int c =b++;
        System.out.println("b="+b);//b=201
        System.out.println("c="+c);//c=200

        System.out.println("------------------------------");

        int d = 200;
        System.out.println("d="+d);//d=200;
        int e =++d;
        System.out.println("d="+d);//d=201
        System.out.println("e="+e);//e=201

        System.out.println("------------------------------");

        int k = 100;
        //将k的值加上300，然后将结果再赋值给k
        k+=300;//k=k+300;
        System.out.println("k="+k);//k=400

        k-=100;//k=k-100;
        System.out.println("k="+k);//k=300

        k*=2;//k=k*2;
        System.out.println("k="+k);//k=600

        k/=160;// k=k/160;
        System.out.println("k="+k);//k=3

        k%=2;// k=k%2;
        System.out.println("k="+k);//k=1

    }
}

关系运算符?

package JavaLearn3;

public class Demo05 {
    public static void main(String[] args) {
        /*
         * 关系运算符（比较运算符）：
         *   > >= < <= == !=
         *
         *   关系运算符的结果是布尔值，要么成立（true），要么不成立（false）
         *   为赋值运算符，==为等于运算符
         *   >、<、>=、<= 运算符的优先级别高于==、!=
         *   >、<、>=、<=运算符只支持数值类型的数据比较,==和!=可以比较引用数据类型的内存地址值
         *
         * */
        int num1 = 100;
        int num2 = 200;
        int num3 = 100;

        boolean result1 =num1>num2;
        System.out.println("num1>num2："+result1);

        boolean result2 =num1<num2;
        System.out.println("num1<num2："+result2);

        boolean result3 =num1>=num3;
        System.out.println("num1>=num3："+result3);

        boolean result4 =num1<=num3;
        System.out.println("num1<=num3："+result4);

        boolean result5=num1==num3;
        System.out.println("num1==num3："+result5);

        boolean result6 =num1!=num2;
        System.out.println("num1!=num2："+result6);

    }

}

?逻辑运算符

package JavaLearn3;

public class Demo06 {
    /*
     * 逻辑运算符：
     *   &(单与)、&&(双与/短路与) 、|(单或) 、||(双或/短路或) 、！(非)
     *
     *   与运算和或运算，运算符左右两边需要布尔类型的表达式
     *   非运算只需要在运算符右边有一个布尔类型的表达式
     *   逻辑运算符的结果还是布尔值，要么成立（true），要么不成立（false）
     * */

    public static void main(String[] args) {
        int num1 =100;
        int num2 = 200;

        boolean result = num1<num2 && num2>num1;
        System.out.println(result);

        System.out.println("------------------------");

        //true&true-->true
        boolean result1 =true&true;
        System.out.println("true&true:"+result1);

        //true&false-->false
        boolean result2 =true&false;
        System.out.println("true&false:"+result2);

        //false&true-->false
        boolean result3 =false&true;
        System.out.println("false&true:"+result3);

        //false&false-->false
        boolean result4 =false&false;
        System.out.println("false&false:"+result4);

        System.out.println("------------------------");

        //true&&true-->true
        boolean result5 =true&&true;
        System.out.println("true&&true:"+result5);

        //true&&false-->false
        boolean result6 =true&&false;
        System.out.println("true&&false:"+result6);

        //false&&true-->false
        boolean result7 =false&&true;
        System.out.println("false&&true:"+result7);

        //false&false-->false
        boolean result8 =false&&false;
        System.out.println("false&&false:"+result8);

        /*
        * 由上面的运算结果可知：
        *   &和&&的运算规律是一样的，只有&或者&&左右两边的表达式同时为true。&或者&&的运算结果才为true
        * */
        }

    }

package JavaLearn3;

public class Demo07 {
        /*
         * 逻辑运算符：
         *   &(单与)、&&(双与/短路与) 、|(单或) 、||(双或/短路或) 、！(非)
         *
         *   与运算和或运算，运算符左右两边需要布尔类型的表达式
         *   非运算只需要在运算符右边有一个布尔类型的表达式
         *   逻辑运算符的结果还是布尔值，要么成立（true），要么不成立（false）
         * */
        public static void main(String[] args) {

            //true|true-->true
            boolean result1 =true|true;
            System.out.println("true|true:"+result1);

            //true|false-->false
            boolean result2 =true|false;
            System.out.println("true|false:"+result2);

            //false|true-->false
            boolean result3 =false|true;
            System.out.println("false|true:"+result3);

            //false|false-->false
            boolean result4 =false|false;
            System.out.println("false|false:"+result4);

            System.out.println("------------------------");

            //true||true-->true
            boolean result5 =true||true;
            System.out.println("true||true:"+result5);

            //true||false-->false
            boolean result6 =true||false;
            System.out.println("true||false:"+result6);

            //false||true-->false
            boolean result7 =false||true;
            System.out.println("false||true:"+result7);

            //false||false-->false
            boolean result8 =false||false;
            System.out.println("false||false:"+result8);

            /*
             * 由上面的运算结果可知：
             *   |和||的运算符规律是一样的，只要|或者||左右两边的表达式有一个结果为true，那么|或者||的运算结果就为true
             *   只有|或者||左右两边表达式结果同时为false，|或者||运算结果才为false
             * */

        }
    }

package JavaLearn3;

public class Demo08 {

    public static void main(String[] args) {
        boolean bool1 = true;
        boolean bool2 = false;

        System.out.println("bool1="+bool1);
        System.out.println("bool2="+bool2);

        //!true-->false
        boolean result1 =!bool1;
        System.out.println("!true："+result1);

        //!false-->true
        boolean result2 =!bool2;
        System.out.println("!false："+result2);
        /*
         * ！运算符的运算规律：
         *   ！是进行取反操作，
         *       当表达式结果为true，进行！运算，得到的结果为false；
         *       当表达式结果为false，进行！运算，得到的结果为true
         *
         * */
    }

}

package JavaLearn3;

public class Demo09 {

    public static void main(String[] args) {

        int x1=8;
        int y1=9;
        System.out.println((++x1==y1)&&(++x1!=y1));//true
        System.out.println(x1);//10

        int x2=8;
        int y2=9;
        System.out.println( (++x2!=y2)&&(++x2==y2));//false &&具有短路功能，判断++x!=y为false后，不再继续判断++x==y的结果
        System.out.println(x2);//9

        int x3=8;
        int y3=9;
        System.out.println( (++x3!=y3)&(++x3==y3));//false &没有短路功能，判断++x!=y为false后，继续判断++x==y的结果
        System.out.println(x3);//10

        int x4=8;
        int y4=9;
        System.out.println((++x4==y4)||(++x4!=y4));//true ||具有短路功能，判断++x==y为true后，不再判断++x!=y的结果
        System.out.println(x4);//9

        int x5=8;
        int y5=9;
        System.out.println((++x5==y5)|(++x5!=y5));//true |没有短路功能，判断++x==y为true后，继续判断++x!=y的结果
        System.out.println(x5);//10

        /*
         * &&和&的区别：
         *   &没有短路功能，不管&左边表达式的结果为true还是false，&右边表达式都要进行运算
         *   &&具有短路功能，当&&左边表达式结果为false的时候，直接判断&&运算结果为false，&&右边表达式结果不再进行运算
         *
         * ||和|的区别
         *   |没有短路功能，不管|左边表达式的结果为true还是false，|右边表达式都要进行运算
         *   ||具有短路功能，当||左边表达式结果为true的时候，直接判断||运算结果为true，||右边表达式结果不再进行运算
         * */
    }
}

条件运算符?

package JavaLearn3;

public class Demo10 {
    /*
     * 条件运算符（三目运算符/三元运算符）：
     *       语法结构：
     *           条件?表达式1:表达式2;
     *       执行规律：
     *           判断条件的结果：
     *               如果条件为true，执行表达式1；
     *               如果条件为false，执行表达式2
     * */

    public static void main(String[] args) {
        //使用条件运算符获取两个数中的最大值
        int num1 = 100;
        int num2 = 200;

        int max =num1>num2?num1:num2;
        System.out.println("两个数中的最大值是："+max);

        //使用条件运算符获取两个数中的最小值
        int min =num1<num2?num1:num2;
        System.out.println("两个书中的最小数："+min);

    }

}

?

package JavaLearn3;

import java.util.Scanner;

public class Demo11 {
    /*
     *需求说明
     * 键盘输入四位数字的会员卡号
     * 使用“/”和“%”运算符分解获得会员卡各个位上的数字
     * 将各个位上数字求和
     * 根据分解后的数字之和，判断用户是否中奖。如果数字之和大于20，则中奖
     * */
    public static void main(String[] args) {
        //创建Scanner对象
        Scanner scanner = new Scanner(System.in);

        //获取键盘输入的4位数字会员卡号
        System.out.println("请输入4位会员卡号：");
        int cardNum=scanner.nextInt();
        System.out.println("你的会员卡号是："+cardNum);

        //使用“/”和“%”运算符分解获得会员卡各个位上的数字
        int geWei =cardNum%10;
        int shiWei = cardNum/10%10;
        int baiWei =cardNum/100%10;
        int qianWei =cardNum/1000;
        System.out.println("千位："+qianWei+"，百位："+baiWei+"，十位："+shiWei+"，个位："+geWei);

        //将各个位上数字求和
        int sum =geWei+shiWei+baiWei+qianWei;
        System.out.println("你的会员卡各个位上的数字之和为："+sum);

        //根据分解后的数字之和，判断用户是否中奖。如果数字之和大于20，则中奖
        String result =sum>20?"恭喜你，中奖了":"很遗憾，没有中奖";
        System.out.println(result);
    }

}

package JavaLearn3;

import java.util.Scanner;

public class Demo12 {
    /*
     * 条件运算符的嵌套：在条件运算符中包含另外的条件运算符
     *   语法结构：
     *       条件1?(条件2?表达式1:表达式2):(条件3?表达式3:表达式4);
     *   执行规律：
     *       首先判断条件1：
     *           如果条件1为true，接着判断条件2：
     *               如果条件2为true，执行表达式1
     *               如果条件2为false，执行表达式2
     *           如果条件1为false，接着判断条件3：
     *               如果条件3为true，执行表达式3
     *               如果条件3为false，执行表达式4
     * */

    public static void main(String[] args) {
        //从键盘输入3个整数，输出3个整数中的最大值

        //创建Scanner对象
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入第一个整数：");
        int num1 =scanner.nextInt();
        System.out.println("请输入第二个整数：");
        int num2 =scanner.nextInt();
        System.out.println("请输入第三个整数：");
        int num3 =scanner.nextInt();

        int max =num1>num2?(num1>num3?num1:num3):(num2>num3?num2:num3);
        System.out.println("你输入的三个数中的最大值是："+max);
    }

}