Java基础-变量

72 阅读 0 评论 48 点赞

我是靠谱客的博主耍酷草丛，最近开发中收集的这篇文章主要介绍Java基础-变量，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

Test1：

Test2：

Test3；

Test4；

Test5：

Test6：

Test7：

Test8：

Test9:

Test10：

Test1：

编写步骤：

1. 定义类 Test1

2. 定义 main 方法

3. 控制台输出 5 行字符串类型常量值

4. 控制台输出 5 行字符类型常量值

方法一：

public class Test1 {
    public static void main(String[] args) {
        //控制台输出 5 行字符串类型常量值
        System.out.println("善学如春起之苗n不见其增，日有所长n" +
                "假学如磨刀之石" + "n不见其损，年有所亏n加油吧！少年");
        //控制台输出 5 行字符类型常量值
        System.out.println("JnAnVnAn!");
    }
}

结果一：

方法二：

public class Test1 {
    public static void main(String[] args) {
        //控制台输出 5 行字符串类型常量值
        String str1 = "善学如春起之苗";
        String str2 = "不见其增，日有所长";
        String str3 = "假学如磨刀之石";
        String str4 = "不见其损，年有所亏";
        String str5 = "加油吧！少年";
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
        System.out.println(str4);
        System.out.println(str5);
        //控制台输出 5 行字符类型常量值
        char c1 = 'J';
        char c2 = 'A';
        char c3 = 'V';
        char c4 = 'A';
        char c5 = '!';
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
    }
}

结果二：

注：两种方法可根据自己需求选择编写；

Test2：

1.定义类Test2

2.定义main方法

3.控制台输出 5 行整数类型常量值

4. 控制台输出 5 行小数类型常量值

public class Test2 {
    public static void main(String[] args) {
        //整数类型常量值
        int a = -2147483648;
        short b = -100;
        int c = 0;
        byte d = 100;
        long e = 2147483648L;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        System.out.println(e);
        //小数类型常量值
        float a1 = -100f;
        float b1 = -10f;
        float c1 = 0f;
        double d1= 10.9;
        double e1 = 100.9;
        System.out.println(a1);
        System.out.println(b1);
        System.out.println(c1);
        System.out.println(d1);
        System.out.println(e1);
    }
}

结果展示：

Test3；

编写步骤：

1. 定义类 Test3

2. 定义 main 方法

3. 控制台输出所有布尔类型常量值

public class Test3 {
    public static void main(String[] args) {
        //控制台输出所有布尔类型常量值
        boolean a = true;
        boolean b = false;
        System.out.println(a);
        System.out.println(b);
    }
}

结果展示：

Test4；

编写步骤：

1. 定义类 Test4

2. 定义 main 方法

3. 定义 2 个 byte 类型变量,分别赋 byte 类型范围内最大值和最小值,并输出在控制台.

4. 定义 2 个 short 类型变量,分别赋 short 类型范围内的值,并输出在控制台.

5. 定义 2 个 int 类型变量,分别赋 int 类型范围内的值,并输出在控制台.

6. 定义 2 个 long 类型变量,分别赋超过 int 类型范围的值,并输出在控制台.

public class Test4 {
    public static void main(String[] args) {
        //定义 2 个 byte 类型变量,分别赋 byte 类型范围内最大值和最小值,并输出在控制台.
        byte a1 = -128;
        byte a2 = 127;
        //定义 2 个 short 类型变量,分别赋 short 类型范围内的值,并输出在控制台.
        short b1 = -32768;
        short b2 = 32767;
        //定义 2 个 short 类型变量,分别赋 short 类型范围内的值,并输出在控制台.
        int c1 = -2147483648;
        int c2 = 2147483647;
        //定义 2 个 long 类型变量,分别赋 long 类型范围内的值,并输出在控制台.
        long d1 = -2147483649L;//long类型赋值时数值最后必须添加“L”，否则格式不正确
        long d2 = 2147483648L;
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(d1);
        System.out.println(d2);
    }
}

结果：

Test5：

编写步骤：

1. 定义类 Test5

2. 定义 main 方法

3. 定义 2 个 float 类型变量,分别赋值,并输出在控制台.

4. 定义 2 个 double 类型变量,分别赋值,并输出在控制台.

public class Test5 {
    public static void main(String[] args) {
        //定义 2 个 float 类型变量,分别赋值,并输出在控制台.
        float a1 = -3.14f;
        float a2 = 3.14f;
        //定义 2 个 double 类型变量,分别赋值,并输出在控制台.
        double b1 = -3.4;
        double b2 = 3.4;
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(b1);
        System.out.println(b2);
    }
}

结果：

Test6：

编写步骤：

1. 定义类 Test6

2. 定义 main 方法

3. 定义 5 个 char 类型变量,分别赋值,并输出在控制台.

4. 定义 2 个 boolean 类型变量,分别赋值,并输出在控制台.

public class Test6 {
    public static void main(String[] args) {
        //定义 5 个 char 类型变量,分别赋值,并输出在控制台.
        char a1 = '9';
        char a2 = 'J';
        char a3 = 'a';
        char a4 = ' ';
        char a5 = '@';
        //定义 2 个 boolean 类型变量,分别赋值,并输出在控制台.
        boolean b1 = true;
        boolean b2 = false;
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);
        System.out.println(a4);
        System.out.println(a5);
        System.out.println(b1);
        System.out.println(b2);
    }
}

结果：

Test7：

编写步骤：

1. 定义类 Test7

2. 定义 main 方法

3. 定义两个整数变量 a，b 并赋值

4. 控制台输出变量 a，b 互换前的值

5. 定义一个第三方变量 temp，不赋值

6. 利用第三方变量 temp 使 a，b 的值互换

7. 控制台输出变量 a，b 互换后的值

public class Test7 {
    public static void main(String[] args) {
        //定义两个整数变量 a，b 并赋值
        int a = 10;
        int b = 20;
        //控制台输出变量 a，b 互换前的值
        System.out.println("互换前：");
        System.out.println(a);
        System.out.println(b);
        //定义一个第三方变量 temp，不赋值,利用第三方变量 temp 使 a，b 的值互换
        int temp = a;
        a = b;
        b = temp;
        //利用第三方变量 temp 使 a，b 的值互换
        System.out.println("互换后：");
        System.out.println(a);
        System.out.println(b);
    }
}

结果：

Test8：

编写步骤：

1. 定义类 Test8

2. 定义 main 方法

3. 定义 2 个 int 类型变量 x、y，x 赋值为 100，y 赋值为 200

4. 定义新变量 add，保存变量 x，y 的和并打印到控制台

5. 定义新变量 sub，保存变量 x，y 的差并打印到控制台

6. 定义新变量 mul，保存变量 x，y 的积并打印到控制台

7. 定义新变量 div，保存变量 x，y 的商并打印到控制台

public class Test8 {
    public static void main(String[] args) {
        //定义 2 个 int 类型变量 x、y，x 赋值为 100，y 赋值为 200
        int x = 100;
        int y = 200;
        //定义新变量 add，保存变量 x，y 的和并打印到控制台
        int add = x+y;
        System.out.println("x,y的和为：n" +add);
        //定义新变量 sub，保存变量 x，y 的差并打印到控制台
        int sub = x-y;
        System.out.println("x,y的差为：n"+sub);
        //定义新变量 mul，保存变量 x，y 的积并打印到控制台
        int mul = x*y;
        System.out.println("x,y的积为：n"+mul);
        //定义新变量 div，保存变量 x，y 的商并打印到控制台
        int div = x/y;
        System.out.println("x,y的商为：n"+div);
    }
}

结果：

Test9:

编写步骤：

1. 定义类 Test9

2. 定义 main 方法

3. 定义 2 个 double 类型变量 x、y，x 赋值为 100.8，y 赋值为 20.6

4. 定义新变量 add，保存变量 x，y 的和并打印到控制台

5. 定义新变量 sub，保存变量 x，y 的差并打印到控制台

6. 定义新变量 mul，保存变量 x，y 的积并打印到控制台

7. 定义新变量 div，保存变量 x，y 的商并打印到控制台

    public static void main(String[] args) {
        //定义 2 个 double 类型变量 x、y，x 赋值为 100.8，y 赋值为 20.6
        double x = 100.8;
        double y = 20.6;
        // 定义新变量 add，保存变量 x，y 的和并打印到控制台
        double add = x+y;
        System.out.println("x,y的和为：n" +add);
        // 定义新变量 sub，保存变量 x，y 的差并打印到控制台
        double sub = x-y;
        System.out.println("x,y的差为：n"+sub);
        //定义新变量 mul，保存变量 x，y 的积并打印到控制台
        double mul = x*y;
        System.out.println("x,y的积为：n"+mul);
        //定义新变量 mul，保存变量 x，y 的积并打印到控制台
        double div = x/y;
        System.out.println("x,y的商为：n"+div);
    }
}

结果：

Test10：

编写步骤：

1. 定义类 Test10

2. 定义 main 方法

3. 定义 byte 类型变量，并赋值为 10，不换行输出类型说明，换行输出变量值。

4. 定义 short 类型变量，并赋值为 100，不换行输出类型说明，换行输出变量值。

5. 定义 int 类型变量，并赋值为 1000，不换行输出类型说明，换行输出变量值。

6. 定义 long 类型变量，并赋值为 10000，不换行输出类型说明，换行输出变量值。

7. 定义 float 类型变量，并赋值为 100000.0，不换行输出类型说明，换行输出变量值。

8. 定义 double 类型变量，并赋值为 1000000.0，不换行输出类型说明，换行输出变量值。

9. 定义 char 类型变量，并赋值为'Z'，不换行输出类型说明，换行输出变量值。

10.定义 boolean 类型变量，并赋值为 false，不换行输出类型说明，换行输出变量值

public class Test10 {
    public static void main(String[] args) {
        //定义 byte 类型变量，并赋值为 10，不换行输出类型说明，换行输出变量值。
        byte a = 10;
        System.out.print("整数类型-byte:");// 去掉 ln ,输出内容后,没有换行
        System.out.println(a);// 带有 ln,输出内容后,带有换行
       //定义 short 类型变量，并赋值为 100。
        short b = 100;
        System.out.print("整数类型-short:");
        System.out.println(b);
        //定义 int 类型变量，并赋值为 1000
        int c = 1000;
        System.out.print("整数类型-int:");
        System.out.println(c);
        //定义 long 类型变量，并赋值为 10000
        long d =10000L;
        System.out.print("整数类型-long:");
        System.out.println(d);
        //定义 long 类型变量，并赋值为 10000
        float f = 100000f;
        System.out.print("小数类型-float:");
        System.out.println(f);
        //定义 double 类型变量，并赋值为 1000000.0
        double g = 1000000;
        System.out.print("小数类型-double:");
        System.out.println(g);
        //定义 char 类型变量，并赋值为'Z'
        char h = 'Z';
        System.out.print("字符类型-char:");
        System.out.println(h);
        //定义 boolean 类型变量，并赋值为 false
        boolean e = false;
        System.out.print("布尔类型-boolean:");
        System.out.println(e);
    }
}

结果：