自动化测试面题

一般自动化面试会问到一些问题， 功能测试逻辑，selenium，appium，java，数据库，linux等一些相关的问题；

将自己面试过程中遇到的一些问题，整理下来；

 

java部分：

1. Java的垃圾回收机制

使得java程序员在编写程序的时候不在考虑内存管理，垃圾回收可以有效的防止内存泄露，有效的使用空闲的内存；

2. 算法题：一个字符串，如"This is a test !" ,输出"test a is This",要考虑空间。

public static void main(String[] args) {
        String value = "this is a test";
        String[] words = value.split(" ");
        for (int i=words.length-1;i>=0;i--){
            System.out.print(words[i]+" ");
        }
    }

输出结果：
test a is this 

3. HashMap与HashTable的区别

1. HashMap几乎可以等价于Hashtable，除了HashMap是非synchronized的，并可以接受null(HashMap可以接受为null的键值(key)和值(value)，而Hashtable则不行)。
2. HashMap是非synchronized，而Hashtable是synchronized，这意味着Hashtable是线程安全的，多个线程可以共享一个Hashtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的。Java 5提供了ConcurrentHashMap，它是HashTable的替代，比HashTable的扩展性更好。

4. 对抽象类与接口的区别

抽象类：用abstract关键字修饰；

接口 ：用interface修饰；内部只定义一些抽象类方法，不做实现；实现了接口就必须实现接口里面所有的方法；

5. Java类的基本数据类型？

整型：byte，short，int，long；

浮点：float，double；

char； boolean；

6. List是有序还是无序？

list 有序的可重复的；

Set集合？ 存放的元素是不能重复的；

7. http 和https 有什么区别？

http 标准端口是80 ，https是443;

http 是超文本传输协议，信息是明文传输，https 则是具有安全性的ssl加密传输协议;

http 的连接很简单,是无状态的，https协议是由SSL+http协议构建的可进行加密传输、身份认证的网络协议 要比http协议安全;

8. 一个数组，数组去重的话可以怎么做；

1> 思路：定义一个新数组，并存放原数组的第一个元素，然后将元素组一一和新数组的元素对比，若不同则存放在新数组中。

2> set集合的方法，set 集合不允许重复；

9. 两个列表，合并，去重，排序，用代码实现；

public static void main(String[] args) {
        List lista = new ArrayList<>();
        List listb = new ArrayList<>();
        lista.add(5);
        lista.add(1);
        lista.add(3);
        listb.add(5);
        listb.add(7);
        listb.add(9);
        Set set = new HashSet();
        set.addAll(lista);
        set.addAll(listb);
        //将set集合转为list
        List list = new ArrayList(set);
        //排序
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });

        System.out.println(list);
    }

输出结果：
[1, 3, 5, 7, 9]

10. 两个int类型的数组，找其相同元素，不同元素，用代码实现；

java实现：

public static void main(String[] args) {
       String a[] = {"a","c","f","m"};
       String b[] = {"f","h","p","m"};
       Set seta = new HashSet();
       Set setb = new HashSet();
       for (int i=0; i<a.length; i++){
           for (int j=0; j<b.length; j++){
               //比较:相同的放seta集合；
               if(a[i].equals(b[j])){
                   seta.add(a[i]);
               }else {
                  //不同的：放setb集合，要将a，b数组的内容都加进去；
                   setb.add(a[i]);
                   setb.add(b[j]);
               }
           }
       }
       //输出相同元素
       System.out.println(seta);
       //输出不同元素
        setb.removeAll(seta);
        System.out.println(setb);
    }

输出结果：
[f, m]
[p, a, c, h]

python实现：

def test01():
    #定义两个集合
    setM = set()
    setN = set()
    a=[2,6,7]
    b=[2,9,0]
    #开始一一对比
    for i in range(a.__len__()):
        for j in range(b.__len__()):
            if a[i] == b[j]:
                setM.add(a[i]) #相同放M集合
            else:
                setN.add(a[i]) #不同均放N集合
                setN.add(b[j])
    # #1.去除对称差集：
    # setJ = setM ^ setN
    # print("相同元素：")
    # print(setM)
    # print("不同元素：")
    # print(setJ)

    #2.N集合移除M集合的元素
    for x in setM:  #遍历M集合的元素，从N集合中移除；
        setN.remove(x)
    print("相同元素：")
    print(setM)
    print("不同元素：")
    print(setN)


if __name__ == '__main__':
    test01()

11. 两个列表，找其相同元素，不同元素，用代码实现；

public static void main(String[] args) {
        List lista = new ArrayList<>();
        List listb = new ArrayList<>();
        lista.add("a");
        lista.add("c");
        lista.add("f");
        lista.add("m");
        listb.add("f");
        listb.add("h");
        listb.add("p");
        listb.add("m");
        //set取并集：a,c,f,m,h,p
        Set set = new HashSet();
        set.addAll(lista);
        set.addAll(listb);
        //lista，liatb取交集：lista为：f,m 即：相同元素
        lista.retainAll(listb);
        System.out.println(lista);
        //合集移除相同元素，即为不同元素
        set.removeAll(lista);
        System.out.println(set);
    }

输出结果：
[f, m]
[p, a, c, h]

12. 异常捕获机制，执行顺序是什么；

 

13. 如果 try 里面有个return ， finally里面 也有个return， 那么会怎么执行呢；

①、不管有没有出现异常，finally块中代码都会执行；

②、当try和catch中有return时，finally仍然会执行；当finally里面没有return语句是，执行try 和finally语句之后最后再执行return

public static int demo2() {
        try {
            return 0;
        }
        finally {
            System.out.println("finally trumps return.");
        }
    }

输出结果
finally trumps return.
0 

Eg：面试题：

public static int demo5() {
        try {
            return printX();
        }
        finally {
            System.out.println("finally trumps return... sort of");
        }
    }

    public static int printX() {
        System.out.println("X");
        return 0;
    }

输出结果：
X
finally trumps return... sort of
0

14. 编程：求100以内的素数

public static void main(String[] args) {
        int i, j;
        for (i = 2; i <= 100; i++) {
            for (j = 2; j < i; j++) {
                if (i % j == 0)
                    break;
            }
            if (j >= i)
                System.out.print(i+"，");
        }
    }

输出结果：
2，3，5，7，11，13，17，19，23，29，31，37，41，43，47，53，59，61，67，71，73，79，83，89，97，

15. java的访问修饰符

public所修饰的成员可以在任何类中都能被访问到

protected所修饰的成员会被位于同一package中的所有类访问到

private是私有的，即只能在当前类中被访问到，它的作用域最小

16. java的重写，重载

在java中有很多的继承，继承下来的有变量、方法。在有一些子类要实现的方法中，方法名、传的参数、返回值跟父类中的方法一样，但具体实现又跟父类的不一样，这时候我们就需要重写父类的方法，就比如我们有一个类叫做Animals，Animals类中有一个叫做Call,然后我们继承Animals又生成了Cat类和Dog类，Cat和Dog也分别有自己特别的叫声；

重载是在一个类中实现的，有多个同名方法，但参数不一样，包括参数类型、参数个数、还可以没有参数，总之每个重载的方法的参数必须不一样。

17. final用法

  1>修饰变量，不能被修改；
  2>修饰方法，方法不能被重写；
  3>修饰类，该类不允许被继承；

18. static用法

1> 静态方法,在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法;
         它们仅能调用其他的static 方法。
         它们只能访问static数据。
         它们不能以任何方式引用this 或super。
2> 静态变量
         在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间;
3> 静态类
        通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。

19. final修饰变量和String有什么区别？

String a = "xxx";  这里a还是可以重新引用别的：a = "yyy"; 即可以改变引用；
但是加上final修饰： final String a = "xxxx"; 这时就不可以：a = "yyy";即：final是让被修饰的变量，不能再引用别的变量

20. String，StringBuffer，StringBuilder区别？

 

21. 多态如何理解

父类的引用指向子类的对象；

多态的前提：

• 要有方法重写
• 要有继承关系
• 要有父类引用子类对象（向上转型）

     格式  父类 对象名 = new 子类（）

     例如   father f = new son（）

22. jdk1.8的新特性

Lambda：简化集合的操作；之前是for循环；

Filter：对list集合根据你的条件进行过滤，得到的结果也是list；

group by：对list集合分组，一般得到的是map；

23. 怎么理解post和get的

查询是get，修改删除增加是post

24. 能说说常用的linux命令

建立文件夹：    mkdir   文件夹名称

删除空文件夹：  rmdir  文件夹名称

强制删除一个文件：   rm  -rf   文件名

查看自己所在目录：  pwd

查看文件列表： ls -l

chmod :修改为只读权限：  读，写，执行，对应的是 r，w，x；

命令参考：https://blog.csdn.net/zyl_842215935/article/details/85121071

25. Java实例化一个对象所分配内存的过程

创建一个对象都在内存中做了什么事情？Person p = new Person();

先将硬盘上指定位置的Person.class文件加载进内存。

执行main方法时，在栈内存中开辟了main方法的空间（压栈-进栈），然后在main方法的栈区分配了一个变量p。

在堆内存中开辟一个实体空间，分配了一个内存首地址值。new

在该实体空间中进行属性的空间分配，并进行了默认初始化。

对空间中的属性进行显示初始化。

进行实体的构造代码块初始化。

调用该实体对应的构造函数，进行构造 函数初始化。

将首地址赋值给p，p变量就引用了该实体。（指向了该对象）

26. Gradle 打包忽略的命令；

gradle在执行build的时候想跳过test task，那么可以使用-x命令

eg: gradle build -x test

27. 查看docker所有container命令；

 docker ps -a

28. 单例模式：

Public class Singleton{
        private Singleton(){}
        private static Singleton instance = new Singleton();
        public static Singleton getInatance(){
            return instance;
        }
}

29. 实现冒泡排序：

public static void main(String[] args) {
        int a[] = {4,1,6,0};
        sort(a);
    }

    public static void sort(int a[]){
        int temp = 0;
        int n = a.length;
        for(int i=0; i<n; i++){
            for (int j=0; j<n-i-1; j++){
                //按从小到大顺序排列
                if(a[j]>a[j+1]){
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        //完成排序后输出
        for(int i=0;i<n;i++){
            System.out.printf(a[i]+" ");
        }
    }

输出结果：
0 1 4 6 

30. git如何解决冲突：

 

31.为什么要用fiddler抓包：

 

32. nginx 是什么？特点？

 

测试部分：

1. 如何在脚本中组织测试用例，按什么模式设计

分为：对象层：如loginpage，存放各页面对象：获取返回页面的元素对象；

           操作层：如loginaction，操作步骤：各元素的事件；

           用例层：如logintest，测试方法，主要调用操作层的具体操作方法；

2. webdriver client的原理是什么？

webdriver是按照server C client的经典设计模式设计的。server端就是remote server，可以是任意的浏览器。当我们的脚本启动浏览器后，该浏览器就是remote server，它的职责就是等待client发送请求并做出相应；client端简单说来就是我们的测试代码，我们测试代码中的一些行为，比如打开浏览器，跳转到特定的url等操作是以http请求的方式发送给被测试浏览器，也就是remote server，remote server接受请求，并执行相应操作，并在response中返回执行状态、返回值等信息；

3. 平日工作是如何设计测试用例，讲解下目前所测产品的一个模块的测试用例设计策略

单元测试；集成测试；功能测试；

包括等价类划分法、边界值分析法、错误推测法、因果图法、判定表驱动法、正交试验设计法、功能图法、场景图法等。

4. App测试和web有什么区别？

web项目，一般都是b/s架构，基于浏览器的；而app则是c/s的，必须要有客户端。

系统测试测试： 的时候就会产生区别了

首先从系统架构来看的话，web测试只要更新了服务器端，客户端就会同步会更新。而且客户端是可以保证每一个用户的客户端完全一致的。但是app端是不能够保证完全一致的，除非用户更新客户端。如果是app下修改了服务端，意味着客户端用户所使用的核心版本都需要进行回归测试一遍。

性能方面：web页面可能只会关注响应时间，而app则还需要关心流量、电量、CPU、GPU、Memory这些了。至于服务端的性能是没区别，这里就不谈。

兼容方面：web是基于浏览器的，所以更倾向于浏览器和电脑硬件，电脑系统的方向的兼容，不过一般还是以浏览器的为主。而浏览器的兼容则是一般是选择不同的浏览器内核进行测试（IE、chrome、Firefox）。app的测试则必须依赖phone或者是pad，不仅要看分辨率，屏幕尺寸，还要看设备系统。系统总的来说也就分为Android和iOS，不过国内的Android的定制系统太多，也是比较容易出现问题的。一般app的兼容测试三种方法，云测试，请团队测试，真机测试。云测试咱们稍后再聊，这里说说真机的选择。首先要选择主流的机型，其次要选择不同的分辨率，尺寸，然后就是不同的操作系统。

5. selenium为什么要设计成c/s，client 和 server 这样的方式；

使用的是JavaScript注入技术与浏览器打交道，需要Selenium RC启动一个Server，将操作Web元素的API调用转化为一段段Javascript，在Selenium内核启动浏览器之后注入这段Javascript。开发过Web应用的人都知道，Javascript可以获取并调用页面的任何元素，自如的进行操作。由此才实现了Selenium的目的：自动化Web操作。这种Javascript注入技术的缺点是速度不理想，而且稳定性大大依赖于Selenium内核对API翻译成的Javascript质量高低。

6. 如何捕获和分析测试数据

接口文档；  接口入参出参；  数据格式交互；

工具；   再看页面展示；

7. 做这个接口测试的流程

接口你可以简单的理解他就是URL，工作原理就会说URL通过get或者post请求像服务器发送一些东西，然后得到一些相应的返回值，本质就是数据的传输与接收。

--由于我们项目前后端调用主要是基于http协议的接口，所以测试接口时主要是通过工具或代码模拟http请求的发送与接收。工具有很多如：postman、jmeter、soupUI、java+httpclient、robotframework+httplibrary等。

--也可以用 接口自动化来实现，就是用代码实现，框架和UI自动化差不多，发送请求用断言来判断。

1> 选择get方式，输入url以及拼接的参数，发送请求；

2> 选择post方式，输入url，然后body里面输入json格式的参数，发送请求；

3> 有时需要加入请求头header，或cookies；

8. Dada驱动，里面数据批量的怎么弄；

1>创建一个注解为DataProvider的方法：里面是存一些数组对象；

2>在测试方法上@Test注解上会添加参数，定义dataProvider=数据提供者的name；

9. appium，client-server设计模式

client端也就是我们 test script是我们的webdriver测试脚本。
Appium在服务端起了一个Server，Appium Server接收web driver client标准rest请求，解析请求内容，
调用对应的框架响应操作；
Appium Server相当于中间作用；在用例和手机UI之间传递；

10. jmeter

线程数量，就相当于模拟的用户数量；
时间间隔，若时间间隔为0的话，就相当于多个用户同时执行一次任务；