面向对象 - 拓展知识 - 《编程笔记》

JavaBean
UML类图
MVC设计模式
object类
- equals()方法
- toString方法
单元测试
- 下载和添加jar包
- JUnit简单应用
🌟包装类
- 基本数据类型、包装类和String类间的转化
设计模式
">

JavaBean

public class JavaBean {
    private String name; // 属性一般定义为private
    private int age;
    public JavaBean() {
    }
    public int getAge() {
        return age;
    }
    public void setAge(int a) {
        age = a;
    }
    public String getName() {
        return name;
    }
    public void setName(String n) {
        name = n;
    }
}

UML类图

MVC设计模式

object类

没有提到的方法可能会在其他章节出现！

`equals()`方法

== 的使用。

equals()的使用。

重写equals()方法的原则。

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
    }

@Override
public boolean equals(Object obj) {
    if (this == obj) {
        return true;
    }
    if (obj instanceof Customer) {
        Customer customer = (Customer) obj;
        String firstName = customer.getFirstName();
        String lastName = customer.getLastName();
        if (firstName.equals(this.firstName) && lastName.equals(this.lastName)) {
            return true;
        }
    }
    return false;
}

*一般都使用idea自动生成的重写equals方法。

`toString`方法

单元测试

下载和添加jar包

首先需要去下载JUnit的jar包以及一个依赖包hamcrest.core（junit:4.13-beta-1 hamcrest.core:1.3.0.1）

需要注意的是hamcrest.core包不能使用2.1版本的，因为4.13版本的JUnit和它不兼容，会抛出ClassNotFoundException异常。推荐使用 junit-4.13.jar 和 hamcrest-core-1.3.jar ，不然会有意想不到的麻烦。
另外，上面的两个地址特别慢，基本下载不下来，这里给出另外的一个第三方网站 https://jar-download.com/

更简单的做法是在IDEA中直接输入@Test，然后会有提示下载和导入的，但是需要注意看清楚导入的包名为org.junit.Test。

在Intellij IDEA项目中添加jar包

首先需要在IDEA中添加刚才下载好的包：
拓展知识 - 图12
记得勾选Export选项。

下载插件并进行设置

然后需要下载一个名为JUnitGeneratorV2.0的插件：
拓展知识 - 图13

然后对其进行设置：
拓展知识 - 图14

JUnit简单应用

创建Java类，进行单元测试。
- 此时的Java类要求：① 此类是public的 ②此类提供公共的无参的构造器。
此类中声明单元测试方法。
- 此时的单元测试方法要求：方法的权限是public，没有返回值，没有形参。
此单元测试方法上需要声明注解：@Test，并在单元测试类中导入：import org.junit.Test;

声明好单元测试方法以后，就可以在方法体内测试相关的代码。

int num = 1;
@Test
public void testEquals(){
 String s1 = "mm";
 String s2 = "mm";
 System.out.println(s1.equals(s2));

 System.out.println(num);
}

🌟包装类

基本数据类型、包装类和String类间的转化

基本数据类型 —->包装类
- 调用包装类的构造器 ```java Integer int1 = new Integer(123); Integer int2 = new Integer(“123”);

Float f1 = new Float(12.3f); Float f2 = new Float(“12.3”);

Boolean b1 = new Boolean(true); Boolean b2 = new Boolean(“TrUe”);//true Boolean b3 = new Boolean(“true123”);//false

> 面试题：Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[]，保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在-128~127范围内时，可以直接使用数组中的元素，不用再去new了。目的是提高效率。


- 包装类--->基本数据类型
   - 调用包装类Xxx的xxxValue()
```java
Integer in1 = new Integer(12);        
int i1 = in1.intValue();
System.out.println(i1 + 1);


Float f1 = new Float(12.3);
float f2 = f1.floatValue();
System.out.println(f2 + 1);

JDK 5.0 新特性：自动装箱与自动拆箱（类型必须匹配）

//自动装箱：基本数据类型 --->包装类
int num2 = 10;
Integer in1 = num2;//自动装箱

boolean b1 = true;
Boolean b2 = b1;//自动装箱

//自动拆箱：包装类--->基本数据类型
System.out.println(in1.toString());

int num3 = in1;//自动拆箱

基本数据类型、包装类—->String类型
- 调用String重载的valueOf(Xxx xxx) ```java int num1 = 10; //方式1：连接运算 String str1 = num1 + “”; //方式2：调用String的valueOf(Xxx xxx) float f1 = 12.3f; String str2 = String.valueOf(f1);//“12.3”

Double d1 = new Double(12.4); String str3 = String.valueOf(d1); System.out.println(str2); System.out.println(str3);//“12.4”


- String类型 --->基本数据类型、包装类
   - 调用包装类的parseXxx(String s)
```java
String str1 = "123";
//错误的情况：
//        int num1 = (int)str1;
//        Integer in1 = (Integer)str1;
//可能会报NumberFormatException
int num2 = Integer.parseInt(str1);
System.out.println(num2 + 1);

String str2 = "true1";
boolean b1 = Boolean.parseBoolean(str2);
System.out.println(b1);

设计模式

单例设计模式

饿汉式

class Bank{

    //1.私有化类的构造器
    private Bank(){

    }

    //2.内部创建类的对象
    //4.要求此对象也必须声明为静态的
    private static Bank instance = new Bank();

    //3.提供公共的静态的方法，返回类的对象
    public static Bank getInstance(){
        return instance;
    }
}

懒汉式

class Order{

    //1.私有化类的构造器
    private Order(){

    }

    //2.声明当前类对象，没有初始化
    //4.此对象也必须声明为static的
    private static Order instance = null;

    //3.声明public、static的返回当前类对象的方法
    public static Order getInstance(){ 

        if(instance == null){

            instance = new Order();

        }
        return instance;
    }

}

//一、同步代码块
public static Order getInstance(){ 

    //方式一：效率稍差
    synchronized(Order.class){
        if(instance == null){

            instance = new Order();
        }
        return instance;

    }


    //方式二：效率高
    if(instance == null){
        synchronized(Order.class){
            if(instance == null){

                instance = new Order();
            }
        }
    }
    return instance;



}

//二、同步方法
public static synchronied Order getInstance(){ 

    if(instance == null){

        instance = new Order();

    }
    return instance;
}

记法：啥时候啥时候造（懒汉式），一上来就造好（饿汉式）。

饿汉式：

坏处：对象加载时间过长。
好处：饿汉式是线程安全的。

懒汉式：

好处：延迟对象的创建。
目前的写法坏处：线程不安全。—->到多线程内容时，再修改。

模板方法设计模式

/*
 * 抽象类的应用：模板方法的设计模式
 * 
 */
public class TemplateTest {
    public static void main(String[] args) {

        SubTemplate t = new SubTemplate();

        t.spendTime();
    }
}

abstract class Template{

    //计算某段代码执行所需要花费的时间
    public void spendTime(){

        long start = System.currentTimeMillis();

        this.code();//不确定的部分、易变的部分

        long end = System.currentTimeMillis();

        System.out.println("花费的时间为：" + (end - start));

    }

    public abstract void code();


}

class SubTemplate extends Template{

    @Override
    public void code() {

        for(int i = 2;i <= 1000;i++){
            boolean isFlag = true;
            for(int j = 2;j <= Math.sqrt(i);j++){

                if(i % j == 0){
                    isFlag = false;
                    break;
                }
            }
            if(isFlag){
                System.out.println(i);
            }
        }

    }

}

//抽象类的应用：模板方法的设计模式
public class TemplateMethodTest {

    public static void main(String[] args) {
        BankTemplateMethod btm = new DrawMoney();
        btm.process();

        BankTemplateMethod btm2 = new ManageMoney();
        btm2.process();
    }
}
abstract class BankTemplateMethod {
    // 具体方法
    public void takeNumber() {
        System.out.println("取号排队");
    }

    public abstract void transact(); // 办理具体的业务 //钩子方法

    public void evaluate() {
        System.out.println("反馈评分");
    }

    // 模板方法，把基本操作组合到一起，子类一般不能重写
    public final void process() {
        this.takeNumber();

        this.transact();// 像个钩子，具体执行时，挂哪个子类，就执行哪个子类的实现代码

        this.evaluate();
    }
}

class DrawMoney extends BankTemplateMethod {
    public void transact() {
        System.out.println("我要取款！！！");
    }
}

class ManageMoney extends BankTemplateMethod {
    public void transact() {
        System.out.println("我要理财！我这里有2000万美元!!");
    }
}

代理模式

public class NetWorkTest {
    public static void main(String[] args) {
        Server server = new Server();
//        server.browse();
        ProxyServer proxyServer = new ProxyServer(server);

        proxyServer.browse();

    }
}

interface NetWork{

    public void browse();

}

//被代理类
class Server implements NetWork{

    @Override
    public void browse() {
        System.out.println("真实的服务器访问网络");
    }

}
//代理类
class ProxyServer implements NetWork{

    private NetWork work;

    public ProxyServer(NetWork work){
        this.work = work;
    }


    public void check(){
        System.out.println("联网之前的检查工作");
    }

    @Override
    public void browse() {
        check();

        work.browse();    
    }    
}

工厂模式

拓展：工厂设计模式.pdf

拓展知识