正则表达式&接口和抽象类的区别

@System类&抽象类与接口的区别&Date类

增强for循环：
String [ ] arr="abcde";
for(String s:arr){
System.out.println(s);
}
增强for循环的好处是不计入循环次数，所以执行速度快效率高，但是也有弊端，增强for循环不可控，从第一个元素遍历到最后一个元素，而且不记入循环次数。
for循环：

- 迭代for循环（普通for循环）：可以控制循环次数
- for each（增强for循环）：运行速度快，但是循环次数不可控。
if循环和for循环的嵌套最好不要超过三层，因为超过三层以后很容易会有逻辑上的漏洞。

正则表达式：用来校验字符串的规则。
regex表示正则的类。
例题：
判断用户输入的字符串，要求：2位到5位，由数字，字母，下划线组成，不允许有其他字符。
如果不使用正则表达式，那么代码将及其冗长且易出错；

```

package com;

import java.util.Scanner;

public class Demo {

public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String str=sc.next();
char[] arr=str.toCharArray();
if(str.length()>=2&&str.length()<=5) {
boolean flag=false;
for(char s:arr) {
if(!(s>='a'&&s<='z'||s>='A'&&s<='Z')) {
if(!Character.isDigit(s)) {
if(!(s=='_')) {
flag=true;
}
}
}
}
if(flag) {
System.out.println("不合法");
}
else {
System.out.println("合法");
}

}
else {
System.out.println("不合法");
}
}

}

```
而使用了正则表达式以后，代码会简洁很多

```

package com;

import java.util.Scanner;

public class Demo {

public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String str=sc.next();
String regex="[0-9a-zA-Z_]{2,5}";
boolean result=str.matches(regex);
System.out.println(result);


}
}

```

使用了正则表达式的代码，简洁，逻辑清晰，不易出错，这就是正则表达式存在的意义。
正则表达式 [该位置允许出现的字符]{该字符可以出现的次数}
元字符：
.表示任何字符
d表示数字
D表示非数字
s表示空白字符 space
S表示非空白字符
w表示单词字符 （数字 字母） word
W表示非单词字符

*任意多次
+至少一次
？至多一次
matches 匹配 校验方法

使用正则表达式来简单校验手机号 规则： 以1开头，第二位为 3，5，7，8
1[3578]\d{9}另一种非主流写法
1[(3)|(5)|(7)|(8)]\d{9};

使用正则表达式来简单的校验邮箱：
[0-9]\w*@\w+\.com

类只能单继承，也就是说一个类只能继承一个父类，而一个接口，却可以继承多个接口，原因如下：
首先：接口中的方法都是抽象方法，都没有被实现，而抽象类中有的方法不是抽象方法，如果一个类可以继承多个类，恰好这多个类中都有同名的非抽象方法，那么调用时该调用哪一个方法就不知道了，这也是为什么类只能继承一个类的原因，下面将用简单的代码来说明：、
abstract class T{
public viod fun();
}
abstract class T2{
public void fun();
}
如果有一个子类同时集成了T 和T2
class Zi extends T,T2{
那么它在调用fun（）方法时系统就无法知道它调用的是哪一个父类的fun()方法。
}
下面用接口来说明一下：

interface Y{
abstract void fun();
}
interface Y2{
abstract void fun();
}
interface Y3 extends Y,Y2{
因为父接口的两个fun()方法都是抽象的，都没有被实现，所以这两个方法是完全相同的两个方法，调用哪一个都是一样的，所以接口可以继承多个接口。
}

下面来介绍一次抽象类和接口的区别：
抽象类：为同一事物，有“血缘关系”
接口： 许多事物都具有的共性功能
拿缉毒犬来举一个例子

abstract class Dog{
//狗的属性和功能
}
abstract class Pig{
//猪 的属性和功能
}
interface JD{
public void jd(); //缉毒方法
}
interface DM{
public void dm(); //导盲方法
}

class JDDog extends Dog implements JD{ //这是一条缉毒犬 
public void jd(); 
}
class DMDog extends Dog implements DM{ //这是一条导盲犬
public void dm();
}
class JDPig extends Pig implements JD{ //这是一只缉毒猪
public void jd();
}

缉毒犬有缉毒的功能，但是其他犬没有缉毒的功能，所以将狗的属性，功能写在Dog类中，将缉毒的方法
写在缉毒接口中，不光有缉毒犬，还有缉毒猪，这样缉毒猪也可以实现缉毒接口。还有导盲犬，实现导盲
的接口。各个动物都写在抽象类中，特有的功能写在接口中
假如每个抽象类都是竖着的个体，那么接口就是一个横着贯穿这些抽象类的东西。可以用一幅图来形象的
描述

错误流的输出是随机的，不一定在哪出现

1. day02 课堂笔记
1.1. 正则表达式
1. 用来校验字符串的规则， 实质：字符串
2. 格式：
该位置可以出现的字符 [ 这些字符可以出现的次数 ]
3. 规则 ：
该位置可以出现的字符 [ 该字符可以出现的次数 ]
1 》字符：正则表达式 字符 分为 ：原义字符 、元字符
*** 元字符 / 预定义字符：
① . 表示任意字符
② d 表示数字 [0-9]
③ D 表示非数字 [^0-9]
④ s 表示空白字符 [ x0Bf ]
⑤ S 表示非空白字符 [^s]
⑥ w 表示单词字符 [a-zA-Z0-9_]
⑦ W 表示非单词字符 [^w]
2 》次数 ：
*** 数量词：
① * 任意次数
② + 至少一次
③ ？ 至多一次
④ {n} n 次
⑤ {n,} 大于等于 n 次
⑥ {n,m} n 到 m 次
3 》边界匹配器：
① ^ 表示行的开头
② $ 表示行的结尾
③  表示单词的边界
4. 分组： () 表示
代码演示：

public static void main(String[] args) {
// 规则： 数字组成 、 5 到 11 位 --> 升级 -- 》第一位必须是数字 1
String qq="212345";
// 校验 ：
String qqReg="1\d{4,10}";
//String str.matches(reg) 校验 当前 str 字符串是否符合 reg 规则
System.out.println(qq.matches(qqReg));
}
代码演示分组：
public static void main(String[] args) {
String tel="13451241235";
// 数字组成， 11 位，必须 1 开头，第二位为 3,5,7,8 。
// String reg="1[3578]\d{9}";
// 分组的形式 ( 了解内容 )
String reg="1((3)|(5)|(7)|(8))\d{9}";
System.out.println(tel.matches(reg));
}

1.1.1. 正则表达式补充内容 ( 了解 )
正则表达式可以进行其他操作，如提取
代码演示：

public static void main(String[] args) {
String msg="adfas123 我 sfsdf 我 1235s 我 dfsdf123";
// 把数字提取出来
/* compile(reg) 用来预编译正则表达式的规则
* Pattern p = Pattern.compile("a*b");
* matcher(str) 用来进行操作的 str ，表示 str 是否能够匹配预编译的规则。
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();
*/
Pattern co = Pattern.compile(" 我 ");
Matcher matcher = co.matcher(msg);
/*System.out.println(matcher.find());
System.out.println(matcher.group());*/
// find() 表示搜索字符串中是否有与规则匹配的字符串，有返回 true
while(matcher.find()) {
System.out.println(matcher.start());
// group() 表示查找字符串中符合规则的字符串，有返回该字符串
System.out.println(matcher.group());
}
}

1.2. 常用类
1.2.1. Math 类
1. 工具类：
辅助其他类实现某些功能的， Math 、 Arrays
2. 常用的方法与属性：
① PI ： 圆周率
② abs(obj) 返回 obj 绝对值
③ cbrt(obj) 返回 obj 的立方根
*** ④ ceil(double a) 返回一个等于某个整数的 double 的值，该值大于等于 a 的整数
*** ⑤ floor(double a) 返回一个等于某个整数的 double 的值，该值小于等于 a 的整数
*** ⑥ round(double a) 四舍五入，返回 long 类型的值。
⑦ pow(double a, double b) 求第一个参数的第二个参数次幂 返回值 double 类型
⑧ random() 随机数 表示从 [0,1.0)
代码演示：

public class Math 类 {
public static void main(String[] args) {
// PI ： 圆周率
// System.out.println(Math.PI);
//abs(obj) 返回 obj 绝对值
// System.out.println(Math.abs(-5));
// cbrt(obj) 返回 obj 的立方根
// System.out.println(Math.cbrt(27));
System.out.println("=====================");
//ceil/floor/round
/*System.out.println(Math.ceil(10.7));
System.out.println(Math.floor(10.7));
System.out.println(Math.round(10.7));*/
//pow(double a, double b) 求第一个参数的第二个参数次幂
// System.out.println(Math.pow(2, 3));
// random() 随机数 表示从 [0,1.0) nextInt(11)
System.out.println(Math.floor(Math.random()*10+1));
}
}

System 类
1. 标准输入、输出流、错误流
① 标准输入 System.in
② 标准输出 System.out
③ 标准错误流 System.err
2.arrayCopy(src,srcPos,dest,destPos,length) 快速数组复制
src : 原数组
srcPos: 原数组开始复制的索引值
dest ：目标数组
destPost: 目标数组中要放置的位置
length: 表示复制的长度。
3.currentTimeMillis() 返回当前时刻的毫秒值。从 1970 年 1 月 1 日 0 时 0 分 0 秒开始的。
4.exit(0) 表示退出 jvm 。其中 0 表示正常退出。
5.gc(): java 垃圾回收机制：自动的垃圾回收机制。
代码演示：

public class System 类 {
public static void main(String[] args) {
/*System.out.println("===========1");
System.err.println("==========5");
System.out.println("===========2");
System.out.println("===========3");
System.out.println("===========4");*/
// Scanner sc=new Scanner(System.in);
// System.out.println(5/0);
//arrayCopy(src,srcPos,dest,destPos,length)
/*int[] arr= {1,5,2,4};
int[] brr= new int[10];
System.arraycopy(arr, 1, brr, 3 , 2);
arr[2]=10;
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(brr));*/
//switch 循环 -->break
/*System.out.println("======1");
System.exit(0);
System.out.println("======2");*/
// 了解 getProperties() 获取系统的属性集
Properties prp = System.getProperties();
Set<Entry<Object, Object>> entrySet = prp.entrySet();
Iterator<Entry<Object, Object>> it = entrySet.iterator();
while(it.hasNext()) {
Entry<Object, Object> entry = it.next();
System.out.println(entry.getKey()+"======>"+entry.getValue());
}
}
}

1.2.2. Date 类
1.Date 表示特定的瞬间 表示当前的时刻
2. 构造方法 :
① Date() 表示当前的时间
默认表示的是 cst 的时间：
CST 可视为美国、澳大利亚、古巴或中国的标准时间
② Date(long) 表示从 1970 年 1 月 1 日 0 时 0 分 0 秒开始的毫秒值。
3. 常用方法：
① getTime() 获取从 1970 年 1 月 1 日 0 时 0 分 0 秒开始的毫秒值。
代码演示：

public class Date 类 {
public static void main(String[] args) {
Date d=new Date();
/* System.out.println(d);
Date d1=new Date(1000);
System.out.println(d1);*/
// System.out.println(d.getDate());
System.out.println(d.toGMTString());
System.out.println(d.toLocaleString());
}
}

1.2.3. Calendar 类
1.Calendar 表示日历类，
2. 创建对象的方法：
① getInstance() 获取日历类
3. 常用方法：
① set(int field, int value) /get(field) 设置 / 获取字段的值
代码演示：

public class Calendar 类 {
public static void main(String[] args) {
//getInstance() 获取日历类
Calendar in = Calendar.getInstance();
// 月份是从 0 开始，需要加 1
// System.out.println(in.get(Calendar.MONTH));
// 年月日
/*System.out.println(in.get(Calendar.YEAR));
System.out.println(in.get(Calendar.MONTH)+1);
System.out.println(in.get(Calendar.DAY_OF_MONTH));
// 时分秒
System.out.println(in.get(Calendar.HOUR_OF_DAY));
System.out.println(in.get(Calendar.MINUTE));
System.out.println(in.get(Calendar.SECOND));*/
// 星期 从周日开始 到周六结束
// System.out.println(in.get(Calendar.DAY_OF_WEEK)-1);
// 设置当前的日期为 15
// in.set(Calendar.DAY_OF_MONTH, 15);
//add 添加
in.add(Calendar.DAY_OF_MONTH, 31);
System.out.println(in.get(Calendar.DAY_OF_MONTH));
}
}

1.2.4. SimpleDateFormat 类
模式：
1. 时间 / 日期格式化的类，但是该类是一个抽象类。
2. 使用的子类 SimpleDateFormat 。
3. 概念 ：
① 格式化
日期 --> 字符串
② 解析
字符串 --> 日期
4.SimpleDateFormat :
① 构造方法 ：
SimpleDateFormat(String pattern)
** 模式 ：
y 年
M 月
d 日
H 0-23 小时
m 分钟
s 秒
建议 ： 解析或者格式化时，最好使用同一个模式。
**② 常用方法：
1 》 format( 时间 ) 格式化 时间 -- 》字符串
2 》 parse(str) 解析 字符串 -- 》时间
代码演示：

public class DateFormat 类 {
public static void main(String[] args) throws ParseException {
// SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
SimpleDateFormat sf=new SimpleDateFormat("yyyy 年 MM 月 dd 日 HH 时 mm 分 ss 秒 ");
// 将日期格式化为字符串 format(date)
// String value = sf.format(new Date());
//2019 年 04 月 02 日 16 时 25 分 48 秒 --> 转成日期格式： 解析 ： 字符串 --> 日期格式 parse(str) 将字符串解析为
日期格式
Date valueP = sf.parse("2019 年 04 月 02 日 16 时 25 分 48 秒 ");
System.out.println(valueP);
}
}

1.2.5. 练习之计算出生日期距今天数
代码演示：

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

课程内容
1. 输入出生的年月日，算出距离今天你出生了多少天？
思路 ：
① 字符串 -- 》 转换为时间 -- 》出生的日期
② 出生到现在的毫秒值？
③ 换算该毫秒值为天数。
*/
public class Topic1 {
public static void main(String[] args) throws ParseException {
Scanner sc=new Scanner(System.in);
System.out.println(" 请输入您的出生日期 格式为 : yyyy 年 MM 月 dd 日 HH 时 mm 分 ss 秒 ");
//2019 年 03 月 29 日 00 时 00 分 00 秒
// 获取出生日期的字符串
String birth = sc.nextLine();
// 将字符串转换为时间
SimpleDateFormat sf=new SimpleDateFormat("yyyy 年 MM 月 dd 日 HH 时 mm 分 ss 秒 ");
// birth-->date 字符串转时间 解析
Date birthTime = sf.parse(birth);
// 出生到现在的毫秒值 现在的毫秒值 - 出生的毫秒值 getTime() 获取毫秒值
long time=new Date().getTime()-birthTime.getTime();
System.out.println(time/1000/3600/24);
}
}