Java 面向对象（七）

最新推荐文章于 2024-07-09 16:46:46 发布

weixin_30911809

最新推荐文章于 2024-07-09 16:46:46 发布

阅读量107

点赞数

文章标签： java 运维

原文链接：http://www.cnblogs.com/xzh0717/p/11232811.html

版权

枚举

枚举的引入（模拟枚举）

class Student {
    private int restDay;

    public int getRestDay() {
        return restDay;
    }

    public void setRestDay(int restDay) {
        this.restDay = restDay;
    }
}

public class Test {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setRestDay(1);
        int res = stu.getRestDay();
        if (res == 6 || res == 7) {
            System.out.println("放假");
        } else {
            System.out.println("上课");
        }
    }
}

上面的代码，存在一些问题：

（1）数据不安全，输入8

stu.setRestDay(8);  // 输出：上课（没有星期八）

（2）业务逻辑不合理：中外一周的第一天不一样，中国第一天是周一，外国第一天是周天。

改进后：

class WeekDay {
    public static final int MONDAY = 1;
    public static final int TUESDAY = 2;
    public static final int WEDNESDAY = 3;
    public static final int THURSDAY = 4;
    public static final int FRIDAY = 5;
    public static final int SATURDAY = 6;
    public static final int SUNDAY = 7;
}

class Student {
    private int restDay;

    public int getRestDay() {
        return restDay;
    }

    public void setRestDay(int restDay) {
        this.restDay = restDay;
    }
}

public class Test {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setRestDay(WeekDay.MONDAY);
        int res = stu.getRestDay();
        if (res == 6 || res == 7) {
            System.out.println("放假");
        } else {
            System.out.println("上课");
        }
    }
}

改进后的代码，还存在问题：

（1）数据不安全，输入8

stu.setRestDay(8);  // 输出：上课（没有星期八）

再次改进：

class WeekDay {
    private WeekDay() {}
    public static final WeekDay MONDAY = new WeekDay();
    public static final WeekDay TUESDAY = new WeekDay();
    public static final WeekDay WEDNESDAY = new WeekDay();
    public static final WeekDay THURSDAY = new WeekDay();
    public static final WeekDay FRIDAY = new WeekDay();
    public static final WeekDay SATURDAY = new WeekDay();
    public static final WeekDay SUNDAY = new WeekDay();
}

class Student {
    private WeekDay restDay;

    public WeekDay getRestDay() {
        return restDay;
    }

    public void setRestDay(WeekDay restDay) {
        this.restDay = restDay;
    }
}

public class Test {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setRestDay(WeekDay.MONDAY);
        WeekDay res = stu.getRestDay();
        if (res == WeekDay.SATURDAY || res == WeekDay.SUNDAY) {
            System.out.println("放假");
        } else {
            System.out.println("上课");
        }
    }
}

上面的代码，问题解决了，但是代码不好看，太冗余。

什么是枚举

枚举：表示一个事物固定状态。

比如：季节（春，夏，秋，冬）、星期（周一到周日）、性别（男，女）

枚举的定义

格式：

[修饰符] enum 枚举的名称  {
    常量1，常量2，常量3……
}

比如：

enum Sex {
    MAN, FEMALE
}

枚举的本质

java 枚举是一个语法糖。是一个特殊的类，是多个常量对象的集合。

当我们定义一个枚举后，它的本质还是一个类，一个继承了Enum的类。

enum Sex {
    MAN, FEMALE
}

反编译后：

final class Sex extends Enum
{

    public static final Sex MAN;
    public static final Sex FEMALE;
    private static final Sex ENUM$VALUES[];

    private Sex(String s, int i)
    {
        super(s, i);
    }

    public static Sex[] values()
    {
        Sex asex[];
        int i;
        Sex asex1[];
        System.arraycopy(asex = ENUM$VALUES, 0, asex1 = new Sex[i = asex.length], 0, i);
        return asex1;
    }

    public static Sex valueOf(String s)
    {
        return (Sex)Enum.valueOf(Test/Sex, s);
    }

    static 
    {
        MAN = new Sex("MAN", 0);
        FEMALE = new Sex("FEMALE", 1);
        ENUM$VALUES = (new Sex[] {
            MAN, FEMALE
        });
    }
}

程序 main 方法

public static void main(String[] args) {
    
}

当点击运行时，JVM自动会调用main方法。

public : 被JVM调用的方法，它的权限要足够的大。

static : 被JVM调用的方法，不需要创建对象，直接使用类名调用

void : 被JVM调用的方法，不需要有任何的返回值。

main : 方法的名称，只能这样写，不然JVM识别不了

String[] args : 以前是指键盘录入。

常用类之Scanner

Scanner类常用的场景为：

（1）控制台输入（等待从键盘录入一个数）；

（2）字符串分割；

（3）文本整行读取。

控制台输入

输入八大基本数据类型

在输入之前最好先使用 hasNextXxx() 方法进行验证是否还有输入的数据，再使用 nextXxx() 来读取。

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    if (in.hasNextInt()) {
        System.out.println("请输入一个数：");
        int input = in.nextInt();
        System.out.println("input ==> " + input);
    }
    in.close();
}

这时候，我们可能希望的是：先输出“请输入一个数：”，然后我们就可以在控制台输入一个字符串或数字。

但是，事实却是：控制台要我们先输入，输入后才显示“请输入一个数：”。

个人理解如下：

首先，in.hasNextInt() 和 in.nextInt() 都可以用来输入。

in.hasNextInt()输入：

Scanner in = new Scanner(System.in);
boolean b = in.hasNextInt();    // 输入1：12       输入2：12.5
System.out.println(b);          // 输出1：true     输出2：false

in.hasNext：读取数据存储区，有下一个则返回布尔true，否则一直等待输入（不会返回false）

可设置终止符：hasNext(String patten)，如果下一个标记与从指定字符串构造的模式匹配，则返回 true。

Scanner in = new Scanner(System.in);
boolean b = in.hasNext("0");    // 输入1：0        输入2：java
System.out.println(b);          // 输出1：true 输出2：false

in.nextInt()输入：

Scanner in = new Scanner(System.in);
int i = in.nextInt();           // 输入1：12       输入2：java
System.out.println(i);          // 输出1：12       输出2：抛异常

可以发现，hasNextXxx()返回的是boolean类型，而nextXxx()返回的是输入的那个值。

in.hasNextXxx()可以理解为: 从一段用于用户输入的内存（可以理解为in）当中扫描，
如果该内存中有值，判断是否符合类型。符合就返回true，不符合就返回false。
如果该内存中没有值，会阻塞，先从键盘读取一个值存到该内存中，在进行判断是否符合类型。

in.next()可以理解为：从一段用于用户输入的内存（可以理解为in）中取值，
如果该内存中有值，会先判断是否符合类型，如果符合直接取值，取值后将标识符后移（可以理解为：取完值后这个值就不在了），如果不符合会报异常；
如果该内存中没有值，会阻塞，先从键盘读取一个值存到该内存中，再取值（取值时也要判断是否符合类型）。

输入字符串

可以使用 next() 与 nextLine()。在输入之前也是最好先使用 hasNext() 方法进行验证是否还有输入的数据。

next() 与 nextLine() 区别

next():

1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。

注意：next() 不能得到带有空格的字符串。

nextLine()：

1、以Enter为结束符，也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。

字符串分割

public static void main(String[] args) {
    String inputStr = "123 456,abc.def...张三|李四";
    Scanner in = new Scanner(inputStr);
    in.useDelimiter(" |,|\\.|\\|");
    while(in.hasNext()){
        String input = in.next();
        System.out.println("input ==> " + input);
    }
    in.close();
}

文本整行读取

public static void main(String[] args) {
    InputStream is = null;
    try {
        is = new FileInputStream(new File("D:\\Desktop\\Hello.txt"));
        Scanner in = new Scanner(is);
        while (in.hasNextLine()) {
            String input = in.nextLine();
            System.out.println("input ==> " + input);
        }
        in.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } finally {
        try {
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

常用类之System（java.lang.System）

常用类主要说的是常用类当中常用的方法（系统已经给我们提供了很多可以直接使用的方法）

常用类一般都不允许你创建对象。一般都私有化了构造器。

java.lang 是不需要导入包的。

数组拷贝

public static void main(String[] args) {
    int[] src = { 1, 2, 3, 4, 5, 6 };
    int[] dest = new int[8];
    /*
     * 数组拷贝
     * public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
     * src      ：源数组
     * srcPos   ：源数组中的起始位置
     * dest     ：目标数组
     * destPos  ：目标数据中的起始位置
     * length   ：要复制的数组元素的数量
     */
    System.arraycopy(src, 2, dest, 2, 4);
    // 数组打印
    System.out.println(Arrays.toString(src));   // [1, 2, 3, 4, 5, 6]
    System.out.println(Arrays.toString(dest));  // [0, 0, 3, 4, 5, 6, 0, 0]
}

返回以毫秒为单位的当前时间（用于计算代码耗时）

public static void main(String[] args) {
    // 获取当前时间与 1970 年 1 月 1 日午夜之间的时间差（以毫秒为单位测量）。
    long time1 = System.currentTimeMillis();
    for (int i = 0; i < 100; i++) {
        System.out.println(i);
    }
    long time2 = System.currentTimeMillis();
    long time3 = time2 - time1;
    System.out.println("总耗时：" + time3 + " ms");
}

终止当前正在运行的 Java 虚拟机

public static void exit(int status)

非 0 的状态码表示异常终止。

正常终止：

System.exit(0);

运行垃圾回收器

System.gc();

例子：

public class Test {
    
    /**
     * 当一个对象被垃圾回收时，自动调用的一个方法
     */
    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("我被回收了");
    }
    
    public static void main(String[] args) {
        
        new Test();
        new Test();
        /*
         * 一个对象并不是立即被回收
         * 执行gc，立即运行垃圾回收器
         */
        System.gc();
    }
}

常用类之Math（java.lang.Math）

java.lang 是不需要导入包的。

说明	方法
求绝对值	abs
求平方根	sqrt
求立方根	cbrt
求最大值	max
求最小值	min
求 n 次方	pow
随机数	random
三角函数	……
对数	……
指数	……

public static void main(String[] args) {

    // abs : 求绝对值
    int abs = Math.abs(-62);
    System.out.println(abs);
    
    // sqrt : 求平方根
    double sqrt = Math.sqrt(4.0);
    System.out.println(sqrt);
    
    // cbrt : 求立方根
    double cbrt = Math.cbrt(27);
    System.out.println(cbrt);

    // max : 求最大值
    // min : 求最小值
    int max = Math.max(6, 10);
    double min = Math.min(6.0, 3.0);
    System.out.println("max: " + max + ",  min: " + min);

    // pow : 求一个数的 n 次方
    double pow = Math.pow(2, 3);
    System.out.println(pow);

    // random : 返回一个 [0,1) 的随机数
    double random = Math.random();
    System.out.println(random);
    // 返回 [0,100) 的随机数
    double random2 = Math.random() * 100;
    System.out.println(random2);
    // 返回 [0,100) 的随机整数
    int random3 = (int)(Math.random() * 100);
    System.out.println(random3);
}

大精度小数

先来看个例子：

// float double 表示小数，但是不能表示精确的小数
System.out.println("0.09 + 0.01 = " + (0.09 + 0.01));
System.out.println("1.0 - 0.33 = " + (1.0 - 0.33));
System.out.println("4.015 * 1000 = " + (4.015 * 1000));
System.out.println("12.3 / 100 = " + (12.3 / 100));

输出结果：

0.09 + 0.01 = 0.09999999999999999
1.0 - 0.33 = 0.6699999999999999
4.015 * 1000 = 4014.9999999999995
12.3 / 100 = 0.12300000000000001

这里结果精度差了点，如果用来表示金钱，问题就大了。

金钱对精度要求比较高，所以不用 float 和 double，用 BigDecimal

BigDecimal b1 = new BigDecimal(0.09);
BigDecimal b2 = new BigDecimal(0.01);
BigDecimal add = b1.add(b2);
System.out.println(add);
// 输出结果： 0.09999999999999999687749774324174723005853593349456787109375

发现结果精度更高了，但还不是我们想要的结果。这是构造器的原因：

public BigDecimal(double val):

（1）此构造方法的结果有一定的不可预知性。有人可能认为在 Java 中写入 new BigDecimal(0.1) 所创建的 BigDecimal 正好等于 0.1，但是它实际上等于 0.1000000000000000055511151231257827021181583404541015625。这是因为 0.1 无法准确地表示为 double（或者说对于该情况，不能表示为任何有限长度的二进制小数）。这样，传入到构造方法的值不会正好等于 0.1（虽然表面上等于该值）。

（2）另一方面，String 构造方法是完全可预知的：写入 new BigDecimal("0.1") 将创建一个 BigDecimal，它正好等于预期的 0.1。因此，比较而言，通常建议优先使用 String 构造方法。

BigDecimal b1 = new BigDecimal("0.09");
BigDecimal b2 = new BigDecimal("0.01");
BigDecimal add = b1.add(b2);
System.out.println(add);
// 输出结果： 0.10

BigDecimal 加减乘除：

public static void main(String[] args) {
    double d1 = 0.09;
    double d2 = 0.01;
    BigDecimal b1 = new BigDecimal(Double.toString(d1));
    BigDecimal b2 = new BigDecimal(Double.toString(d2));
    // d1+d2
    BigDecimal add = b1.add(b2);
    System.out.println(add);
    // d1-d2
    BigDecimal sub = b1.subtract(b2);
    System.out.println(sub);
    // d1*d2
    BigDecimal mul = b1.multiply(b2);
    System.out.println(mul);
    // d1/d2
    BigDecimal div = b1.divide(b2);
    System.out.println(div);
    
    // BigDecimal -> double
    double d3 = div.doubleValue();
    System.out.println(d3); 
}

转载于:https://www.cnblogs.com/xzh0717/p/11232811.html

weixin_30911809

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java 面向对象（七）

枚举枚举的引入（模拟枚举）class Student { private int restDay; public int getRestDay() { return restDay; } public void setRestDay(int restDay) { this.restDay = restDay; ...
复制链接

扫一扫