【别摸鱼了，来打卡刷题】吃透java、细化到知识点的练习题及笔试题，助你轻松搞定java

 

【快来免费打卡学习】参与方式

本期百题计划开始时间：2022-02-09

0、本文文末评论区打卡，需要登录才可以打卡以及查看其他人的打卡记录

1、以下练习题，请用对应的知识点完成，一级或者二级标题就是对应的知识点；

2、给代码要求说出结果的题，不一定都能正常运行，如果有编译异常或者运行时异常，需要给出原因及解决方案；

 

测试该学哪门语言？

至于语言的选择，推荐一个高级（java），加上1-2个脚本（python、shell），很多招聘也是这么要求的，可以说是标配，

脚本语言会基础即可（比如，我用python主要是造一些性能数据），尽量深入高级的，也就是java，而且，当前项目绝大多数是java吧（其次是go，python的太少了），

学java的好处就是：自动化、测开、性能、白盒都能做，和开发无障碍交流，有问题，也可以免费问开发，何乐而不为呢？

学习代码，只要坚持多写多练，没有学不会的。 

 

完成本文的练习题，可以达到的水平：

　　1、打牢java基础，轻松应对java笔试题

　　2、编写java接口自动化测试框架

 

考考你：你真的会hello world么？

请说出下面每个单词所表示的含义、作用

package com.qzcsbj;

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

 

 

工欲善其事，必先利其器

idea安装、配置、基本使用

https://www.cnblogs.com/uncleyong/p/10971923.html

idea已经放网盘，网盘地址：

链接：https://pan.baidu.com/s/17MxVRfp7A_q8uz7iFYk25w 
提取码：qzbj 
复制这段内容后打开百度网盘手机App，操作更方便哦

java必备基础

https://www.cnblogs.com/uncleyong/category/1288317.html 

 

参考资料：官方api文档

https://docs.oracle.com/javase/8/docs/api/index.html

 

java基础练习：变量、数据类型、输入、输出、运算符

练习1：判断输入的值是否是偶数，另外，要处理输入错误

（目的：熟悉输入、输出，特别是Scanner对象的方法）

 

练习2：输入并输出姓名、年龄、身高

 

练习3：从控制台获取Java、Oracle、HTML三门课程的成绩，计算总分和平均分（平均分保留2位小数，要求四舍五入；按如下格式输出）

 

 

练习4：输入一个数字，反转输出，如：输入123，输出321

 

练习5：输入tom和jack的年龄，比较年龄并输出相差多少岁，要求使用条件运算符

 

练习6：交换两个数值变量的值（至少两种方法）

 

练习7：下面结果分别是？说明原因

int a = 97;
char b = a;
System.out.println(b);

  

char c = 97;
System.out.println(c);

 

int m = 3;
int n = m++ + ++m;
System.out.println("m:"+m+", n:"+n);

 

java基础练习：选择结构（if、switch）

if：if...else...及if嵌套

练习1：提示用户输入三个整数，判断并输出最大值、最小值

 

练习2：

如果今天是周日且晴天，就出去嗨

如果今天是周日但不是晴天，睡懒觉

如果今天不是周日，继续996

说明：天气、星期几的变量，自己定义即可；主要练习if嵌套

 

练习3：由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else)，并且从小到大输出。 

 

 

练习4：提示用户输入三角形的边a、b、c，范围必须在 [1,100) 之间，判断三角形的类型：1.非三角形；2.等边三角形；3.直角三角形；4.等腰三角形；5.普通三角形

 

switch

练习1：周一跑步，周二、三、四打羽毛球，周五游泳，其它休息

int today=4;

 

练习2：输入 2022 年的某个月份和日期，例如 month=4，day=21，经过程序计算，打印出输入的月份和日期是 2022年的第几天：31+28+31+21

 

java基础练习：循环结构（while、do...while、for、break、continue、return）

while

练习1：输出比i（i=5）小的正整数

 

练习2：求1到100之间所有偶数的和 

 

练习3：循环提示用户输入一个非零整数，直接输入数字0为止，然后输出其中的最大值和最小值　　

 

练习4：从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序　　

 

do while

练习1：下面输出结果是？说明原因

package com.qzcsbj.demo.entity;

public class T2 {
    public static void main(String[] args) {
        int i = 5;
        do {
            System.out.println(i);
            i--;
        }while (i>5);
    }
}

 

练习2：打印输出 [0,200] 之间所有能被7整除，但不能被4整除的所有整数，要求每行打印5个，并统计个数 

 

for

练习1：求1到100之间所有偶数的和

 

练习2：循环输入五门课程的成绩，计算平均分 

 

练习3：任意输入一个整数，根据这个值输出加法表

 

练习4：打印 1-100 之间的所有素数

 

break

练习1：将1-10之间的整数相加，当累加值大于20时停止相加，输出当前整数和累加值 

 

continue

练习1：输出1到10之间所有的奇数

 

return

练习1：下面输出结果是？说明原因

package com.qzcsbj;

import java.util.Scanner;

/**
 * @公众号 : 全栈测试笔记
 * @博客 : www.cnblogs.com/uncleyong
 * @微信 : ren168632201
 * @描述 : <>
 */
public class Test {
    public static void main(String[] args) {
        System.out.println(test());
        test2();
    }
    public static int test(){
        for (int i = 0; i < 5; i++) {
            System.out.println(i);
            if (i==1){
                return i;
            }
        }
        return 10;
    }
    public static void test2(){
        for (int i = 0; i < 5; i++) {
            System.out.println(i);
            if (i==1){
                return ;
            }
        }
        System.out.println("hello");
        return;
    }
}

 

双重for循环

练习1：实现输出九九乘法表　　

 

 

练习2：某次技能大赛，共有3个班参加，每个班有4名学生参加，计算每个班级的平均分（只统计成绩大于80分的学生的平均分） 

 

 

练习3：打印如下样式的直角三角形

 

 

练习4：打印等腰三角形 

 

 

练习5：打印等边三角形 

 

练习6：输入带*字符串，把*左移输出，其他字母按原顺序输出，例如输入“as*c*gkl**o*p*h”，输出******ascgkloph

 

java基础练习：方法、递归

方法

练习1：定义方法，计算x的y次方，如2的5次方

　　

练习2：猜数字游戏：随机生成 [0,100] 之间的随机数，让用户猜生成的数字，显示猜大了、猜小了，如果猜对了，提示共猜了多少次。用Math.random()方法

 

递归

练习1：用递归实现，计算x的y次方，如2的5次方

 

练习2：输出n（n=5）到0的整数 

 

java基础练习：数组（一维、二维、传值传地址）

一维数组

练习1：定义一个int类型数组，动态赋值，然后将数组中元素反转，最后输出，要求：动态赋值定义方法；反转定义方法 

 

练习2：有一个数组 [1, 3, 66, 16, 28, 666, 168] ，循环输出数组中的元素并计算所有数的总和，并将最大值放到最前面，最小值放到最后面，然后输出数组 

 

增强for

练习1：输出数组的值[1, 3, 66, 16, 28, 666, 168]

 

传值、传地址

练习1：下面输出结果是？说明原因

package com.qzcsbj;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @公众号 : 全栈测试笔记
 * @博客 : www.cnblogs.com/uncleyong
 * @微信 : ren168632201
 * @描述 : <>
 */
public class Test {
    public static void main(String[] args) {
        /*
         * 基本数据类型
         */
        int a = 5;
        int b = a;
        b = 8;
        System.out.println(a);
        System.out.println(b);

        /*
         * 引用数据类型
         */
        int[] c = { 1,2,3 };
        int[] d = c; 
        d[0] = 666;
        System.out.println(Arrays.toString(c));
        System.out.println(Arrays.toString(d));


        change(a,c);
        System.out.println(a);
        System.out.println(Arrays.toString(c));

    }

    public static void change(int i, int[] array) {
        i = 666;
        array[array.length - 1] = 999;
        System.out.println(i);
        System.out.println(Arrays.toString(array));
    }
}

 

二维数组（含冒泡）

练习1：输出二维数组的每个元素，int[][] d = { { 1, 2, 9 }, { 5 }, { 1, 3 }, { 9, 7, 0 } }; 

 

 

练习2：有2个班，每个班有3名学生，提示用户分别输入学生的成绩，将数据保存到二维数组中，并计算每个班的平均分、全校的最高分、最低分，最后输出平均分最高的班以及对应的平均分

 

练习3：冒泡实现排序，[9,6,4,5,3]，输出：[3, 4, 5, 6, 9]，要求打印每一轮每一次冒泡后的结果 

 

不定长参数

练习1：下面的输出结果是？说明原因

package com.qzcsbj;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @公众号 : 全栈测试笔记
 * @博客 : www.cnblogs.com/uncleyong
 * @微信 : ren168632201
 * @描述 : <>
 */
public class Test {
    public static void main(String[] args) {
        // String[] names=new String[]{"tom","jack"};
        m1(6, new String[] { "tom", "jack" }); 

        m2(6,"tom","jack","alice"); 
        m2(6,"tom");
        m2(6);
        m2(6,new String[] { "tom", "jack" });

    }

    public static void m1(int n, String[] args) {
        System.out.println("m1");
    }

    public static void m2(int n,String... args){
        System.out.println("不定长参数个数："+args.length);
        if (args.length > 0){
            System.out.println("不定长参数第一个："+args[0]);
        }
    }
}

 

笔试题

练习1：数组中有一个数字出现的次数超过数组长度的一半

 

java基础练习： 类（对象数组）、构造方法及this、对象初始化

类

练习1：创建一个用户类，为用户设置年龄（0-120），并打印年龄，如果设置的不合法，给出提示

　

练习2：定义Boy、Girl类，对象boy给对象girl求婚，且girl答复；要求，boy对象的求婚方法传入girl对象，girl对象的答复方法传入求婚的对象

 

练习3：分别用面向过程和面向对象的思维，计算圆的面积；

 

全局变量、局部变量、this

练习1：在main中分别调用下面3个方法，输出结果是？并说明原因

package com.qzcsbj;

public class Test {
    String name = "jack";

    public void modifyName(String username){
        name = username + "666";
        System.out.println(name);
    }
    public void modifyName2(String name){
        name = name + "666";
        System.out.println(name);
    }
    public void modifyName3(String name){
        this.name = name + "666";
        System.out.println(name);
    }
    public static void main(String[] args) {
        Test test = new Test();

        // test.modifyName("tom");
        // System.out.println(test.name); 

        // System.out.println("===============");
        // test.modifyName2("tom"); 
        // System.out.println(test.name);

        System.out.println("===============");
        test.modifyName3("tom");
        System.out.println(test.name);
    }
}

　　

 

练习2：下面结果分别是？

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

　　

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

　　

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

 

 

对象数组

练习1：定义学生类（姓名、学号），录入学生信息，并将学生保存到数组中

 

构造方法、this

练习1：添加一个三参构造方法，要求调用两参构造方法，

package com.qzcsbj;

/**
 * @create : 2021/3/30 10:25
 * @description : <描述>
 */
public class Person {
    private String name;
    private int age;
    private String phone;

    public Person() {
        System.out.println("无参");
    }

    public Person(String name) {
        System.out.println("一个参数");
        this.name = name;
    }

    public Person(String name, int age) {
        this();
        System.out.println("两个参数");
        this.name = name;
        this.age = age;
    }


    public void study(String type){
        System.out.println(this.name + "的学习方式是：" + type);
    }

    public void study(String type,String subject){
        System.out.println(this.name + "的学习方式是：" + type + ", 学习的科目是：" + subject);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }


    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", phone='" + phone + '\'' +
                '}';
    }
}

 

 

对象初始化顺序

练习1：写代码验证对象初始化顺序：代码块（静态、非静态）、构造 

 

综合练习

练习1：定义一个Person类，要求：属性（name，age，phone），方法（study）并实现方法重载，实现封装，实例化多个对象，输出某个对象的信息，最后输出创建了多少对象 

测试类

package com.qzcsbj;

import java.util.Scanner;

/**
 * @公众号 : 全栈测试笔记
 * @博客 : www.cnblogs.com/uncleyong
 * @微信 : ren168632201
 * @描述 : <>
 */
public class Test {
    public static void main(String[] args) {
        Person p1 = new Person("jack",18,"13888888888");
        System.out.println(p1.toString());
        System.out.println("当前累计已经创建了" + Person.getObj_nums() + "个Person对象。");
        System.out.println(p1.getName());
        System.out.println(p1.getAge());
        System.out.println(p1.getPhone());
        Person p2 = new Person("tom",19,"13888888889");
        System.out.println("当前累计已经创建了" + Person.getObj_nums() + "个Person对象。");
        Person p3 = new Person("laowang",19,"13888888887");
        System.out.println("当前累计已经创建了" + Person.getObj_nums() + "个Person对象。");
        p3.study("book");
        p2.study("video", "java");
        Person p4 = new Person();
        System.out.println("当前累计已经创建了" + Person.getObj_nums() + "个Person对象。");
    }
}

 

 

java基础练习：封装、继承、多态

封装

练习1：封装一个User对象（name，age），setAge方法要求年龄只能输入0-130

 

继承、构造调用、super

练习1：在子类中，添加一个2参构造方法，且调用父类1参构造方法

package com.qzcsbj;

/**
 * @create : 2021/3/31 10:56
 * @description : <描述>
 */
public class T {
    public static void main(String[] args) {
        System.out.println("=====创建对象，不传参");
        C c = new C();
        System.out.println("=====创建对象，传1参"); 
        C c2 = new C(18);
        System.out.println("=====创建对象，传2参"); 
        C c3 = new C("jack",18);

        System.out.println("=====对象调用子类test方法");
        c.test();
        System.out.println("=====对象调用子类test方法");
        c3.test();

        System.out.println("===========修改父类属性值");
        B b = new B();
        b.name = "父类的name值";
        System.out.println("=====对象再次调用子类test方法");
        c.test();  
    }
}

class A{
    public A() {
        System.out.println("父父类--无参构造");
    }
}

class B extends A{
    String name;

    public B() {
        System.out.println("父类--无参构造");
    }

    public B(String name) {
        this.name = name;
        System.out.println("父类--带参构造");
    }
    public void fun(){
        System.out.println("父类方法fun");
    }
}

class C extends B{
    int age;

    public C() {
        System.out.println("子类--无参构造");
    }

    public C(int age) {
        super(); 
        this.age = age;
        System.out.println("子类--带1参构造");
    }


    public void test(){
        String name = "局部变量name";
        System.out.println(age);  
        System.out.println(this.age);
        System.out.println(name);  
        System.out.println(this.name);  
        System.out.println(super.name); 
        this.name = "子类修改后的name值";
        System.out.println(this.name);
        System.out.println(super.name); 
        super.name = "父类修改后的name值";
        System.out.println(this.name); 
        System.out.println(super.name);

        fun(); 

    }
    public  void fun(){
        System.out.println("子类方法fun");
        super.fun(); 
    }
}

 

方法重写

练习1：创建父类Person，子类Japan、Chinese，重写父类方法，实现子类的差异化，比如：日本人说日语，中国人说汉语

　　

多态

练习1：创建一个宠物父类：Pet，两个子类：Cat、Dog，主人类：Master，用多态实现主人陪宠物玩耍、主人给宠物喂食物

 

对象属性

练习1：创建Person类（name，age，address），address是对象属性，Address类（province、city），创建一个Person类对象person，并给所以属性赋值，最后打印person

 

 

练习2：定义MyDate类，在MyDate类中覆盖equals方法，使其判断当两个MyDate类型对象的年月日都相同是，结果为ture，否则为false。

MyDate m1 = new MyDate(14, 3, 2022);
MyDate m2 = new MyDate(14, 3, 2022);

 

 

java基础练习：抽象类、接口

笔试题

练习1：下面输出结果是？为什么？

package com.qzcsbj;


/**
 * @公众号 : 全栈测试笔记
 * @博客 : www.cnblogs.com/uncleyong
 * @微信 : ren168632201
 * @描述 : <>
 */

interface A{
    int x = 0;
}
class B{
    int x = 1;
}
public class Test extends B implements A{
    public void p(){
        System.out.println(x);
    }
    public static void main(String[] args) {
        new Test().p();
    }
}

  

面向对象综合练习

练习1：写一个宠物超市系统（java面向对象练习题，综合运用：封装、继承、多态），需求详情：https://www.cnblogs.com/uncleyong/p/12580618.html

 

java基础练习：访问修饰符、非访问修饰符

练习1：访问修饰符public、private、protected，以及不写（默认）时的区别？

 

练习2：如果访问非本类的private修饰的属性、方法？

public class Person{
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private String getName() {
        return name;
    }

    private int getAge() {
        return age;
    }
}

 

Person p = new Person("jack", 18);

 

练习3：下面输出结果是？

package com.qzcsbj;

/**
 * @公众号 : 全栈测试笔记
 * @博客 : www.cnblogs.com/uncleyong
 * @微信 : ren168632201
 * @描述 : <>
 */
public class Test {
    public static void main(String[] args) {
        Person.test(2);
    }
}

class Person{
    public static void test(final int m){ 
        final int n =1; 
        n=2;
        System.out.println(n); 
        m=3; 
        System.out.println(m);
    }
}

 

java基础练习：常用类（Object、String、StringBuffer、包装类）

Object

练习1：根据给定的类（类的属性：name，age，phone，job），重写equals方法，要求是name，age相同，即认为对象相同，要求：不能用工具生成，自己实现的equals不能和工具生成的一样

 

String 

练习1：提示用户输入字符串，1.计算字符串包含多少个数字、英文字母以及其他字符，2.计算字符串中字母a出现的次数

 

 

练习2：提示用户输入字符串，1.统计每个字母出现的次数（忽略大小写）并输出，2.统计每个数字出现的次数，存储到数组nums中　　

上面图中输出的数组，对应0-9的出现次数

 

正则 

练习1：一次性获取三门课程的成绩，保存到数组，然后输出　　

 

String常量池

练习1：下面输出结果是？

package com.qzcsbj;

public class Test {
    public static void main(String[] args) {
        System.out.println("=========使用双引号直接创建字符串=======");
        String addr = "北京";
        System.out.println(Integer.toHexString(addr.hashCode()));  
        addr = "上海";
        System.out.println(Integer.toHexString(addr.hashCode())); 
        String name = "jack";
        System.out.println(Integer.toHexString(name.hashCode()));   
        String name2 = "jack";
        System.out.println(Integer.toHexString(name2.hashCode()));    
        System.out.println("equals：" + name.equals(name2)); 
        System.out.println("name==name2: "+(name==name2)); 
        System.out.println();

        System.out.println("=========使用构造方法创建字符串=======");
        String name3 = new String("jack");
        System.out.println(Integer.toHexString(name3.hashCode()));  
        String name4 = new String("jack");
        System.out.println(Integer.toHexString(name4.hashCode()));  
        System.out.println("equals：" + name3.equals(name4));  
        System.out.println("name3==name4: "+(name3==name4));  
        System.out.println();

        System.out.println("=========两种方式对象比较=======");
        System.out.println("name==name3: "+(name==name3));  
        System.out.println("equals：" + name.equals(name3));  

    }
}

 

练习2：下面的输出结果是？

String s1 = new String("qzcsbj");
String s2 = new String("qzcsbj");
String s3 = "qzcsbj";
String s4 = "qzcsbj";
String s5 = "qz";
String s6 = "csbj";
String s7 = s5 + s6;
String s8 = "qz" + "csbj";
String s9 = s5 + "csbj";
 
System.out.println(s1==s2);
System.out.println(s1.equals(s2));
System.out.println(s3==s4);
System.out.println(s3.equals(s4));
System.out.println(s1==s3);
System.out.println(s1.equals(s3));
System.out.println(s3==s7);
System.out.println(s3.equals(s7));
System.out.println(s3==s8);
System.out.println(s3.equals(s8));
System.out.println(s3==s9);
System.out.println(s3.equals(s9));
System.out.println(s8==s7);
System.out.println(s8.equals(s7));
System.out.println(s9==s7);
System.out.println(s9.equals(s7));

 

String和StringBuffer性能对比

练习1：写代码测试字符串拼接的性能，比如拼接10万次

 

 

包装类

练习1：下面输出结果是？为什么？

package com.qzcsbj;

/**
 * @公众号 : 全栈测试笔记
 * @博客 : www.cnblogs.com/uncleyong
 * @微信 : ren168632201
 * @描述 : <>
 */
public class Test {
    public static void main(String[] args) {
        
        int m = 6;
        Integer n = new Integer(1);
        int p = m + n;  
        System.out.println(p);  // 7


        
        int x=3;
        Integer y = new Integer(3);
        Integer z = new Integer(3);
        System.out.println(y==z);  
        System.out.println(x==z); 

       
        Integer integer = new Integer(10); 
        test(integer); 
        System.out.println(integer);  

    }
    public static void test(Integer integer){
        integer=666; // 修改为666
    }
}

 

 

练习2：下面代码是否正确，为什么？

Object obj=5;

 

笔试题

练习1：删除字符串下标是3的倍数的字符 ，s = "aabbcdeefg"，输出abcdef

 

练习2：输入一个字符串，输出出现次数最多的前2个字符及出现次数

 

练习3：输入字符串（中间有若干个空格隔开），要求：以空格隔开，删除空格两边字符串的重复字符再输出，例：aabbbcc ddaaaffggbb变为abc dafgb(注意：输入的空格得保留下来)

 

java基础练习：常用类（Date、SimpleDateFormat、Calendar、Math、Random）

Date、SimpleDateFormat

练习1：假设1910年1月1日是星期一，请写一个函数：该函数输入为1910年1月1日后的任意一天日期，格式为字符串YYYY-MM-DD，输出为该日期是星期几的英文。 

 

Calendar

练习1：获取2008年2月有多少天

 

练习2：输入4位年份，输出当年2月天数，不能用判断是否闰年的方式。如：输入2019，输出的是28天

 

笔试题

练习1：实现一个类，打印昨天的当前时刻

 

java基础练习：集合-Collection（ArrayList、LinkedList等）

ArrayList

练习1：定义Student类并创建对象，把对象放入ArrayList，循环ArrayList，打印学生信息

 

练习2：提示用户输入整数，存放到ArrayList集合中，输入0代表结束。分别使用for、foreach、iterator循环集合，并删除所有是3的倍数的元素

 

练习3：定义一个学生类Stu，属性：id、name、age

1.提示用户循环输入学生的信息，存储到ArrayList集合中

2.输出所有学生的信息 

3.根据学号修改指定学生信息

4.根据学号删除学生

 

练习4：list1=[A,B,C]，list2=[B,C,A]，对比两个列表，内容相同返回ture，不同返回false

假设list中是String类型对象，下面运行结果是true

String[] strArray = {"A","B","C"};
List list1 = Arrays.asList(strArray);
String[] strArray2 = {"B","C","A"};
List list2 = Arrays.asList(strArray2);

 

 

ArrayList和LinkedList性能对比：读取操作

练习1：使用Java编程语言定义两个容器存储结构link, array分别如下：

private List<Integer> link = new LinkedList<Integer>();

private List<Integer> array = new ArrayList<Integer>(); 

现在要测试link和array存储10万个Integer对象，比较link与array读取这10万条存储数据的效率，请写出实现的代码。

 

 

java基础练习：集合-Map（HashMap、Collections工具类等）

练习1：班级有不同数量的学生，用map保存；循环取出学生信息

 

练习2：统计一个字符串中每个字符出现的次数，保存到HashMap集合中

 

练习3：统计一个字符串中每个字符出现的次数，保存到HashMap集合中，通过排序，打印输出次数最多的前三个字符及次数

 

java基础练习：异常

练习1：下面结果是？ 

package com.qzcsbj;

public class TestException {
    public static void main(String[] args) {
        int[] nums = { 12, 4, 23 };

        try {
            System.out.println(nums[3]);
            System.out.println(5 / 0);
            System.out.println("try中最后的代码。。。");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数组下标越界异常。。。：" + e.getMessage());
        } catch (ArithmeticException e) {
            System.out.println("算术异常。。。：" + e.getMessage());
        }
       
        System.out.println("异常之后的代码。。。");
    }
}

　　

java基础练习：枚举、泛型

练习1：list1=[A,B,C]，list2=[B,C,A]，对比两个列表，内容相同返回ture，不同返回false。要求定义一个泛型方法实现（解决类型侵入的问题）

说明：A可以任意类型的对象，

比如Student对象

List<Student> stu1s = new ArrayList<>();
stu1s.add(new Student("jack",18));
stu1s.add(new Student("tom",19));

List<Student> stu2s = new ArrayList<>();
stu2s.add(new Student("tom",19));
stu2s.add(new Student("jack",18));

也可以是String对象

String[] strArray = {"A","B","C"};
List list1 = Arrays.asList(strArray);
String[] strArray2 = {"B","C","A"};
List list2 = Arrays.asList(strArray2);

 

java基础练习：I/O输入输出流

练习1：删除给定目录下的空目录（包含子目录下的），测试文件夹见Q群文件

 

 

java基础练习：反射

练习1：读取所有数据并保存到对象集合，表单名：testcase

 

java基础练习：JDBC

练习1：解析配置文件jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://192.168.168.168:3360/gifts?useUnicode=true&characterEncoding=utf-8&useSSL=true
jdbc.username=root
jdbc.password=123456

 

 

练习2：从数据库查询数据

sql查询结果：

 

代码操作结果

 

详见：https://www.cnblogs.com/uncleyong/p/15867779.html

 

【综合应用】：java自动化测试框架

fastjson的使用（处理json字符串、json数组）

练习1：将json字符串转化成map，字符串：{"username":"qzcsbj", "password":"123456"}

 

练习2：json数组转换为对象集合，[{"name":"jack","age":"18"},{"name":"tom","age":"19"}]

 

java操作excel（通过POI）

练习1：读取所有数据，并打印出来，表单名：testcase

 

 

 

详见：https://www.cnblogs.com/uncleyong/p/15867741.html

 

HttpClient的使用（get、post请求）

详见：https://www.cnblogs.com/uncleyong/p/15867745.html

 

TestNG用法

详见：https://www.cnblogs.com/uncleyong/p/15867747.html

 

接口自动化测试框架设计思路（还没更新完，暂未对外）

https://www.cnblogs.com/uncleyong/p/15867903.html

 

参考答案

建议先自己动手练习，只看答案不思考、不动手练习是学不会的，有问题微信留言、或者登录后下方评论区留言、查看参考答案。

每日一题，下方留言区打卡给参考答案：滴，学习卡

 

bak：https://www.cnblogs.com/uncleyong/p/15865009.html

原文：https://www.cnblogs.com/uncleyong/p/15828510.html

更多笔试题：https://www.cnblogs.com/uncleyong/p/11119489.html