面试题（一）

一、线程的生命周期，线程可不可以重复start开启？
在new Thread() 之后线程进入新建状态，线程start方法被调用判断threadStatus是否是新建状态，否则抛出异常
二、字节流和字符流的区别，是否可以相互转换？
节流没有缓冲区，是直接输出的，而字符流是输出到缓冲区的。因此在输出时，字节流不调用colse()方法时，信息已经输出了，而字符流只有在调用close()方法关闭缓冲区时，信息才输出。要想字符流在未关闭时输出信息，则需要手动调用flush()方法。

· 读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。

· 处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。
// Reader Write字符流,
// InputStream OutputStream 字节流
字节流转化为字符流 InputStreamReader，OutputStreamWriter

        Reader in = new BufferedReader(new InputStreamReader(System.in));
        Writer out = new BufferedWriter(new OutputStreamWriter(System.out));

字符通过字节流输出

        String s = "dasd";
        byte[] b = s.getBytes();
        for (byte b1 : b) {
            out.write(b1);
        }

三、常见的设计模式，建造者模式

//实体类
class Product {
    private String title;
    private double price;

    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }

    public String toString() {
        return "title=" + title + ", price=" + price;
    }
}

class Director {
    private Builder builder;
    public Director(Builder builder) {
         this.builder = builder;
    }
    public void construct() {
        builder.buildPartA();
        builder.buildPartB();
    }
}
//构造器接口
interface Builder {
    void buildPartA();
    void buildPartB();
    Product getResult();

}
//构造器实现
class BuilderA implements Builder {
    private Product productA;
    public BuilderA(Product productA) {
        this.productA = productA;
    }

    public void buildPartA() {
        this.productA.setTitle("设计模式");
    }

    public void buildPartB() {
        this.productA.setPrice(28.8);
    }

    public Product getResult() {
        return productA;
    }
}

public class TestBuilder {
    public static void main(String[] args) {
    //构建器
        BuilderA builderA = new BuilderA(new Product());
        Director director = new Director(builderA);
        director.construct();
        System.out.println(builderA.getResult());
    }
}
代码转自https://blog.csdn.net/chenghao_test/article/details/78768908，侵删

//建造者模式
//当类中有多个可选属性的时候，如果选择使用set方法构建，那么中间会生成未构造完成的对象
//适配构造方法，不方便维护需要多个构造方法
public class User {
  private final String firstName; // required
  private final String lastName; // required
  private final int age; // optional
  private final String phone; // optional
  private final String address; // optional
 
  private User(UserBuilder builder) {
    this.firstName = builder.firstName;
    this.lastName = builder.lastName;
    this.age = builder.age;
    this.phone = builder.phone;
    this.address = builder.address;
  }
 
  public String getFirstName() {
    return firstName;
  }
 
  public String getLastName() {
    return lastName;
  }
 
  public int getAge() {
    return age;
  }
 
  public String getPhone() {
    return phone;
  }
 
  public String getAddress() {
    return address;
  }
 
  public static class UserBuilder {
    private final String firstName;
    private final String lastName;
    private int age;
    private String phone;
    private String address;
 
    public UserBuilder(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
    }
 
    public UserBuilder age(int age) {
      this.age = age;
      return this;
    }
 
    public UserBuilder phone(String phone) {
      this.phone = phone;
      return this;
    }
 
    public UserBuilder address(String address) {
      this.address = address;
      return this;
    }
 
    public User build() {
      return new User(this);
    }
  }
}

public User getUser() {
  return new
    User.UserBuilder("Jhon", "Doe")
    .age(30)
    .phone("1234567")
    .address("Fake address 1234")
    .build();
}
代码转至https://www.cnblogs.com/iCanhua/p/8636085.html，侵删

四、mybatis 枚举映射
继承BaseTypeHandler类，然后在xml配置文件中配置，或者是resultmap中使用
xml配置

<typeHandlers>
    <typeHandler handler="枚举类转换器，继承BaseTypeHandler" javaType="枚举类"/>
</typeHandlers>

<result column="status" property="orderStatusEnum"
                typeHandler="com.example.config.EnumOrderStatusHandler"/>

五、maven
dependencies，子项目会直接继承。
dependencyManagement，只是一个声明，子项目如果需要，在dependencies中假如，不需要引入版本号