Fatal编程技术网
  • java/
  • java中的帮助对象是什么？

java中的帮助对象是什么？

java

java中的帮助对象是什么？,java,Java,我遇到过几次叫做帮助对象的东西。。。有人能详细说明这些帮助对象是什么，我们为什么需要它们吗？这些对象“位于”代码主体的一侧，并为对象做一些工作。它们“帮助”对象完成其工作 例如，许多人有一个更接近的辅助对象。这将使用各种可关闭的对象，例如java.sql.Statement、java.sql.Connection等，并将关闭该对象，并忽略由此产生的任何错误。这往往是因为，如果你在关闭一个对象时出错，你无论如何也无能为力，所以人们会忽略它 而不是有这个样板： try { connection.

我遇到过几次叫做帮助对象的东西。。。有人能详细说明这些帮助对象是什么，我们为什么需要它们吗？

这些对象“位于”代码主体的一侧，并为对象做一些工作。它们“帮助”对象完成其工作

例如，许多人有一个更接近的辅助对象。这将使用各种可关闭的对象，例如java.sql.Statement、java.sql.Connection等，并将关闭该对象，并忽略由此产生的任何错误。这往往是因为，如果你在关闭一个对象时出错，你无论如何也无能为力，所以人们会忽略它

而不是有这个样板：

try {
  connection.close();
} catch (SQLException e) {
  // just ignore… what can you do when you can't close the connection?
   log.warn("couldn't close connection", e);
}
分散在代码库中，他们只需调用：

Closer.close(connection);
相反。例如，看看番石榴

一些对几个类通用的操作可以移动到辅助类，然后通过对象组合使用这些辅助类：

public class OrderService {
    private PriceHelper priceHelper = new PriceHelper();

    public double calculateOrderPrice(order) {
        double price = 0;
        for (Item item : order.getItems()) {
            double += priceHelper.calculatePrice(item.getProduct());
        }
    }
}

public class ProductService {
    private PriceHelper priceHelper = new PriceHelper();

    public double getProductPrice(Product product) {
        return priceHelper.calculatePrice(product);
    }
}
可以通过多种方式使用帮助器类：

  • 直接实例化它们（如上所述）
  • 通过依赖注入
  • 通过使其方法
    静态
    并以静态方式访问它们，如
    IOUtils.closequilly（inputStream）
    关闭
    inputStream
    而不抛出异常
  • 至少我的习惯是只使用静态方法命名类，而不使用依赖项
    XUtils
    ，而使用依赖项/需要由DI容器管理的类
    XHelper
（上面的例子只是一个例子——不应该从领域驱动设计的角度来讨论）

一个“助手”方法通常是一种使事情变得更简单的方法，不管它是什么。有时，它们被用来使事情更具可读性/组织更清晰（有些人可能认为这一点，但这最终是非常主观的）：

其中，每个“助手方法”本身都相当复杂。。。这个概念变得非常清晰和简单

助手方法的另一个很好的用途是跨许多不同的类提供公共功能。最好的例子是
Math
类，它包含大量静态辅助方法，可以帮助您计算数字的对数、指数。。。等等

你把什么是辅助方法和什么是常规方法划清界限，这是非常主观的，但这就是它的要点。这里的其他答案也不错。在我看来，

< P>辅助类类似于C++中类外声明的正常函数。例如，如果许多类需要全局常量，则可以定义一个包含最终静态常量变量的帮助器类。

import java.text.simpleDataFormat；

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class Helpers {
public static String getDate() {
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy");
        return dateFormat.format(new Date());
    }

    public static boolean isTimeABeforeTimeB(String timeA, String timeB) {
        try {
            SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy hh:mm aa");
            Date dA = dateFormat.parse(timeA);
            Date dB = dateFormat.parse(timeB);
            if (dA.getTime() < dB.getTime()) {
                return true;
            } else {
                return false;
            }
        } catch (Exception e) {
            //
        }
        return false;
    }

    public static String getDateAndTimeInput(String prompt) {
        Scanner input = new Scanner(System.in);
        String ans;
        SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy hh:mm aa");
        dateFormat.setLenient(false);
        boolean dateValid;
        do {
            System.out.print(prompt);
            ans = input.nextLine();
            ans = ans.trim();
            dateValid = true;
            try {
                Date d = dateFormat.parse(ans);
            } catch (Exception e) {
                dateValid = false;
            }
        } while (!dateValid);
        return ans;
    }


    public static String getStringInput(String prompt) {
        Scanner input = new Scanner(System.in);
        String ans;

        do {
            System.out.print(prompt);
            ans = input.nextLine();
            ans = ans.trim();
        } while (ans.length() == 0);
        return ans;
    }

    public static double getDoubleInput(String prompt) {
        Scanner input = new Scanner(System.in);
        double ans = 0;
        boolean inputValid;
        do {
            System.out.print(prompt);
            String s = input.nextLine();
            //Convert string input to integer
            try {
                ans = Double.parseDouble(s);
                inputValid = true;
            } catch (Exception e) {
                 inputValid = false;
            }
        } while (!inputValid);
        return ans;
    }

    public static int getIntegerInput(String prompt) {
        Scanner input = new Scanner(System.in);
        int ans = 0;
        boolean inputValid;
        do {
            System.out.print(prompt);
            String s = input.nextLine();
            // Convert string input to integer
            try {
                ans = Integer.parseInt(s);
                inputValid = true;
            } catch (Exception e) {
                inputValid = false;
            }
        } while (!inputValid);
        return ans;
    }

    public static int getIntegerInput(String prompt, int lowerBound, int upperBound) {
        Scanner input = new Scanner(System.in);
        int ans = 0;
        boolean inputValid;
        do {
            System.out.print(prompt);
            String s = input.nextLine();
            // Convert string input to integer
            try {
                ans = Integer.parseInt(s);
                if (ans >= lowerBound && ans <= upperBound) {
                    inputValid = true;
                } else {
                     inputValid = false;
                }
            } catch (Exception e) {
                inputValid = false;
            }
       } while (!inputValid);
       return ans;
   }
}


导入java.util.Date；
导入java.util.Scanner；
公营班级助理{
公共静态字符串getDate（）{
SimpleDataFormat dateFormat=新的SimpleDataFormat（“dd-MM-yyyy”）；
return dateFormat.format（new Date（））；
}
公共静态布尔值isTimeABeforeTimeB（字符串timeA，字符串timeB）{
试一试{
SimpleDataFormat dateFormat=新的SimpleDataFormat（“dd-MM-yyyy-hh:MM-aa”）；
dateda=dateFormat.parse（timeA）；
datedb=dateFormat.parse（timeB）；
if（dA.getTime（）如果（ans>=lowerBound&&ans，您可以将帮助器类视为工具箱，其他类可以使用它来

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class Helpers {
public static String getDate() {
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy");
        return dateFormat.format(new Date());
    }

    public static boolean isTimeABeforeTimeB(String timeA, String timeB) {
        try {
            SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy hh:mm aa");
            Date dA = dateFormat.parse(timeA);
            Date dB = dateFormat.parse(timeB);
            if (dA.getTime() < dB.getTime()) {
                return true;
            } else {
                return false;
            }
        } catch (Exception e) {
            //
        }
        return false;
    }

    public static String getDateAndTimeInput(String prompt) {
        Scanner input = new Scanner(System.in);
        String ans;
        SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy hh:mm aa");
        dateFormat.setLenient(false);
        boolean dateValid;
        do {
            System.out.print(prompt);
            ans = input.nextLine();
            ans = ans.trim();
            dateValid = true;
            try {
                Date d = dateFormat.parse(ans);
            } catch (Exception e) {
                dateValid = false;
            }
        } while (!dateValid);
        return ans;
    }


    public static String getStringInput(String prompt) {
        Scanner input = new Scanner(System.in);
        String ans;

        do {
            System.out.print(prompt);
            ans = input.nextLine();
            ans = ans.trim();
        } while (ans.length() == 0);
        return ans;
    }

    public static double getDoubleInput(String prompt) {
        Scanner input = new Scanner(System.in);
        double ans = 0;
        boolean inputValid;
        do {
            System.out.print(prompt);
            String s = input.nextLine();
            //Convert string input to integer
            try {
                ans = Double.parseDouble(s);
                inputValid = true;
            } catch (Exception e) {
                 inputValid = false;
            }
        } while (!inputValid);
        return ans;
    }

    public static int getIntegerInput(String prompt) {
        Scanner input = new Scanner(System.in);
        int ans = 0;
        boolean inputValid;
        do {
            System.out.print(prompt);
            String s = input.nextLine();
            // Convert string input to integer
            try {
                ans = Integer.parseInt(s);
                inputValid = true;
            } catch (Exception e) {
                inputValid = false;
            }
        } while (!inputValid);
        return ans;
    }

    public static int getIntegerInput(String prompt, int lowerBound, int upperBound) {
        Scanner input = new Scanner(System.in);
        int ans = 0;
        boolean inputValid;
        do {
            System.out.print(prompt);
            String s = input.nextLine();
            // Convert string input to integer
            try {
                ans = Integer.parseInt(s);
                if (ans >= lowerBound && ans <= upperBound) {
                    inputValid = true;
                } else {
                     inputValid = false;
                }
            } catch (Exception e) {
                inputValid = false;
            }
       } while (!inputValid);
       return ans;
   }
}



public final class HelperClass{

       private HelperClass(){
       }

       public static boolean isPositive(int number) {

             if (number >= 0) 
                    return true;
             else
                    return false;
       }
}



 HelperClass.isPositive(5);