Java理论

构造方法

就是类构造对象时调用的方法，主要用来实例化对象。构造方法分为无参构造方法、有参构造方法。
构造方法的名字必须与定义他的类名完全相同，没有返回类型，甚至连void也没有

重写方法

在Java程序中，类的继承关系可以产生一个子类，子类继承父类，它具备了父类所有的特征，继承了父类所有的方法和变量。
子类可以定义新的特征，当子类需要修改父类的一些方法进行扩展，增大功能，程序设计者
常常把这样的一种操作方法称为重写，也叫称为覆写或覆盖。
使用“super.方法名(参数列表)”的形式调用。

重写方法与被重写方法同名，参数列表也必须相同。
重写方法的返回值类型必须和被重写方法的返回值类型相同或是其子类。
重写方法不能缩小被重写方法的访问权限。

如果一个软件缺陷被拒绝，不可能的原因是（很小的缺陷）

web功能测试中页面内容的测试重点考虑的是页面内容的正确性、准确性、相关性。没有简洁性

对文本框测试时我们不需要考虑颜色

正交表数量有限，可选性比较有限

BugFree（测试管理工具）不具有需求管理的功能

瀑布模型是开发过程模型不是测试过程模型

创建二维数组时，第一个中括号的长度不能省略
new int[3][2]{{1,2},{1,5},{3,9}};这种形式创建二维组数组时，中括号不需要写长度

方法重载

方法名相同，参数列表不同
所谓方法重载是指在一个类中，多个方法的方法名相同，但是参数列表不同。参数列表不同指的是参数个数、参数类型或者参数的顺序不同。
方法重载需要满足以下几个条件：
在同一个类中
方法的名称相同
参数列表不同

String属于引用数据类型，Double是double的封装类

float [][] f1 = {{1.2f,2.3f},{4.5f,5.6f}} ;

             Object oo = f1 ;

              f1[1] = oo ;
              报错！一维数组不能储存二维数组

继承

`

super关键字调用父类的构造方法
子类可以继承父类中访问权限修饰符为public和protected的属性和方法
子类可以继承父类中用默认访问权限修饰的属性和方法，但子类和父类必须在同一个包中
子类无法继承父类中访问权限修饰符为private的属性和方法
子类无法继承父类的构造方法

子类构造方法中使用super调用父类的构造方法必须放在构造方法第一行
在一个类中，this关键字代表这个类对象本身

try…catch…finally语句中的返回值锁定问题
finally语句块，保证无论是否发生异常，finally语句块中的代码总被执行

ArrayList集合的创建方式
List< String> lists = new ArrayList< String >();

JUnit4中常用注解没有@Round

抽象类

abstract

抽象方法必须包含在抽象类中
抽象类不允许被实例化，只能被继承。也就是说，你不能 new 一个抽象类的对象出来
抽象类可以包含属性和方法。方法既可以包含代码实现，也可以不包含代码实现。不包含代码实现的方法叫作抽象方法。
子类继承抽象类，必须实现抽象类中的所有抽象方法。

抽象类实际上就是类，只不过是一种特殊的类，这种类不能被实例化为对象，只能被子类继承。

如果一个方法里没有实际工作，也就是什么都不用写 .那么我们就可以把这个方法设计成抽象方法，而包含抽象方法的类，顾名思义 ：抽象类。
那么抽象类和普通类的区别是什么呢？
抽象类声明时需要abstract 关键字来定义 ，而普通类则可以是public private等。
抽象类里的抽象方法里不能有方法的主体，只能是抽象方法的声明，而普通类里的方法里可以有主体。
抽象类是不能被实例化的，也就是不能用new调用构造函数创建对象，而普通类可以通过new关键字进行实例化。
抽象类的访问权限限于public和protected，因为抽象类方法是需要继承之后让子类去实现的，private修饰的方法不能被重写，抽象方法的目的就是为了继承以后再子类里重写。而普通类的访问权限没有限制，都可以修饰。
抽象类被继承时，子类必须实现它的所有方法，如果子类没有实现父类的抽象方法，则必须将子类也定义成抽象类。而普通类被继承时，不需要实现它的所有方法。

抽象类中可以存在非抽象方法
抽象类使用abstract修饰
抽象方法没有方法体
抽象类不能被实例化

接口

interface
public interface 方法名(){
全部是抽象方法；
全部是final属性；
}
继承： isa …是一个…
接口：has a …有…功能

implements
实现类（子类） 实现（继承） 接口（父类）

    接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；
接口不能包含属性（也就是成员变量）。
接口只能声明方法，方法不能包含代码实现。
类实现接口的时候，必须实现接口中声明的所有方法。

   2> 就像铁门木门都是门（抽象类），你想要个门我给不了（不能实例化），但我可以给你个具体的铁门或木门（多态）；而且只能是门，你不能说它是窗（单继承）；一个门可以有锁（接口）也可以有门铃（多实现）。门（抽象类）定义了你是什么，接口（锁）规定了你能做什么（一个接口最好只能做一件事，你不能要求锁也能发出声音吧（接口污染））。
抽象类和接口有什么区别？
简单来说，
接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的.
另外，实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。
还有，接口可以实现多重继承，而一个类只能继承一个超类，但可以通过继承多个接口实现多重继承

多态

父类  对象名= new 子类就是多态
多态是同一个行为具有不同表现形式或形态的能力，多态性是对象多种表现形式和体现。
多态的前提：
子父类的继承关系或子类实现父类接口
必须有方法的重写
父类引用指向子类对象
多态成员变量：变量不像方法有重写，所以直接执行父类，父类没有这个变量则报错
多态成员方法：方法可重写，执行子类方法，父类没有这个方法则报错
多态静态方法：运行的是父类里面的静态方法。如果父类没有静态方法，编译报错。

（1）、子类重写父类的方法。使子类具有不同的方法实现。

（2）、把父类类型作为参数类型，该父类及其子类对象作为参数转入。

（3）、运行时，根据实际创建的对象类型动态决定使用那个方法。

在运行时，java虚拟机会根据实际创建的对象类型决定使用那个方法。一般将这称为动态绑定。   

原文链接：https://blog.csdn.net/baidu_33714003/article/details/52290627


当父类的方法，子类调用出现歧义并且为了代码的方便时，使用多态。

多态是同一个行为具有不同表现形式或形态的能力，多态性是对象多种表现形式和体现。

多态的前提：
子父类的继承关系或子类实现父类接口
必须有方法的重写
父类引用指向子类对象

多态成员变量：变量不像方法有重写，所以直接执行父类，父类没有这个变量则报错
多态成员方法：方法可重写，执行子类方法，父类没有这个方法则报错

多态一般使用步骤：
1.写出父类方法
2.重写父类方法
3.运行，运行类中 父类 引用对象名 = new 子类称为使用多态


多态的实现：
1.方法重写
2.方法重载
3.使用父类作为方法的传值
4.使用父类作为方法的返回值（public static 父类名 名字（int 名字））

方法可重写，执行子类方法，父类没有这个方法则报错，如果还是想调用子类方法，需要强转，用if辅助
1.从小转大，自动转换
2.从大到小，强制转换
if（对象   instanceof  类型）判断对象是不是该类型

内部类

成员内部类

在类的内部定义类，称为内部类。成员内部类中，可以访问外部类的所有成员，变量和方法。外部类同样可以访问内部类。
外部类名.内部类名 变量名  =  new 外部类名（）.new 内部类名（）；

局部内部类
局部内部类可以访问外部类所有成员，局部内部类的成员只能由创建方法访问

异常

try…catch(Exception e) finally throws（抛给上级） throw

try{
           
           如果正常执行这里
           
       }catch (Exception e){
           
           如果不正常执行这里(异常)
           
       }
    }

异常分为运行时异常 和 检查异常

处理异常：try…catch 或者 throws

如果try中的代码的确发生了异常，则不再执行发生异常后的代码，跳到catch中执行
finally 无论异常或正常都会执行的代码 即使有return，除非虚拟机关闭（System.exit（））；

e.getMassage() :捕获出错信息

throw 一般和自定义异常一起使用
如何编写自定义异常：
类继承Exception类

public class MyException extends Exception{//自定义异常
    public MyException(String message){
        super(message);
    }
}

如果某异常类继承自 RuntimeException（运行时异常），则该异常可以不显式的使用“try…catch…”或throws进行处理。
异常的基类是 Throwable。
IOException（输入输出异常）
IllegalAccessException 是访问权限不足构成的异常；ClassCastException 是类型转换异常；InputMismatchException 通常是使用 Scanner 输入数据时发生的异常

数组

数组元素的添加

快速查看数组中元素：System.out.println（Arrays.toString（数组名））
1.创建新数组，长度增加
2.for循环把旧数组值赋给新数组
3.在数组最后加入新元素
4.旧数组 = 新数组

数组元素的删除

1.同上，数组长度减少，需要注意 for中 if（i<要删除的元素位置，则新数组[i] = 旧数组[i]）else（新数组[i] = 旧数组[i+1]）
2.新数组替换旧数组 ： 旧数组 = 新数组

数组元素的插入

1.创建新数组，长度+1
2.for循环把旧数组值赋给新数组，需要注意 for中 if（i<要插入的元素位置，则新数组[i] = 旧数组[i]）else（新数组[i+1] = 旧数组[i]）
3.赋值插入数值：新数组[插入位置] = 插入的数值
4.新数组替换旧数组 ： 旧数组 = 新数组

package com.com;

public class Text {
    public static void main(String[] args) {
        //创建可变数组
        Myarrays my = new Myarrays();
        System.out.println(my.size());
        //增加元素
        my.add(33);
        my.add(66);
        my.add(99);
        my.add(129);
        //查看数组长度
        System.out.println(my.size());
        //查看数组元素
        my.show();
        //删除数组元素
        my.delete(1);
        my.show();
        //插入数组元素
        my.insert(1,69);
        my.show();
    }
}

package com.com;

import java.util.Arrays;

public class Myarrays {
    private int[] elements;
    public Myarrays(){
        elements = new int[0];
    }
    //获取数组长度的方法
    public int size(){
        return elements.length;
    }
    //往数组末尾添加元素
    public void add(int element){
        int[] newarray = new int[elements.length+1];
        for(int i=0;i<elements.length;i++){
            newarray[i] = elements[i];
        }
        newarray[elements.length] = element;
        elements = newarray;
    }
    //查看数组所有元素
    public void show(){
        System.out.println(Arrays.toString(elements));
    }
    //删除数组元素
    public void delete(int index){
        //判断下标是否越界
        if(index<0 || index > elements.length-1){
            throw new RuntimeException("下标越界");
        }
        int[] newArray = new int[elements.length-1];
        for(int i=0;i<newArray.length;i++){//一定是新数组
            if(i<index){
                newArray[i]=elements[i];
            }else{
                newArray[i]=elements[i+1];
            }
        }
        elements = newArray;
    }
    //插入元素到指定位置
    public void insert(int index,int element){
        int[] newArray = new int[elements.length+1];
        for(int i=0;i<elements.length;i++){
            if(i<index){
                newArray[i] = elements[i];
            }else{
                newArray[i+1] = elements[i];
            }
        }
        newArray[index] = element;
        elements = newArray;
    }
}

栈和队列

有手就行

单链表

1.结点内容
public class Node{}
int data；
2.下一个结点
Node next；
this.data = data；

集合框架

集合 Collection是个接口
集合实现对象增删改查很方便

Collection的方法

package coll;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Colll {
    public static void main(String[] args) {
        Collection coll = new ArrayList();
        //增加 如果要加对象，改变toString即可
        coll.add("a");
        coll.add("b");
        coll.add("c");
        System.out.println(coll);
        //清除集合所有元素
        coll.clear();
        System.out.println(coll);
        //求集合中真实数据的个数
        System.out.println(coll.size());
        //addall 将集合添加到另一个集合
        Collection col2 = new ArrayList();
        col2.add("a");
        col2.add("b");
        col2.add("c");
        coll.addAll(col2);
        System.out.println(coll);
        //判断集合是否包含了指定的对象（元素）
        System.out.println(coll.contains("a"));
        //判断集合是否包含另一个集合
        System.out.println(coll.containsAll(col2));
        //判断集合是否为空
        System.out.println("coll是否为空："+coll.isEmpty());

        //iterator():迭代器
        System.out.println("col2:"+col2);
        Iterator iter = col2.iterator();
        //iter.hasNext():判断集合是否有下一个元素
        while (iter.hasNext()){
            String result = (String)iter.next();//取出下一个元素
            System.out.println(result);
        }
        //remove:删除指定对象
        col2.remove("b");
        System.out.println(col2);
        //removeall:删除指定集合
        coll.removeAll(col2);
        System.out.println(coll);
        //retainAll(),从一个集合之中 只保留另一个集合的元素
        //size：获取当前集合中元素个数
        //toArray（）：将集合转换为数组
        Object[] col1Array = coll.toArray();
    }
}

ArrayList（动态数组）的方法

package coll;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

public class Colll {
    public static void main(String[] args) {
        List list1 = new ArrayList();
        //List是有序的
        list1.add("a");
        list1.add("b");
        list1.add("c");
        System.out.println(list1);

        //list的add重载方法，可以将增加的元素指定的某个位置 addAll 同理
        list1.add(1,"e");
        System.out.println(list1);
        //get：返回指定位置的元素
        System.out.println(list1.get(1));
        //indexOf:获取某个元素在集合的位置(如果出现重复，从前往后) lastIndexOf（从后往前）
        int index = list1.indexOf("e");
        System.out.println(index);

        //remove:删除第一次出现的对象，也可以删除指定索引位置的对象
        //collection有可能无序，所以不可以删除指定位置对象

        //set:将指定位置的元素修改为新的对象
        list1.set(3,"zhong");
        System.out.println(list1);
        //类似subString，截取集合，左闭右开
        List sublist1 = list1.subList(2,4);
        System.out.println(sublist1);
    }
}

1

2

1

2

2

1

2

2

1

2

1

2

2

1

2

2

1

2

1

2

2

1

2

2

1

2