Java入门实操复习心得（全）

最新推荐文章于 2024-06-26 19:56:46 发布

大头白菜

最新推荐文章于 2024-06-26 19:56:46 发布

阅读量794

点赞数

分类专栏： JAVA 文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/sk_girl/article/details/125628213

版权

这篇博客详述了Java入门的复习心得，涵盖从基本的输出、变量到复杂的多线程、泛型等内容。通过实例解析了Byte与Short的区别、float与double、字符串拼接、数组操作、各种运算符、Scanner的使用、多线程编程以及文件操作等核心知识点。还讨论了类、对象、继承、接口、异常处理等方面，提供了丰富的代码示例。

摘要由CSDN通过智能技术生成

JAVA实操复习心得

由于图片有点问题，完整的文档放在我的资源里了
csdn：java技能树学习链接

(1条消息) Java技能树 (csdn.net)

推荐b站：韩顺平java

1. 输出Hello

package Java2022_6_2;

public class Hello {
   
    public static void main(String[] args) {
   
        System.out.println("Hello");
    }
}

2. 转义字符

/*02 转义字符*/
public class ChangeChar {
   
    public static void main(String[] args) {
   
        System.out.println("北\t上\t广");      //提示：\t表示间隔
        System.out.println("---------");

        System.out.println("北\n上\n广");      //提示：\n表示换行
        System.out.println("---------");

        System.out.println("北\\上\\广");      //提示：\\表示输出\
        System.out.println("---------");

        System.out.println("北\"上\'广");      //提示：\"表示输出"    \'表示输出‘
        System.out.println("---------");

        System.out.println("北\r上\r广");      //提示：\r表示后面会替换掉前面的数据
        System.out.println("---------");
    }
}

3. 变量，字符串拼接

public class Var {
   
    public static void main(String[] args) {
   
        int a = 100;
        int b = 100;
        String str = "一百";
        System.out.println(a);
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a/b);
        System.out.println(a*b);
        System.out.println("----------");

        System.out.println(a+str);					//字符串拼接：a本身是一个整数类型，被变为字符串类型
        System.out.println("----------");

        System.out.println(str+100);                //把两个数据拼接（连接）在一起
        System.out.println("----------");

        System.out.println(100+str);
        System.out.println("----------");

        System.out.println(100+3+str);
        System.out.println("----------");
    }
}

4. Byte与Short的区别

public class ByteOrShort {
   
    public static void main(String[] args) {
   
        byte n1 = 3;        //byte：开辟1个字节的空间
        short n2 = 3;       //short：开辟2个字节的空间
        System.out.println(n1);
        System.out.println(n2);
    }
}

--输出结果：
    3
    3

5. float跟double的区别

public class FloatOrDouble {
   
    public static void main(String[] args) {
   
        double n1 = 3.1415926535;
        float n2 = 3.1415926535f;
        System.out.println(n1+"\t"+n2);
        System.out.println("----------");

        double num1 = 2.7;
        double num2 = 8.1/3;
        System.out.println(num1==num2);
        System.out.println(num1+"\t\t"+num2);
        System.out.println("----------");

        if(Math.abs(num1-num2)<0.000001){
   
            System.out.println("num1等于num2");
        }
        else{
   
            System.out.println("num1不等于num2");
        }
    }
}

6. char

public class CharVar {
   
    public static void main(String[] args) {
   
        char c1 = 'a';
        char c2 = 97;           //97对应的ASCII码 是a
        char c3 = '许';
        char c4 = '\t';         //\t表示空格
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println("----------");
        System.out.println((int)c3);
        System.out.println("----------");
        char c5 = 35768;
        System.out.println(c5);
    }
}

7. boolean（true、false）

public class BooleanVar {
   
    public static void main(String[] args) {
   
        boolean b1 = true;          //注意boolean类型的值不能是o，1或-1，这里与C语言不同
        if(b1==true){
   
            System.out.println("考试通过");
        }
        else{
   
            System.out.println("考试不通过");
        }
    }
}

--运行结果：
    考试通过

8. 自动类型转换1

public class AutoConvert {
   
    public static void main(String[] args) {
   
        //只允许从低精度向高精度的转换
        // char int long float double
        // byte short int long float double
        double d = 100;                 //输出结果为100.0，是因为int型转换为double型
        int i = 'a';                    //输出结果为97，是因为char型转换为int型
        System.out.println(d);
        System.out.println(i);
    }
}

9. 自动类型转换2

public class AutoConvert {
   
    public static void main(String[] args) {
   
        //只允许从低精度向高精度的转换
        // char int long float double
        // byte short int long float double
        double d = 100;
        int i = 100;
        float f = 10.1f;
        System.out.println(d+i+f);		//输出的数据类型是精度最高的，也就是double型
    }
}

10. 强制类型转换

public class ForceConvert {
   
    public static void main(String[] args) {
   
        //允许从高精度向低精度的转换
        // char int long float double
        // byte short int long float double
        int i = (int)1.9;
        byte b = (byte)2000;
        System.out.println(i);          //结果为1，精度丢失
        System.out.println(b);          //结果为-48，数据溢出
    }
}

11. String类型转换

public class StringConvert {
   
    public static void main(String[] args) {
   
        int i = 10;
        double d = 10.0;
        float f = 10.0f;

        String s1 = i+"";       //i拼接上一个空字符串后，所表示的数值就是String类型。
        String s2 = d+"";
        String s3 = f+"";

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
    }
}

--输出结果：
10
10.0
10.0

public class StringConvert {
   
    public static void main(String[] args) {
   
        //问题1：怎么把String类型转换为int、double或float类型
        String s1 = "123";
        int x1 = Integer.parseInt(s1);      //parseInt表示传入值
        double y1 = Double.parseDouble(s1);
        float z1 = Float.parseFloat(s1);
        System.out.println(x1);
        System.out.println(y1);
        System.out.println(z1);

        System.out.println("---------------");
        //问题2：怎么把String类型转换为char类型
        System.out.println(s1.charAt(0));       //charAt(int index)中的index是索引的意思，0是输出第一个字符
        System.out.println(s1.charAt(1));       //index为1时，输出第二个字符
        System.out.println(s1.charAt(2));       //index为2时，输出第三个字符
    }
}

12. 除法运算

public class DevUse {
   
    public static void main(String[] args) {
   
        System.out.println(10/3);       //结果的精度为int型
        System.out.println(10.0/3);     //结果的精度为double型

        double d = 10/3;        //3     3转成精度大的double型 3.0
        System.out.println(d);
    }
}

13. 取模规则（公式：a % b = a - (a / b * b)）

public class DevUse {
   
    public static void main(String[] args) {
   
        System.out.println(10 % 3);             //1
        System.out.println(-10 % 3);            //-1
        System.out.println(10 % (-3) );         //1
        System.out.println(-10 % (-3) );        //-1
        /*
            -10 % (-3) 
         = -10 - (-10 / (-3) * (-3)) 
         = -10 - (3 * (-3)) 
         = -10 + 9
         = -1
         */
    }
}

14. 自增

public class AutoAdd {
   
    public static void main(String[] args) {
   
        int i = 1;
        System.out.println(i++);       //1

        int j = 1;
        System.out.println(++j);       //2

        int k = 1;
        k = k++;
        System.out.println(k);         //1
    }
}

15. 逻辑运算符

public class LogicOperater {
   
    public static void main(String[] args) {
   
        //      &, &&, |, ||, !, ^
        boolean b1 = true;
        boolean b2 = true;
        boolean b3 = false;
        boolean b4 = false;
        if(b1 & b2){
   
            System.out.println("1");
            //执行，true & true = true
        }
        if(b1 & b3){
   
            System.out.println("2");
            //不执行，true & false = false
        }
        if(b1 | b3){
   
            System.out.println("3");
            //执行，true | false = true
        }
        if(b1 & !b3){
   
            System.out.println("4");
            //执行，!false = true
        }
        if(b1 ^ b3){
   
            System.out.println("5");
            //执行，true ^ false = true
        }
    }
}

public class LogicOperater {
   
    public static void main(String[] args) {
   
        //在&&运算中，左边如果是false，则不再对右边进行运算
        int i = 20;
        if(i<10 && i++>20){
                //i<10 是false ，所以后面的i++不再执行
            System.out.println("对");
        }
        else {
   
            System.out.println("错");
        }
        System.out.println(i);          //20

        
        在&运算中，左边如果是false，对右边仍然进行运算
        int j = 20;
        if(j<10 & j++>20){
   
            System.out.println("对");
        }
        else {
   
            System.out.println("错");
        }
        System.out.println(j);          //21
    }
}

16. 赋值运算符

public class Operater {
   
    public static void main(String[] args) {
   
        int i = 10;
        i += 4;
        System.out.println(i);          //14

        byte b = 10;
        /*
        b += 4；
        会报错，因为b是byte型，而b+4是int型
         */

        b = (byte)(b+4);
        //正确写法
        System.out.println(b);          //14
    }
}

17. 三元运算符

public class ThreeOperater {
   
    public static void main(String[] args) {
   
        /*
        a>b ? a : b;
        若a大，就输出a，否则输出b
        */
        int a = 10;
        int b = 20;
        int c = 30;

        //目的：求出a,b,c 哪个数最大？
        int max1 = a>b ? a : b;             //10<20，输出20
        int max2 = max1 > c ? max1 : c;      //20<30，输出30

        System.out.println(max2);       //30
    }
}

--把他们合并到一起，求出a,b,c 哪个数最大？
public class ThreeOperater {
   
    public static void main(String[] args) {
   
        int a = 10;
        int b = 20;
        int c = 30;

        int max2 = (a>b ? a : b) > c ? (a>b ? a : b): c;
        System.out.println(max2);       //30
    }
}

18. Scanner（）

package Java2022_6_7;

import java.util.Scanner;

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

        Scanner scanner = new Scanner(System.in);   //返回一个scanner

        System.out.println("输入您的年龄");
        int age = scanner.nextInt();
        System.out.println("您的年龄"+age);

        System.out.println("输入您的工资");
        double wage = scanner.nextDouble();
        System.out.println("您的工资"+wage);
    }
}

运行结果：
    输入您的年龄
    22
    您的年龄22
    输入您的工资
    7000
    您的工资7000.0

19. 位运算符

package Java2022_6_21;

public class BitOperater {
   
    public static void main(String[] args) {
   
        //位运算符：
        // &    有0全0
        // |    有1全1
        // ~    按位取反
        // ^    相异为1，相同为0
        System.out.println(2&3);//00000010  &  00000011 = 00000010 ,结果为2
        System.out.println(2|3);//00000010  |  00000011 = 00000011 ,结果为3
        System.out.println(2^3);//00000010  |  00000011 = 00000001 ,结果为1
        System.out.println(~3);
        /*
        00000000 00000000 00000000 00000011
        按位取反:
        11111111 11111111 11111111 11111100
        再减去1:
        11111111 11111111 11111111 11111011
        首位不变，其它位按位取反：
        10000000 00000000 00000000 00000100
        结果为-4
         */
    }
}

左移，右移，无符号右移(<<， >>，>>>)

提示1：左移几次，就乘上几次2；右移几次，就除去几次2。

提示2：负数要用补码来进行运算，要先对其补码进行移动，最后再将补码变为原码，即得到结果。

public class BitOperater {
   
    public static void main(String[] args) {
   
        // >>2    向右移动2位
        // <<2    向左移动2位
        // >>>2   无符号右移2位
        int i = 4>>2;       // 4/2/2 = 1
        System.out.println(i);
        /*
        00000000 00000000 00000000 00000100
        向右移动2位：
        00000000 00000000 00000000 00000001
        结果为1
        */

        int y = 4<<2;        // 4*2*2 = 16
        System.out.println(y);

        int z = 4<<2;        // 4*2*2 = 16
        System.out.println(z);

        int k = 8<<3;        // 8*2*2*2 = 64
        System.out.println(k);
        /*
        * 00000000 00000000 00000000 00001000
        * 向左移动3位
        * 00000000 00000000 00000000 01000000
        * 结果为64
        * */

        //负数要用补码来进行运算，要先对其补码进行移动，最后再将补码变为原码，即得到结果.
        //在移动过程中其符号位保持不变
        int l = -4<<2;            //(-4)*2*2 = -16
        System.out.println(l);
        /*
        * -4的原码      10000000 00000000 00000000 00000100
        * -4的反码      11111111 11111111 11111111 11111011
        * 补码=反码+1   11111111 11111111 11111111 11111100
        * 补码左移2位：  11111111 11111111 11111111 11110000
        *
        * 最后将补码变为原码（步骤：补码减1，然后取反）
        * 11111111 11111111 11111111 11101111
        * 10000000 00000000 00000000 00010000
        * 结果为-16
        * */
        int m = -4>>2;            //(-4)/2/2 = -1
        System.out.println(m);
        /*
        * -4的补码      11111111 11111111 11111111 11111100
        * 补码右移2位    10111111 11111111 11111111 11111111
        * 最后将补码变为原码（步骤：补码减1，然后取反）
        *  10111111 11111111 11111111 11111110
        *  10000000 00000000 00000000 00000001
        * 结果为-1
        * */


        //无符号右移
        int n = -4>>>2;        //结果为：1073741823
        System.out.println(n);
        /*
        * -4的补码        11111111 11111111 11111111 11111100
        * 无符号右移2位    00111111 11111111 11111111 11111111
        * 此时已经是正数，正数的补码就是其本身，即为原码：
        *                00111111 11111111 11111111 11111111
        * */
    }
}

20. Switch

package Java2022_6_22;
import java.util.Scanner;

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

        System.out.println("请输入a-g:");
        Scanner scanner = new Scanner(System.in);
        char c = scanner.next().charAt(0);

        switch (c){
   
            case 'a':
                System.out.println("星期一");
                break;
            case 'b':
                System.out.println("星期二");
                break;
            case 'c':
                System.out.println("星期三");
                break;
            case 'd':
                System.out.println("星期四");
                break;
            case 'e':
                System.out.println("星期五");
                break;
            default:
                System.out.println("周末");
                break;
        }
        System.out.println("退出switch");
    }
}

21. Switch成绩管理（大于等于60分及格，小于60不及格）

package Java2022_6_22;
import java.util.Scanner;

public class SwitchScore {
   
    public static void main(String[] args) {
   
        System.out.println("请输入分数（0-100）");
        Scanner scanner = new Scanner(System.in);
        double v = scanner.nextDouble();
        if(v>=0 && v<=100) {
           //用来过滤
            //v(0-100)  100/60=1 60/60=1 59/60=0
            switch ((int)v/60) {
   
                case 0:
                    System.out.println("成绩不合格");
                    break;
                case 1:
                    System.out.println("成绩合格");
                    break;
                default:
                    System.out.println("输入的成绩有误！");
                    break;
            }
        }
        else
            System.out.println("成绩有误，不在0-100内！");

    }
}

package Java2022_6_22;

import java.util.Scanner;

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

        System.out.println("请输入1-12月份中的一个月份");
        Scanner scanner = new Scanner(System.in);
        int i = scanner.nextInt();

        switch (i){
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
            default:
                System.out.println("您输入的月份有误");
        }
    }
}

22. switch穿透，判断季节

package Java2022_6_22;

import java.util.Scanner;

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

        System.out.println("请输入1-12月份中的一个月份");
        Scanner scanner = new Scanner(System.in);
        int i = scanner.nextInt();

        switch (i){
   
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
            default:
                System.out.println("您输入的月份有误！");
        }
    }
}

23. For循环

package Java2022_6_22;

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

        int i = 0;          //提升作用域
        for (; i < 10; i++) {
   
            System.out.println("i="+i);

        }
        System.out.println(i);
    }
}

24. For求9倍数

问题：1-100 取出9的倍数，求出有多少个，并且这些数相加的总数是多少？

package Java2022_6_22;

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

        int j=0;
        int sum = 0;
        for (int i=1; i<100; i++) {
   

            if(i%9==0) {
          //取出9的倍数
                j++;           //j起到计数器的作用，求出有多少个9的倍数
                sum=sum+i;
                System.out.println(i);
            }
        }

        System.out.println("共有"+j+"个9的倍数");

        System.out.println("这些数相加的总数是"+sum);
    }
}

25. 使用For循环嵌套做一个99乘法表

package Java2022_6_24;

public class MulFor {
   
    public static void main(String[] args) {
   
        // 1*1
        // 1*2 2*2
        // 1*3 2*3 3*3
        // 1*4 2*4 3*4 4*4
        // …………一共9层
        for (int i=1; i<=9; i++) {
   
            for (int j=1; j<=i; j++) {
   
                System.out.print(j+"*"+i+"="+(j*i)+"\t");    //print:不换行输出
            }
            System.out.println();   //println:自动换行
        }
    }
}

26. For嵌套，打印一个金字塔

package Java2022_6_24;

public class GoldTown {
   
    public static void main(String[] args) {
   
        //      *           1 = 1*2-1       空格数: 5
        //     ***          3 = 2*2-1              4
        //    *****         5 = 3*2-1              3
        //   *******        7 = 4*2-1              2
        //  *********       9 = 5*2-1              1

        int n = 5;      //n:是层数
        for (int i=1; i<=n; i++) {
   
            for (int j=n; j>=i; j--) {
         //作用：输出每一行的空格数
                System.out.print(" ");      //无换行输出空格
            }
            for