Educoder/头歌JAVA——JAVA面向对象：常用类

最新推荐文章于 2024-09-20 15:56:58 发布

陆小玖

最新推荐文章于 2024-09-20 15:56:58 发布

阅读量1.5w

点赞数 57

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/zhou2622/article/details/128320445

版权

第3关：String&StringBuilder&StringBuffer类-练习

第5关：Date类和SimpleDateFormat类的用法

相关知识

Java日期时间

使用SimpleDateFormat格式化日期

第1关：Object类

编程要求

请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下：

Demo类和Person类已经写好，在测试类中创建Demo类对象d1，传入输入值num1， d1调用toString方法并打印输出该值；
创建Demo类对象d2，同样传入输入值num1，打印判断d1和d2是否相等（实际是比较地址）；
创建Person类对象p，传入输入值num2，打印判断d1和p是否相等（实际是比较地址）；

package case1;

import java.util.Scanner;

public class ObjectTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int num1 = sc.nextInt();
		int num2 = sc.nextInt();
		// 在测试类中创建Demo类对象d1，传入输入值num1， d1调用toString方法并打印输出该值
        Demo d1=new Demo(num1);
        System.out.println(d1.toString());
		// 创建Demo类对象d2，同样传入输入值num1，打印判断d1和d2是否相等（实际是比较地址）
		/********* Begin *********/
        Demo d2=new Demo(num1);
        System.out.println(d1.equals(d2));
		/********* End *********/
		// 创建Person类对象p，传入输入值num2，打印判断d1和p是否相等（实际是比较地址）
		/********* Begin *********/
        Person p=new Person(num2);
        System.out.println(d1.equals(p));
		/********* End *********/
	}
}

class Demo {
	private int num;

	public Demo(int num) {
		this.num = num;
	}
	public boolean equals(Object obj) // Object obj = new Demo()
	{
		if (!(obj instanceof Demo)) // 判断obj是否和Demo是同类
			return false;
		Demo d = (Demo) obj; // 将父类的引用(Object)向下转换为子类(Demo)
		return this.num == d.num;
	}
	public String toString() {
		return "Demo:" + num; // 返回对象的值（每一个对象都有自己的特定的字符串）
	}
}
class Person {
	private int num;

	public Person(int num) {
		this.num = num;
	}
}

第2关：JAVA基础类型包装类-练习

编程要求

请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下：

编写测试类，输入int型值aa传递给Integer类对象a，String型值bb传递给Integer类对象b，输入int型值c，aa、bb、c对应的数值相等；
输入String型值str11传递给String类对象str1，输入String型值str22传递给String类对象str2，str1和str2对应的内容相同；
打印输出a == b、a == c、b == c、a.equals(b)；
打印输出str1 == str2、str1.equals(str2)。

package case2;

import java.util.Scanner;

public class WrapperTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int aa = sc.nextInt();
		String bb = sc.next();
		int c = sc.nextInt();
		String str11 = sc.next();
		String str22 = sc.next();
		// 包装类中“==”与equals的用法比较
		// 值得注意的是，包装类中的equals方法和String类一样，都是重写了Object类中的equals方法，因此比较的是内容而不是地址，
		// 而“==”比较的依然是引用变量的地址，只是当包装类型和与之相对应的基本类型进行“==”比较时会先做自动拆箱处理。
		/********* Begin *********/
        Integer a=new Integer(aa);
        Integer b=Integer.valueOf(bb);
        String str1=str11;
        String str2=str22;
        System.out.println(a == b);
        System.out.println(a == c);
        System.out.println(c == b);
        System.out.println(a.equals(b));
        System.out.println(str1 == str2);
        System.out.println(str1.equals(str2));
		/********* End *********/
	}
}

第3关：String&StringBuilder&StringBuffer类-练习

编程要求

请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下：

编写测试类，输入一个标准的网址，输出其域名的主体；
将该主体转换为大写，打印输出；
具体输出要求请看测试说明。

package case3;

import java.util.Scanner;

public class StringTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String str = sc.next();
		// String substring(int start,int end)
        // 截取字符串，传入的两个参数分别为要截取边界的下标
        // 在java api 中,通常使用两个数字表示范围时,都是含头不含尾,即包含起始下标对应的内容,但不包含结束下标的处对应的内容
        // String toUpperCase() 将当前字符串中的英文部分转换为全大写
		/********* Begin *********/
        int a=str.indexOf(".");//第一个“.”的位置
        String str_=str.substring(a+1,str.length());
        int b=str_.indexOf(".");//第二个“.”的相对位置
        b=b+a+1;
        //System.out.println("a="+a+",b="+b);
        String s=str.substring(a+1,b);//截取主体部分
        System.out.println(s);
        String ans=s.toUpperCase();//主体部分转换为大写
        System.out.println(ans);
		/********* End *********/
	}
}

第4关：Random类

编程要求

请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下：

设计一个密码的自动生成器：密码由大写字母/小写字母/数字组成，生成六位随机密码。
分别以1、2、3作为种子数创建Random对象，生成六位随机密码进行测试。

package case4;

//密码的自动生成器：密码由大写字母/小写字母/数字组成，生成六位随机密码
import java.util.Random;
import java.util.Scanner;

public class RandomTest {
	public static void main(String[] args) {
		// 定义一个字符型数组
		char[] pardStore = new char[62];
		// 把所有的大写字母放进去 把所有的小写字母放进去 把0到9放进去
		/********* Begin *********/
        int j=0;
        for (int i = 'A'; i <='Z' ; i++) {
            pardStore[j++]=(char)i;
        }
        for (int m = 'a'; m <='z' ; m++) {
            pardStore[j++]=(char)m;
        }
        for (int g = '0'; g <='9' ; g++) {
            pardStore[j++]=(char)g;
        }
        //System.out.println(pardStore[26]);
		/********* End *********/
		// 分别以1、2、3作为种子数 生成6位随机密码
		Scanner sc = new Scanner(System.in);
		int seed = sc.nextInt();
		/********* Begin *********/
        char[] ans = new char[6];
        //int[] aa=new int[6];  
        Random ran=new Random(seed);  
        int[]aa = ran.ints(6,0,62).toArray(); 
        for(int k=0;k<6;k++){
            //System.out.println(an);
            ans[k]=pardStore[aa[k]]; 
        }
        System.out.println(ans);
		/********* End *********/
        } 
}

第5关：Date类和SimpleDateFormat类的用法

相关知识

Java日期时间

java.util包提供了Date类来封装当前的日期和时间。Date类提供两个构造函数来实例化Date对象。

第一个构造函数使用当前日期和时间来初始化对象。

Date( )

第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数。

Date(long millisec)

Date对象创建以后，可以调用下面的方法。

获取当前日期时间：

Java中获取当前日期和时间很简单，使用Date对象的toString()方法来打印当前日期和时间，如下所示：

package educoder;

import java.util.Date;

public class DateDemo {
public static void main(String args[]) {
// 初始化 Date 对象
Date date = new Date();

// 使用 toString() 函数显示日期时间
System.out.println(date.toString());
}
}

输出结果： Sun Aug 12 23:33:44 CST 2018

Java使用以下三种方法来比较两个日期：

使用getTime()方法获取两个日期自1970年1月1日经历的毫秒数值，然后比较这两个值；
使用方法before()，after()和equals()。例如，一个月的12号比18号早，则 new Date(99, 2, 12).before(new Date (99, 2, 18))返回true；
使用compareTo()方法，它是由Comparable接口定义的，Date 类实现了这个接口。

使用`SimpleDateFormat`格式化日期

SimpleDateFormat是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat允许你选择任何用户自定义日期时间格式来运行。例如：

package educoder;

import java.util.*;
import java.text.*;

public class DateDemo {
public static void main(String args[]) {

Date dNow = new Date();
SimpleDateFormat ft = new SimpleDateFormat(
"E yyyy.MM.dd 'at' hh:mm:ss a zzz");

System.out.println("Current Date: " + ft.format(dNow));
}
}

SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");

这一行代码确立了转换的格式，其中yyyy是完整的公元年，MM是月份，dd是日期，hh:mm:ss 是时、分、秒。

注意:有的格式大写，有的格式小写，例如MM是月份，mm是分；HH 是 24 小时制，而 hh 是 12 小时制。

以上实例编译运行结果如下: Current Date: 星期日 2018.08.12 at 11:45:16 下午 CST

日期和时间的格式化编码：

时间模式字符串用来指定时间格式。在此模式中，所有的ASCII字母被保留为模式字母，定义如下：

使用printf格式化日期

printf方法可以很轻松地格式化时间和日期。使用两个字母格式，它以%t开头并且以下面表格中的一个字母结尾。

实例：

package educoder;
import java.util.Date;
public class DateDemo {
    public static void main(String args[]) {
        // 初始化 Date 对象
        Date date = new Date();
        // c的使用
        System.out.printf("全部日期和时间信息：%tc%n", date);
        // f的使用
        System.out.printf("年-月-日格式：%tF%n", date);
        // d的使用
        System.out.printf("月/日/年格式：%tD%n", date);
        // r的使用
        System.out.printf("HH:MM:SS PM格式（12时制）：%tr%n", date);
        // t的使用
        System.out.printf("HH:MM:SS格式（24时制）：%tT%n", date);
        // R的使用
        System.out.printf("HH:MM格式（24时制）：%tR", date);
    }
}

/*_________________________________________________________*/

输出结果：
全部日期和时间信息：星期日 八月 12 23:51:03 CST 2018
年-月-日格式：2018-08-12
月/日/年格式：08/12/18
HH:MM:SS PM格式（12时制）：11:51:03 下午
HH:MM:SS 格式（24时制）：23:51:03
HH:MM 格式（24时制）：23:51

如果你需要重复提供日期，那么利用这种方式来格式化它的每一部分就有点复杂了。因此，可以利用一个格式化字符串指出要被格式化的参数的索引。

索引必须紧跟在%后面，而且必须以$结束。例如：

package educoder;
import java.util.Date;
public class DateDemo {
    public static void main(String args[]) {
        // 初始化 Date 对象
        Date date = new Date();
        // 使用toString()显示日期和时间
        System.out.printf("%1$s %2$tB %2$td, %2$tY", "Due date:", date);
    }
}

/*__________________________________________*/

输出结果：
Due date: 八月 12, 2018

或者，你可以使用<标志。它表明先前被格式化的参数要被再次使用。例如：

package educoder;
import java.util.Date;
public class DateDemo {
    public static void main(String args[]) {
        // 初始化 Date 对象
        Date date = new Date();
        // 显示格式化时间
        System.out.printf("%s %tB %<te, %<tY", "Due date:", date);
    }
}
/*_____________________________*/

输出结果：
Due date: 八月 12, 2018

定义日期格式的转换符可以使日期通过指定的转换符生成新字符串。这些日期转换符如下所示：

package educoder;
import java.util.Date;
import java.util.Locale;
public class DateDemo {
    public static void main(String args[]) {
        Date date = new Date();
        // b的使用，月份简称
        String str = String.format(Locale.US, "英文月份简称：%tb", date);
        System.out.println(str);
        System.out.printf("本地月份简称：%tb%n", date);
        // B的使用，月份全称
        str = String.format(Locale.US, "英文月份全称：%tB", date);
        System.out.println(str);
        System.out.printf("本地月份全称：%tB%n", date);
        // a的使用，星期简称
        str = String.format(Locale.US, "英文星期的简称：%ta", date);
        System.out.println(str);
        // A的使用，星期全称
        System.out.printf("本地星期的简称：%tA%n", date);
        // C的使用，年前两位
        System.out.printf("年的前两位数字（不足两位前面补0）：%tC%n", date);
        // y的使用，年后两位
        System.out.printf("年的后两位数字（不足两位前面补0）：%ty%n", date);
        // j的使用，一年的天数
        System.out.printf("一年中的天数（即年的第几天）：%tj%n", date);
        // m的使用，月份
        System.out.printf("两位数字的月份（不足两位前面补0）：%tm%n", date);
        // d的使用，日（二位，不够补零）
        System.out.printf("两位数字的日（不足两位前面补0）：%td%n", date);
        // e的使用，日（一位不补零）
        System.out.printf("月份的日（前面不补0）：%te", date);
    }
}
/*__________________________________________*/

输出结果：
英文月份简称：Aug
本地月份简称：八月
英文月份全称：August
本地月份全称：八月
英文星期的简称：Sun
本地星期的简称：星期日
年的前两位数字（不足两位前面补0）：20
年的后两位数字（不足两位前面补0）：18
一年中的天数（即年的第几天）：224
两位数字的月份（不足两位前面补0）：08
两位数字的日（不足两位前面补0）：12
月份的日（前面不补0）：12

解析字符串为时间：

SimpleDateFormat类有一些附加的方法，特别是parse()，它试图按照给定的SimpleDateFormat对象的格式化存储来解析字符串。例如：

package educoder;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateDemo {
    public static void main(String args[]) {
        SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
        String input = args.length == 0 ? "1818-11-11" : args[0];
        System.out.print(input + " Parses as ");
        Date t;
        try {
            t = ft.parse(input);
            System.out.println(t);
        } catch (ParseException e) {
            System.out.println("Unparseable using " + ft);
        }
    }
}
/*____________________________________________________*/

输出结果：
1818-11-11 Parses as Wed Nov 11 00:00:00 CST 1818

Java休眠(sleep)

sleep()使当前线程进入停滞状态（阻塞当前线程），让出CPU的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会。

你可以让程序休眠一毫秒的时间或者到您的计算机的寿命长的任意段时间。例如，下面的程序会休眠3秒：

package educoder;
import java.util.*;
public class SleepDemo {
    public static void main(String args[]) {
        try {
            System.out.println(new Date() + "\n");
            Thread.sleep(1000 * 3); // 休眠3秒
            System.out.println(new Date() + "\n");
        } catch (Exception e) {
            System.out.println("Got an exception!");
        }
    }
}
/*____________________________________*/

输出结果：
Mon Aug 13 00:05:33 CST 2018

Mon Aug 13 00:05:36 CST 2018

测量时间：

下面的一个例子表明如何测量时间间隔（以毫秒为单位）：

package educoder;
import java.util.Date;
public class DiffDemo {
    public static void main(String args[]) {
        try {
            long start = System.currentTimeMillis();
            System.out.println(new Date() + "\n");
            Thread.sleep(5 * 60 * 10);
            System.out.println(new Date() + "\n");
            long end = System.currentTimeMillis();
            long diff = end - start;
            System.out.println("Difference is : " + diff);
        } catch (Exception e) {
            System.out.println("Got an exception!");
        }
    }
}
/*___________________________________________________*/

输出结果：
Mon Aug 13 00:07:58 CST 2018

Mon Aug 13 00:08:01 CST 2018

Difference is : 3021

测试说明

测试输入： 1999-09-01

预期输出： 你的出生日期距离2020年10月1日:7701天

package case5;

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

public class DateTest {
	public static void main(String[] args) throws ParseException {
		// 键盘录入你的出生年月日 格式为yyyy-MM-dd
		// 把该字符串转换为一个日期
		// 通过该日期得到一个毫秒值
		// 获取2020年10月1日的毫秒值
		// 两者想减得到一个毫秒值
		// 把该毫秒值转换为天 打印输出
		Scanner sc = new Scanner(System.in);
		String line = sc.nextLine();
		/********* Begin *********/
        SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date star = ft.parse(line);  //开始时间
            Date endDay=ft.parse("2020-10-01");  //结束时间
            Long starTime=star.getTime();
            Long endTime=endDay.getTime();
            Long num=endTime-starTime;  // 相差的毫秒数
            System.out.println("你的出生日期距离2020年10月1日:"+num/24/60/60/1000+"天");
            //System.out.println(t);

        } catch (ParseException e) {
            System.out.println("Unparseable using " + ft);
            //e.printStackTrace();
        }
		/********* End *********/
	}
}

第6关：Math类

编程要求

请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下：

编写测试类MathTest，输入4个int类型数值，7个double类型数值；
分别输出第一个数的平方根，第二个数的立方根，第三个数的第四个数次方，第五个数和第六个数的最大值、最小值，第七个数的绝对值，第八个数的ceil值，第九个数的floor值，第十个数的rint值，第十一个数的round值。

package case6;

import java.util.Scanner;
import java.lang.Math;

public class MathTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a1 = sc.nextInt();
		int a2 = sc.nextInt();
		int a3 = sc.nextInt();
		int a4 = sc.nextInt();
		double a5 = sc.nextDouble();
		double a6 = sc.nextDouble();
		double a7 = sc.nextDouble();
		double a8 = sc.nextDouble();
		double a9 = sc.nextDouble();
		double a10 = sc.nextDouble();
		double a11 = sc.nextDouble();
		/********* Begin *********/
        System.out.println(Math.sqrt(a1));
        System.out.println(Math.cbrt(a2));
        System.out.println(Math.pow(a3,a4));
        System.out.println(Math.max(a5,a6));
        System.out.println(Math.min(a5,a6));
        System.out.println(Math.abs(a7));
        System.out.println(Math.ceil(a8));
        System.out.println(Math.floor(a9));
        System.out.println(Math.rint(a10));
        System.out.println(Math.round(a11));

		/********* End *********/
	}
}

注：如果有用请三连哦~ 感谢