面向对象-常用类

作者: 我叫吴智斌 | 来源:发表于2018-11-26 17:32 被阅读9次

常用类:系统帮我们封装好很多功能在类里面,可以直接使用的方法
常用类一般不允许你创建对象,都私有化了构造器

Main方法参数

        当点击运行时,JVM会自动调用main方法
        public:被JVM调用的方法,它的权限要足够的大
        static:被JVM调用的方法,不需要创建对象,直接使用类名调用
        void:被JVM调用的方法,不需要有任何的返回值
        main:方法的名称,只能这样写,不然JVM识别不了
        String[] args: 以前是指键盘录入.

        public static void main(String[] args){

        }

for循环和foreach的区别:
要不要是使用脚标,使用脚标用for循环;不需要使用脚标的情况用foreach

Scanner输入键盘信息

        Scanner sc = new Scanner(System.in);
        等待从键盘录入一个数
        int i = sc.nextInt();
        double d = sc.nextDouble();
        
        System.out.println(i);
        System.out.println(d);
        System.out.println("--------");
        
        从键盘录入一个字符串
        String s = sc.nextLine();
        System.out.println(s);

数组的拷贝

        arraycopy
        java.lang是不需要导入的
        src - 源数组。
        srcPos - 源数组中的起始位置。
        dest - 目标数组。
        destPos - 目标数据中的起始位置。
        length - 要复制的数组元素的数量。 
    public static void main(String[] args) {
        
        arraycopy
        java.lang是不需要导入的
        src - 源数组。
        srcPos - 源数组中的起始位置。
        dest - 目标数组。
        destPos - 目标数据中的起始位置。
        length - 要复制的数组元素的数量。 
        
        int[] src = {1,2,3,4,5,6};
        int[] desc = new int[10];//开辟了10块空间
        
        System.arraycopy(src, 2, desc,0, 4);
        
        System.out.println(Arrays.toString(src));//[1, 2, 3, 4, 5, 6]
        System.out.println(Arrays.toString(desc));//[3, 4, 5, 6, 0, 0, 0, 0, 0, 0]
        
    }

要知道它的在哪个类当中,arraycopy存在System这个类当中
一定得要知道什么类当中有什么方法

计算代码耗时
System.currentTimeMills();

    public static void main(String[] args) {

        获取当前时间的毫秒值 1 秒 = 1000毫秒
        从1970开始到现在的毫秒数
        做测试一个执行的时间

        long time1 = System.currentTimeMillis();
        // System.out.println(time);

        for (int i = 0; i < 1000000; i++) {
            System.out.println(i);
        }

        long time2 = System.currentTimeMillis();
        
        long time3 = time2 - time1;
        System.out.println("总耗时"+time3+"毫秒");
    }

gc方法与对象销毁

public class SystemMethod {
    
    只有当一个对象被回收时,才会自动调用的一个方法
    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("我被回收了");
    }
    
    public static void main(String[] args) {
        
        终止当前正在运行的Java虚拟机
        应用于图形化界面
        System.exit(0);//0 正常退出  负数异常退出
        

        立即运行垃圾回收器。一个对象并不是立马被回收的
        new SystemMethod();
        new SystemMethod();
        System.gc();      一般都不会主动去调用该方法

    }

}

Math数学类

    public static void main(String[] args) {

        System.out.println(Math.PI);// π

        求两个数的最大值
        int res = Math.max(20, 10);
        System.out.println(res);

        求两个数的最小值
        Math.min(5, 6);

        返回一个[0,1) 的随机数
        System.out.println(Math.random());

        0-100的随机数,强制转换成int类型,向下取整
        int res2 = (int) (Math.random() * 100);
        System.out.println(res2);

        开平方根
        double res3 = Math.sqrt(4);
        System.out.println(res3);
    }

大精度小数

java.math
类 BigDecimal

    public static void main(String[] args) {
        System.out.println("0.09+0.01   =   " + (0.09 + 0.01));//0.09999999999999999
        System.out.println("-----------");
        
        //表示金钱都是用BigDecimal类型
        BigDecimal num1 = new BigDecimal(0.09);
        BigDecimal num2 = new BigDecimal(0.01);
        
        System.err.println(num1.add(num2));//还未正确
        //0.09999999999999999687749774324174723005853593349456787109375

        下面才是正确的
        BigDecimal num1 = new BigDecimal("0.09");
        BigDecimal num2 = new BigDecimal("0.01");
    }
float,double 表示小数   不能表示精确的小数

java.math
类 BigInteger
大整形

        // BigInteger
        System.out.println(Long.MAX_VALUE);

        BigInteger b= new BigInteger("100000"+Long.MAX_VALUE);
        System.out.println(b);

总结复习

字符串本质及分类
什么是字符串?
把多个字符串连在一起

字符串分类
1.可变字符串(StringBuffer,StringBuilder): 定义好之后,还可以进行修改, 修改是,不会创建新的内存地址 (内存地址不可变)
2.不可变字符串(String): 定义好了,就不能再去改变, 在内存当中不能再去修改了,修改就会创建新的内存地址

        字符串的本质
        其实它是一个 chat[ ] 类型的数组
        private final char value[ ];

String, StringBuffer, StringBuilder 都实现了:CharSequence接口 ,遵守了规范可以使用里面的方法

字符串的两种比较

        不可变字符串(String)
        String str = "ABC";  在内存当中不能再去修改了,修改就会创建新的地址
        str = "cd";

字符串是放到方法区常量池当中,这里还没讲常量池,先放到堆当中

String创建 
        1.直接赋值 String str = "ABC";
        2.通过构造器来创建  String str = new String("ABC");

字符串对象为空

        1.表示引用为空  String str = null;  还没初始化,没有分配内存空间
        2.表示空字符串  String str = " ";    已经创建了对象,已经分配了内存,内容为空

字符串的比较
比较两个字符串相不相等

== 比较两个内存地址是否相等

        String str = "ABC";

        String str2 = new String("ABC");

        if (str == str2) {  比的是对象的地址
            System.out.println("相等");
        }else {
            System.out.println("不相等");
        } 不相等

使用在object中的一个方法 equals 和 == 相同

        因为 String 类覆盖了 equals 方法
        1.先去比较对象地址是否相等
        2.如果不相等,再去判断是否为String, 是的话再去逐个判断每一个字符相不相等
        if (str.equals(str2)) {  相等
            System.out.println("相等");
        }else {
            System.out.println("不相等");
        }

String类覆盖了 equals 方法
建议子类,自己去覆盖此方法,自己在内部当中去根据自己的需求去判断两个值是否相等

字符串创建以及常量池内存分析

常量--->方法区当中有一个常量池

        String str = "ABC";
        String str3 = "ABC";
        System.out.println(str==str3);  true

        String str2 = new String("ABC");

        1.String str = "ABCD";   局部变量
        使用String str = "ABCD";创建字符串
        要么创建一个对象,要么不创建
        会先到常量池当中看一下有没有该字符串常量
        如果说已经有了,就直接使用,不会创建新的字符串常量池地址
        如果常量池当中没有的话,就会在常量池当中创建一个对象

        2.String str2 = new String("ABCD");  创建对象
        至少得要创建一个对象,       因为使用了new 在堆当中,至少得要创建一个对象
        看一下,常量池当中,有没有传入的字符串常量
        如果没有的话,会创建一个字符串常量,放到常量池当中

        System.out.println(str2);    ABCD    会在堆中找到它的创建地址,这个地址会有一个常量引用,所以就把ABCD打印出来了

字符串工具类设计

    给一个字符串,判断是否为空,如果为空返回false
    不为空就返回一个true
    一个方法当中有return 所在的方法 会立即停止执行

定义一个方法
    static boolean hasLength(String str) {
        if (str != null && !"".equals(str.replace(" ", ""))) {// 不为空
            return true;
        } // 为空
        return false;//一个方法当中有return 所在的方法 会立即停止执行
    }
可以直接简写成
    static boolean hasLength(String str) {
            return str != null && !"".equals(str.replace(" ", ""));
    }
在main方法中执行
        boolean res = hasLength(s);
        System.out.println(res);

把方法抽成一个工具类
public class StringUtils {

    private StringUtils() {};
    
    工具类有两种情况:1.单例模式,2.全部方法搞成静态
    static boolean hasLength(String str) {
        return str != null && !"".equals(str.replace(" ", ""));
    }
}
    System.out.println(StringUtils.hasLength(s));

Random类


        构造方法摘要 Random() 创建一个新的随机数生成器。 

        Random r = new Random();
        int res = r.nextInt();//随机生成一个int类型的数
        System.out.println(res);

        System.out.println(r.nextDouble());
        System.out.println(r.nextBoolean());


        Random(long seed) 使用单个 long 种子创建一个新的随机数生成器。
        伪随机数 , 相同的种子,生成的随机数是一样的

        Random r2 = new Random(11);//传入参数,生成的随机数是一样的
        System.out.println(r2.nextInt());

        生成34-179之间的随机数
        34+ [0,145)
        nextInt(145)  随机生成0到145之间的随机数
        new Random().nextInt(145);//随机生成0到145之间的随机数
        System.out.println(34+new Random().nextInt(145));//生成34-179之间的随机数

生成UUID
UUID:通用唯一识别符
在一台机器上生成的数字,每一台机器都不一样

UUID如何生成:
通过当前时间,跟当前电脑网卡生成一段字符

        String uuid = UUID.randomUUID().toString();
        System.out.println(uuid);//每次生成都不一样

日期类Date
类 Date 表示特定的瞬间，精确到毫秒。

使用String,int类型表示日期不好
要使用java当中专门提供的日期类型
class Employee{
    int age;//年龄
    String hireDate;//工龄
}

public class DateDemo {
    
    public static void main(String[] args) {
        创建一个日期对象
        Date date = new Date();//Fri Nov 23 23:16:10 CST 2018
        System.out.println(date);


        获取当前时间的毫秒值 
        //public static native long currentTimeMillis();
        native 是原生的方法,使用C++写的,所以看不到如何实现
        long curTime = System.currentTimeMillis();
        
        
        把一个毫秒值转成日期
        Date date2 = new Date(curTime);
        System.out.println(date2);
        
        转成中国人喜欢风格,方法着画横线表示过期了
        String str = date2.toLocaleString();
        System.out.println(str);//2018-11-23 23:12:37
        
        把一个日期类型转成时间戳(毫秒值)
        System.out.println(date2.getTime());

    }
    
}

生成随机验证码

    public static void main(String[] args) {

        生成验证码
        首先是想到:5位随机数 UUID生成的是16进制
        String res = UUID.randomUUID().toString();
        System.out.println(res);
        System.out.println(res.substring(0, 5));
        System.out.println("----------");

        不够我们的需求,采取下列措施
        String str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        str += str.toLowerCase();
        str += "0123456789";
        System.out.println(str);// str字符拼接结果

        从所有的字符当中随机生成5个出来
        随机取5个出来
        每取出一个结果,在原来的基础进行拼接

        StringBuilder sb = new StringBuilder(5);// 指定StringBuilder空间大小

        for (int i = 0; i < 5; i++) {
            脚标需要随机的值 (0 62:字符串的长度)
            int index = new Random().nextInt(str.length());// 随机生成脚标, 0 - 62之间的随机数,不包括62

            char ch = str.charAt(index);// char类型接收str的charAt取出随机脚标的字符

            sb.append(ch);// 与空的sb StringBuilder 拼接

        }
        
        System.out.println(sb);
    }

日期格式化

字符串工具类
public class StringUtils {

    public static boolean hb(String str) {

        return (str != null && !str.equals(str.replace(" ", "")));

    }

    为空就为true
    public static boolean isBlank(String str) {
        return !StringUtils.hb(str);
    }

}

public static void main(String[] args) throws ParseException {//声明异常

        日期格式化
        Date date = new Date();
        System.out.println(date.toLocaleString());
        //使用toLocaleString() 过时方法生成 2018-11-24 18:05:48

        DateFromat是一个日期/时间格式化子类的抽象类
        getInstance();获取为日期/时间SHORT风格的默认日期/时间格式器
        DateFormat df = DateFormat.getInstance();

        对指定的日期进行格式化
        String time = df.format(date);
        System.out.println(time);//getInstance()SHORT风格 18-11-24 下午1:22

        System.out.println("-----------");

        dateStyle日期风格:长日期LONG,短日期SHORT
        DateFormat df2 = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.SHORT);
        
        日期风格长,时间风格短
        String time2 = df2.format(date);
        System.out.println(time2);//getDateTimeInstance传入日期风格,时间风格 2018年11月24日 下午1:28

        System.out.println("------");
        DateFormat df3 = DateFormat.getTimeInstance();
        String time3 = df3.format(date);
        System.out.println(time3);//getTimeInstance() 获得时间18:05:48

        把一个字符串转成日期
        DateFormat df4 = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.SHORT);
        String newStr = "2018年11月24日 下午5:59";
        Date date2 = df4.parse(newStr);
        System.out.println(date2);//Sat Nov 24 17:59:00 CST 2018
    }

自定义日期模式
自定义日期模式:SimpleDateFormat

在DateFormat的基础上进行增强

定义了以下模式字母

        Date date = new Date();//创建一个日期
        
        SimpleDateFormat sd = new SimpleDateFormat();//创建一个自定义日期
        定义自己想要什么样的模式
        String pattern = "yyyy-MM-dd HH:mm:ss";//定义日期模式格式
        sd.applyPattern(pattern);//接收格式值,申请模式
        
        以指定的模式格式化哪个日期
        String res=  sd.format(date);//生成日期
        System.out.println(res);

日期工具类设计

Demo类运用日期工具类方法
import java.util.Date;
public class Demo {

    public static void main(String[] args)  throws ParseException{

        String res = DateUtil.dateToString(new Date(), "yyyy-MM-dd hh:mm:dd");
        System.out.println(res);
        String res2 = DateUtil.dateToString(new Date(), null);
        System.out.println(res2);
        String res3 = DateUtil.dateToString(new Date());
        System.out.println(res3);

字符串转时间
        Date date = DateUtils.StringToDate("2018-12-16 19/16/12","yyyy-MM-dd hh/mm/ss");
        System.out.println(date);//Sun Dec 16 19:16:12 CST 2018

    }
}

日期工具类
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateUtil {
    
    private static final String DEFAULT_PATTERN = "yyyy-MM-dd hh:mm:dd:ss";
    使用常量,使得程序的可扩展性增加

    private DateUtil() {
    };

    1.把一个日期类型转成字符串 返回已经转换好的字符串
    public static String dateToString(Date date, String pattern) {

        牢记一个工具类,想要别人使用,记得加public不然在其他包中不能使用你的方法

        判断传入的模式是否为空
        为空的话,设置一个默认的模式

        if (StringUtils.isBlank(pattern)) {// true时
            为空的话,设置一个默认的模式
            pattern =DEFAULT_PATTERN;

        }

        SimpleDateFormat sd = new SimpleDateFormat();
        sd.applyPattern(pattern);
        String res = sd.format(date);

        return res;
    }

    public static String  dateToString(Date date){
        
        return DateUtil.dateToString(date, "");
    }

    2.给一个字符串可以转成日期
    public static Date  StringToDate(String str,String pattern) throws ParseException{
        
        if(StringUtils.isBlank(pattern)) {
            
            pattern =DEFAULT_PATTERN;
            
        }
        
        SimpleDateFormat sd = new SimpleDateFormat();
        sd.applyPattern(pattern);
        
        Date res = sd.parse(str);
        return res;
    }

    public static void main(String[] args) {

    }

}

面向对象-常用类

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

JavaWeb

程序员