什么是多态?
同类型的对象,表现出的不同形态。
多态的表现形式:父类类型 对象名称 = 子类对象;
多态的前提:
Animal.java
package Demo1;
public class Animal {
public void eat(){
System.out.println("动物吃东西");
}
}
Cat.java
package Demo1;
public class Cat extends Animal{
public void eat() {
System.out.println("猫吃鱼");
}
}
AnimalDemo.java
package Demo1;
/*
多态:
同一个对象,在不同时刻表现出来的不同形态
举例:猫
我们可以说猫是猫: 猫 cat = new 猫();
我们也可以说猫是动物: 动物 animal = new 猫();
多态的前提和体现
有继承/实现关系
有方法重写
有父类引用指向子类对象
*/
public class AnimalDemo {
public static void main(String[] args) {
//有父类引用指向子类对象
Animal a = new Cat();
a.eat();
}
}
多态调用成员的特点
Fu f = new Zi();
优势:
弊端:
instanceof
Animal.java
package Duotai;
public class Animal {
private int age;
private String color;
public Animal() {
}
public Animal(int age, String color) {
this.age = age;
this.color = color;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void eat(String food)
{
System.out.println("在吃东西");
}
}
Cat.java
package Duotai;
public class Cat extends Animal {
public Cat() {
}
public Cat(int age, String color) {
super(age, color);
}
public void catchMouse(){
System.out.println("抓老鼠");
}
}
Dog.java
package Duotai;
public class Dog extends Animal{
public Dog() {
}
public Dog(int age, String color) {
super(age, color);
}
public void lookHome(){
System.out.println("在看家");
}
}
Person.java
package Duotai;
public class Person {
private int age;
private String name;
public Person() {
}
public Person(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void keepPet(Animal a, String food)
{
if( a instanceof Dog d )
{
System.out.println(d.getAge()+" 岁 "+d.getColor()+" 的狗两条腿死死的抱住 "+food+" 猛吃");
} else if (a instanceof Cat c) {
System.out.println(c.getAge()+" 岁 "+c.getColor()+" 的猫眯着眼睛侧着头吃 "+food);
}
else
{
System.out.println("这是什么动物 这是废物 宝贝");
}
}
}
Test.java
package Duotai;
public class Test {
public static void main(String[] args) {
Animal a1 = new Dog(2,"黑色");
Animal a2 = new Cat(3,"灰色");
Person p1 = new Person(30,"老王");
Person p2 = new Person(25,"老李");
System.out.println("年龄 "+p1.getAge()+" 的 "+p1.getName()+"养了一只 "+a1.getAge()+" 岁的狗");
p1.keepPet(a1,"肉");
System.out.println("年龄 "+p2.getAge()+" 的 "+p2.getName()+"养了一只 "+a2.getAge()+" 岁的猫");
p2.keepPet(a2,"小鱼干");
}
}
什么是包?
包就是文件夹。用来管理各种不同功能的Java类,方便后期代码维护。
使用其他类的规则
final
权限修饰符
权限修饰符:是用来控制一个成员能够被访问的范围的。
可以修饰成员变量、 方法、构造方法、内部类。
代码块
抽象方法所在的类就是抽象类
抽象方法
●抽象方法:将共性的行为(方法)抽取到父类之后。
由于每一个子类执行的内容是不一样,所以,在父类中不能确定具体的方法体。该方法就可以定义为抽象方法。
●抽象类:如果一个类中存在抽象方法,那么该类就必须声明为抽象类。
public abstract class Pers {
public abstract void work();
}
抽象类和抽象方法的注意事项
Dog.java
package com.itheima;
public abstract class Dog {
public void eat()
{
System.out.println("吃gongliang");
}
public abstract void drink();
}
Hashiqi.java
package com.itheima;
public class Hashiqi extends Dog{
@Override
public void eat() {
System.out.println("吃rou");
}
@Override
public void drink(){
System.out.println("喝水");
}
public void caijia()
{
System.out.println("我在拆家");
}
}
Test.java
package com.itheima;
public class Test {
public static void main(String[] args) {
Dog hh = new Hashiqi();
hh.drink();
}
}
接口的定义和使用
public interface接口名{}
public class类名implements接口名{}
要么重写接口中的所有抽象方法
要么是抽象类
接口和类之间的关系
●类和类的关系
继承关系,只能单继承,不能多继承,但是可以多层继承
●类和接口的关系
实现关系,可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口
●接口和接口的关系
继承关系,可以单继承,也可以多继承
person.java
package Interface;
public class Person {
private String name;
private int Age;
public Person(String name, int age) {
this.name = name;
Age = age;
}
public Person() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return Age;
}
public void setAge(int age) {
Age = age;
}
}
Ydy.java
package Interface;
public abstract class Ydy extends Person{
public Ydy(String name, int age) {
super(name, age);
}
public Ydy() {
}
public abstract void work();
}
Jl.java
package Interface;
public abstract class Jl extends Person{
public Jl(String name, int age) {
super(name, age);
}
public Jl() {
}
public abstract void teach();
}
English.java
package Interface;
public interface English {
public static void English()
{
System.out.println("学英语");
}
}
Pp_Ydy.java
package Interface;
public class Pp_Ydy extends Ydy implements English{
public Pp_Ydy(String name, int age) {
super(name, age);
}
public Pp_Ydy() {
}
@Override
public void work(){
System.out.println("学乒乓球");
}
}
Baskertball_Ydy.java
package Interface;
public class Basketball_Ydy extends Ydy{
public Basketball_Ydy(String name, int age) {
super(name, age);
}
public Basketball_Ydy() {
}
@Override
public void work(){
System.out.println("学篮球");
}
}
Pp_Jl.java
package Interface;
public class Pp_Jl extends Jl implements English{
public Pp_Jl(String name, int age) {
super(name, age);
}
public Pp_Jl() {
}
@Override
public void teach(){
System.out.println("教乒乓球");
}
}
Baskertball_Jl.java
package Interface;
public class Basketball_Jl extends Jl{
public Basketball_Jl(String name, int age) {
super(name, age);
}
public Basketball_Jl() {
}
@Override
public void teach(){
System.out.println("教篮球");
}
}
Test.java
package Interface;
public class Test implements English{
public static void main(String[] args) {
Person p1 = new Pp_Ydy("11",23);
Person p2 = new Pp_Jl("22",45);
Person p3 = new Basketball_Ydy("33",45);
Person p4 = new Basketball_Jl("44",56);
System.out.println(p1.getName()+p1.getAge());
if(p1 instanceof Pp_Ydy){
((Pp_Ydy) p1).work();
}
System.out.println(p2.getName()+p2.getAge());
if(p2 instanceof Pp_Jl){
((Pp_Jl) p2).teach();
}
System.out.println(p3.getName()+p3.getAge());
if(p3 instanceof Basketball_Ydy){
((Basketball_Ydy) p3).work();
}
System.out.println(p4.getName()+p4.getAge());
if(p4 instanceof Basketball_Jl){
((Basketball_Jl) p4).teach();
}
}
}
1.接口代表规则,是行为的抽象。想要让哪个类拥有一个行为,就让这个类实现对应的接口就可以了。
2.当一个方法的参数是接口时,可以传递接口所有实现类的对象,这种方式称之为接口多态。
适配器设计模式
设计模式(Design pattern): 是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。
简单理解:设计模式就是各种套路。
适配器设计模式:解决接口与接口实现类之间的矛盾问题
简单理解:设计模式就是各种套路。
适配器设计模式:解决接口与接口实现类之间的矛盾问题
1.当一个接口中抽象方法过多,但是我只要使用其中一部分的时候,就可以适配器设计模式
2.书写步骤:
编写中间类XXXAdapter,实现对应的接口对接口中的抽象方法进行空实现让真正的实现类继承中间类,并重写需要用的方法为了避免其他类创建适配器类的对象,中间的适配器类用abstract进行修饰
什么是内部类?
类的五大成员:属性、方法、构造方法、代码块、内部类
在一个类的里面,再定义一个类。
举例:在A类的内部定义B类,B类就被称为内部类
package Neibulei;
import Interface.Person;
public class Car {
private String Carname;
private int Carage;
private String Carcolor;
class engine{
private String name;
private int age;
public engine(String name, int age) {
this.name = name;
this.age = age;
}
public engine() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public Car() {
}
public Car(String carname, int carage, String carcolor) {
Carname = carname;
Carage = carage;
Carcolor = carcolor;
}
public String getCarname() {
return Carname;
}
public void setCarname(String carname) {
Carname = carname;
}
public int getCarage() {
return Carage;
}
public void setCarage(int carage) {
Carage = carage;
}
public String getCarcolor() {
return Carcolor;
}
public void setCarcolor(String carcolor) {
Carcolor = carcolor;
}
public void show (){
System.out.println(this.Carname);
engine e = new engine();
System.out.println(e.name);
}
}
package Neibulei;
public class Main {
public static void main(String[] args) {
Car c = new Car();
}
}
创建静态内部类对象的格式:外部类名.内部类名 对象名= new 外部类名.内部类名();
调用非静态方法的格式:先创建对象,用对象调用
调用静态方法的格式: 外部类名.内部类名.方法名();
局部内部类
匿名内部类
package Niming;
public interface Swim {
public abstract void swim();
}
package Niming;
public class Test {
public static void main(String[] args) {
new Swim(){
@Override
public void swim() {
System.out.println("重写了游泳的方法");
}
};
}
}
Java语言主要是做后台服务器开发的,与用户交流很少 所以很少用GUI图形化界面,但是为了前面的知识点相结合,我们做一个小游戏。
大家可以看着 这个大牛的博客:
判断质数
import java.util.Scanner;
public class main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个正整数,我将判断它是否为质数");
int num = sc.nextInt();
System.out.println(isPrime(num));
}
public static boolean isPrime(int num)
{
for(int i =2;i<=Math.sqrt(num);i++)
{
if(num%i ==0)return false;
}
return true;
}
}
自幂数,一个n位自然数等于自身各个数位上数字的n次幂之和
System也是一个工具类,提供了一些与系统相关的方法。
1970年1月1日算C语言的生日
由于时差:
public class main {
public static void main(String[] args) {
System.out.println(System.currentTimeMillis());
}
}
public class main {
public static void main(String[] args) {
int [] arr1 = {
1,2,3,4,5,6,7,8,9,10};
int [] arr2 = new int[10];
//把arr1数组中的数据拷贝到arr2中
//参数一:数据源,要拷贝的数据从哪个数组而来
//参数二:从数据源数组中的第几个索引开始拷贝
//参数三:目的地,我要把数据拷贝到哪个数组中
//参数四:目的地数组的索引。
//参数五:拷贝的个数
System.arraycopy(arr1,0,arr2,0,10);
for (int i = 0; i < arr2.length; i++) {
System.out.print(arr2[i]+" ");
}
}
}
Runtime表示当前虚拟机的运行环境
import java.io.IOException;
public class main {
public static void main(String[] args) throws IOException {
1.获得RunTime的对象
//Runtime r1 = Runtime.getRuntime();
2.exit 停止虚拟机
//Runtime.getRuntime().exit(0);
//System.out.println("看看我执行了吗? ");
//3.获得CPU的线程数
System.out.println(Runtime.getRuntime().availableProcessors());
//4.总内存大小,单位是byte
System.out.println(Runtime.getRuntime().maxMemory()/1024/1024);
//5.虚拟机已经获得总内存 大小
System.out.println(Runtime.getRuntime().totalMemory()/1024/1024);
//6.剩余内存大小
System.out.println(Runtime.getRuntime().freeMemory()/1024/1024);
//7.CMD
Runtime.getRuntime().exec("TIM");//前提是设置好了环境
}
}
Object是Java中的顶级父类。所有的类都直接或间接的继承于Object类。
Object类中的方法可以被所有子类访问,所以我们要学习0bject类和其中的方法。
Object没有成员变量,所以只有空参构造。
Object的成员方法,一共11个,这里我们先学三个。
import java.io.IOException;
public class main {
public static void main(String[] args) {
Object obj = new Object();
String str = obj.toString();
System.out.println(str);//java.lang.Object@7ef20235
}
}
Ctrl+b
,然后Ctrl+F12
搜索 toString
System 是一个类名 选中 Ctrl+B
out 是 System 里的一个静态变量
所以是类名直接调用静态变量
//System. out:获取打印的对象
//printan():方法
比较了地址值。但是地址值对我们来讲不重要,我只想比较内容
那么就要在子类里面重写(Object是父类),Ctrl+insert
点击equals() and hashCode()
,一直点击next,到结束。可以输出下面的内容。
重写之后的equals方法比较的就是对象内部的属性值了。
import java.io.IOException;
import java.util.StringJoiner;
public class main {
public static void main(String[] args) {
String s = "abc";
StringBuilder sb = new StringBuilder("abc");
System.out.println(s.equals(sb));//f
//因为equals方法是被s调用的,而s是字符串
//所以equals要看String类中的
//字符串中的equals方法, 先判断参数是否为字符串
//如果是字符串,再比较内部的属性
//但是如果参数不是字符串,直接返回false
System.out.println(sb.equals(s));//f
//因为equals方法是被sb调用的,而sb是StringBuilder
//所以这里的equals方法要看StringBuilder中的equals方法
//那么在StringBuilder当中,没有重写equals方法
//使用的是Object中的
//在Object当中默认是使用==号比较两个对象的地址:值
//而这里的s和sb记录的地址值是不一样的,所以结果返回false
}
}
把A对象的属性值完全拷贝给B对象,也叫对象拷贝,对象复制
不同的区就是不同服务器。
//2.克隆对象
//细节:
//方法在底层会帮我们创建一个对象,并把原对象中的数据拷贝过去。
//书写细节:
//1.重写Object中的clone方法
//2.让javabean类实现Cloneable接口
//3.创建原对象并调用clone就可以了。
直接拷贝:(浅拷贝)
深克隆:
依旧在串池中寻找。
深克隆的重写:
利用第三方工具来实现深克隆。
//细节:
//1.方法的底层会判断s1是否为null,如果为null,直接返回false
//2.如果s1不为null,那么就利用s1再次调用equals方法
//3.此时s1是Student类型,所以最终还是会调用Student中的equals方法。
// 如果没有重写,比较地址值,如果重写了,就比较属性值。
在Java中,整数有四种类型: byte, short, int, long。
在底层占用字节个数:byte1个字节、short2个字节、int4个字节、long8个字节。
import java.math.BigInteger;
import java.util.Random;
public class main {
public static void main(String[] args) {
Random r = new Random();
BigInteger bg1 = new BigInteger(4,r);
System.out.println(bg1);
}
}
import java.math.BigInteger;
public class main {
public static void main(String[] args) {
//获取一个指定的大整数
BigInteger bg1 = new BigInteger("99999999999999999999999999999999999");
System.out.println(bg1);
}
}
import java.math.BigInteger;
public class main {
public static void main(String[] args) {
//获取一个指定的大整数
BigInteger bg1 = new BigInteger("99999999999999999999999999999999999",11);
System.out.println(bg1);//2529219316325782306555092513018064365
}
}
import java.math.BigInteger;
public class main {
public static void main(String[] args) {
BigInteger bg1 = BigInteger.valueOf(1000);
System.out.println(bg1);
//能取的范围比较小,是在long的取值范围内
System.out.println(Long.MAX_VALUE);
System.out.println(Long.MIN_VALUE);
// 1000
// 9223372036854775807
// -9223372036854775808
}
}
BigInteger构造方法小结
import java.math.BigInteger;
public class main {
public static void main(String[] args) {
BigInteger bg1 = BigInteger.valueOf(1000);
BigInteger bg2 = BigInteger.valueOf(20);
System.out.println(bg1.add(bg2));//1020
System.out.println(bg1.subtract(bg2));//980
System.out.println(bg1.multiply(bg2));//20000
System.out.println(bg1.divide(bg2));//50
BigInteger bg3 = BigInteger.valueOf(21);
BigInteger[] arr = bg1.divideAndRemainder(bg3);
System.out.println(arr[0]);//47
System.out.println(arr[1]);//13
System.out.println(bg2.pow(2));//400
//max
BigInteger bg4 = bg1.max(bg2);
System.out.println(bg4);//1000
System.out.println(bg4 == bg1);//true
System.out.println(bg4 == bg2);//false
int a = bg1.intValue();
System.out.println(a);//1000
System.out.println(bg1.longValue());//1000
System.out.println(bg1.doubleValue());//1000.0
}
}
数据太大,把数据分段,然后分段存到数组中即可
但是电脑的内存是扛不住这么大的内存的,所以是理论值。
数组中最多能存储元素个数: 21亿多
数组中每一位能表示的数字: 42亿多
BigInteger能表示的最大数字为: 42亿的21亿次方
public class main {
public static void main(String[] args) {
System.out.println(0.09+0.01);
System.out.println(0.216-0.1);
System.out.println(0.22*0.1);
System.out.println(0.09/0.1);
// 0.09999999999999999
// 0.11599999999999999
// 0.022000000000000002
// 0.8999999999999999
}
}
发现一个问题,不是我们现实的计算结果 计算机结果不精确。
由于存储都是二进制存储,
BigDecima的作用
import java.math.BigDecimal;
public class main {
public static void main(String[] args) {
//1.通过传递double类型的小数来创建对象
BigDecimal bd1 = new BigDecimal(0.01);
BigDecimal bd2 = new BigDecimal(0.09);
System.out.println(bd1);//0.01000000000000000020816681711721685132943093776702880859375
System.out.println(bd2);//0.0899999999999999966693309261245303787291049957275390625
//这种方式不精确
//2.通过传递字符串表示的小数来创建对象
BigDecimal bd3 = new BigDecimal("0.01");
BigDecimal bd4 = new BigDecimal("0.09");
System.out.println(bd3);//0.01
System.out.println(bd4);//0.09
//3.通过静态方法获取对象
BigDecimal bd6 = BigDecimal.valueOf(10);
System.out.println(bd6);//10
//1.如果要表示的数字不大,没有超过double的取值范围
//2.如果要表示的数字比较大,超出了double的取值范围,建议使用构造方法
//3.如果我们传递的是0~10之间的整数,包含0,包含10,那么方法会返回已经创建好的对象,不会重新new
}
}
import java.math.BigDecimal;
public class main {
public static void main(String[] args) {
//1.加法
BigDecimal bd1 = BigDecimal.valueOf(10.0);
BigDecimal bd2 = BigDecimal.valueOf(3.0);
BigDecimal bd3 = bd1.add(bd2);
System.out.println(bd3);//13.0
//2.减法
BigDecimal bd4 = bd1.subtract(bd2);
System.out.println(bd4);//7.0
//3.乘法
BigDecimal bd5 = bd1.multiply(bd2);
System. out. println(bd5);//30.00
//4.除法
BigDecimal bd6 = bd1.divide(bd2,2, BigDecimal.ROUND_HALF_UP);
//点击ROUND_HALF_UP 然后Ctrl+b
//BigDecimal bd6 = bd1.divide(bd2,2,RoundingMode.HALF_UP);
System. out. println(bd6);//3.33
}
}
先爽一下正则表达式
正则表达式可以校验字符串是否满足一定的规则,并用来校验数据格式的合法性。
需求:假如现在要求校验一一个qq号 码是否正确。
规则 :6位及20位之内,0不能在开头,必须全部是数字。
先使用目前所学知识完成校验需求
然后体验一下正则表达式检验。
import java.math.BigDecimal;
public class main {
public static void main(String[] args) {
String qq = "1234868790";
System.out.println(checkQQ(qq));
}
public static boolean checkQQ(String qq){
int len = qq.length();
if(len <6|| len >20) {
return false;}
if(qq.charAt(0) == '0'){
return false;}
for (int i = 0; i < len; i++) {
char c= qq.charAt(i);
if(c <'0'||c >'9') return false;
}
return true;
}
}
正则表达式:
public class main {
public static void main(String[] args) {
String qq = "1234868790";
System.out.println(qq.matches("[1-9]\\d{5,19}"));
}
}
//校验用户名是否满足规则
//校验密码是否满足规则
//校验身份证是否满足规则
//校验手机是否满足规则
正则表达式的作用
作用一:校验字符串是否满足规则
作用二:在一段文本中查找满足要求的内容
import java.math.BigDecimal;
public class main {
public static void main(String[] args) {
//只能是a b c
System.out.println("---------1------------");
System.out.println("a" .matches("[abc]")); // true
System.out.println("z" .matches("[abc]")); // false
System.out.println("ab".matches("[abc]")); // false 大括号中只能出现一个
System.out.println("ab".matches("[abc][abc]")); //true
//不能出现a b c
System.out.println("-------------2-----------");
System.out.println("a" .matches("[^abc]")); // false
System.out.println("z" .matches("[^abc]")); // true
System.out.println("zz".matches("[^abc]")); //false
System.out.println("zz".matches("[^abc][^abc]")); //true
//a到z A到Z (包括头尾的范围)
System.out.println("-----------3-----------");
System.out.println("a" .matches("[a-zA-z]")); // true
System.out.println("z" .matches("[a-zA-Z]")); // true
System.out.println("aa".matches("[a-zA-Z]")); //false
System.out.println("zz".matches("[a-zA-Z]")); //false
System.out.println("0" .matches("[a-zA-Z]")); //false
// [a-d[m-p]] a到d,或m到p
System. out . println("----------4-------------");
System . out .println("a".matches("[a-d[m-p]]")); //true
System. out . println("d".matches("[a-d[m-p]]")); //true
System. out . println("m".matches("[a-d[m-p]]")); //true
System. out . println("p".matches("[a-d[m-p]]")); //true
System. out . println("e".matches("[a-d[m-p]]")); //false
System. out . println("0".matches("[a-d[m-p]]")); //false
// [a-z&&[def]] a-z和def的交集。为: d, e, f
System.out.println("------------5-----------");
System.out.println("&".matches("[a-z&[def]]")); //true
//细节:如果要求两个范围的交集,那么需要写符号&&
//如果写成了一个&,那么此时&表示就不是交集了,而是一个简简单单的&符号
System.out.println("a".matches("[a-z&&[def]]")); //false
System.out.println("d".matches("[a-z&&[def]]")); //true
System.out.println("0".matches("[a-z&&[def]]")); //false
// [a-z&&[^bc]] a-z和非bc的交集。(等同于[ad-z])
System.out.println("----------6---------");
System.out.println("a".matches("[a-z&&[^bc]]")); //true
System.out.println("b".matches("[a-z&&[^bc]]")); //false
System.out.println("0".matches("[a-z&&[^bc]]")); //false
// [a-z&&[^m-p]] a到z和除了m到p的交集。 (等同于[a-lq-z])
System .out.println("-----------7-------------");
System. out.println("a". matches("[a-z&&[^m-p]]")); //true
System .out.println( "m".matches("[a-z&&[^m-p]]")); //false
System. out.println( "0".matches("[a-z&&[^m-p]]")); //false
}
}
import java.math.BigDecimal;
public class main {
public static void main(String[] args) {
// \ 转义字符 改变后面那个字符原本的含义
//练习:以字符串的形式打印一个双引号
// .表示任意一个字符
System. out. println("-------------------------");
System. out. println("你". matches( "..")); //false
System. out. println("你a".matches( ".."));//true
// \\d只能是任意的一位数字
//简单来记:两个\表示一个\
System. out. println("-------------------------");
System. out. println("a". matches("\\d")); // false
System. out. println("3" . matches("\\d")); // true
System. out. println("333".matches("\\d")); // false
// \\w只能是一位单词字符[a-zA-Z_0-9]
System. out. println("-------------------------");
System. out. println("z" .matches( "\\w")); // true
System. out. println("2" .matches( "\\w")); // true
System. out. println("21".matches( "\\w")); // false
System .out. println("你".matches( "\\w")); //false
//非单词字符
System. out. println("-------------------------");
System .out.println("你" .matches("\\W")); // true
System. out. println("-------------------------");
// 以上正则匹配只能校验单个字符。
//必须是数字字母下划线至少6位
System. out. println("2442fsfsf".matches("\\w{6,}" ));//true
System .out .println( "244f" . matches( "\\W{6,}"));//false
// 必须是数字和字符 必须是4位
System. out. println("-------------------------");
System. out .println( "23dF" .matches("[a-zA-Z0-9]{4}"));//true
System .out. println("23_ F" .matches("[a-zA-Z0-9]{4}"));//false
System. out .println( "23dF" .matches("[\\w&&[^_]]{4}"));//true
System .out .println("23_ F". matches("[\\w&&[^_]]{4}"));//false
}
}
需求:
请编写正则表达式验证用户输入的手机号码是否满足要求。
请编写正则表达式验证用户输入的邮箱号是否满足要求。
请编写正则表达式验证用户输入的电话号码是否满足要求。
public class main {
public static void main(String[] args) {
//心得:
//拿着一个正确的数据,从左到右依次去写。
//分成三部分:
//第一部分: 1表示手机号码只能以1开头
//第二部分: [3-9] 表示手机号码第二位只能是3-9之间的
//第三部分: \\d{9} 表示任意数字可以出现9次,也只能出现9次
String regex1 = "1[3-9]\\d{9}";
System. out. println("13112345678" . matches (regex1));//true
System. out. println( "13712345667" . matches(regex1));//true
System. out. println( "13945679027" . matches(regex1));//true
System. out. println( "139456790271" . matches(regex1));//false
}
}
public class main {
public static void main(String[] args) {
//座机电话号码
//020-2324242 02122442 027-42424 0712-3242434
//思路:
//在书写座机号正则的时候需要把正确的数据分为三部分
//-:区号0\\d{2,3}
// 0:表示区号一定是以e开头的
// \\d{2,3}:表示区号从第二位开始可以是任意的数字,可以出现2到3次。
//二: -?表示次数,e次或一次
//三: 号码号码的第 一位也不能以e开头, 从第二位开始可以是任意的数字,号码的总长度: 5-19位
String regex2 = "0\\d{2,3}-?[1-9]\\d{4,9}";
System.out.println("020-2324242" . matches(regex2));//true
System.out.println("02122442" . matches (regex2));//true
System.out.println("027-42424" . matches (regex2));//true
System.out.println("0712-3242434" .matches (regex2));//true
}
}
public class main {
public static void main(String[] args) {
//邮箱号码
//3232323@qq. com [email protected] d1ei0009@163. com d1ei0009@pci. com.cn
//思路:
//在书写邮箱号码正则的时候需要把正确的数据分为三部分
//第一部分: @的左边\\W+
// 任意的字母数字下划线,至少出现一次就可以了
//第二部分: @只能出现一次
//第三部分:
// 3.1 .的左边[\\w&&[^_]]{2,6}
// 任意的字母加数字,总共出现2-6次(此时不能出现下划线)
// 3.2 . \\.
//大写字母,小写字母都可以,只能出现2-3次[a-zA-Z]{2,3}
//我们可以把3.2和3.3看成一组,这一组可以出现1次或者两次
String regex3 = "\\w+@[\\w&&[^_ ]]{2,6}(\\.[a-zA-z]{2,3}){1,2}";
System . out. println("[email protected]" . matches (regex3));
System . out. println("[email protected]" . matches (regex3));
System. out . println("[email protected]" . matches(regex3));
System. out . println("[email protected]" . matches(regex3));
}
}
下载anyrule 不用自己写了
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class main {
public static void main(String[] args) {
String str = "Java自从95年问世以来,经历了很多版本,目前企业中用的最多的是Java8和Java11, " +
"因为这两个是长期支持版本,下一个长期支持版本是Java17,相信在未来不久Java17也会逐渐登上历史舞台";
//1.获取正则表达式的对象
Pattern p = Pattern.compile("Java\\d{0,2}");
//2.获取文本匹配器的对象
//拿着m去读取str,找符合p规则的子串
Matcher m = p.matcher(str);
//3.利用循环获取
while(m. find()) {
String s = m.group();
System.out.println(s);
}
}
}
全世界的时间,有一个统一的计算标准——格林尼治时间/格林威治时间(Greenwich Mean Time)简称GMT
计算核心:地球自转一天是24小时,太阳直射时为正午12点
全世界的时间,有一个统一的计算标准——原子钟
利用铯原子的震动的频率计算出来的时间,作为世界标准时间(UTC)。
Date类是一个JDK写好的Javabean类,用来描述时间,精确到毫秒。
利用空参构造创建的对象,默认表示系统当前时间。
利用有参构造创建的对象,表示指定的时间。
public Date( ) 创建Date对象,表示当前时间
public Date(long date) 创建Date对象,表示指定时间
public void setTime(long time) 设置/修改亳秒值
public long getTime( ) 获取时间对象的毫秒值
学会掌握上述方法
import java.util.Date;
public class main {
public static void main(String[] args) {
Date d1 = new Date(0L);
Long time = d1.getTime();
time = time+ 1000L*60*60*24*365;
d1.setTime(time);
System.out.println(d1);
}
}
比较两个时间谁在前
import java.text.SimpleDateFormat;
import java.util.Date;
public class main {
public static void main(String[] args) {
SimpleDateFormat sdf1 = new SimpleDateFormat();
Date d1 = new Date(0L);
String str1 = sdf1.format(d1);
System.out.println(str1);//1970/1/1 08:00
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String str2 = sdf2.format(d1);
System.out.println(str2);//1970年01月01日 08:00:00
}
}
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class main {
public static void main(String[] args) throws ParseException {
String str = "2222-02-22 02:22:22";
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = sdf1.parse(str);
System.out.println(date);//Fri Feb 22 02:22:22 GMT+08:00 2222
}
}
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class main {
public static void main(String[] args) throws ParseException {
//1.获取日历对象
//细:1: Calendar是一个抽象类,不能直接new,而是通过一个静态方法获取到子类对象
//底层原理:
//会根据系统的不同时区来获取不同的日历对象,默认表示当前时间。
//把会把时间中的纪元,年,月,日,时,分,秒,星期,等等的都放到一个数组当中
//细节2:11月份:范围0~11 如果获取出来的是0.那么实际上是1月。
//星期:在老外的眼里,星期日是一周中的第- -天.
//1 (星期日) 2 (星期一)3 (星期二)4 (星期三)5 (星期四)6 (星期五)7 (星期六)
Calendar c= Calendar.getInstance();
Date d = new Date(0L);
c.setTime(d);
System.out.println(c);
int year = c.get(1);
int month = c.get(2) + 1;
int date = c.get(5);
System. out. println(year + "," + month + "," + date);//1970, 1,1
}
}
JDK8新增时间相关类
ZoneId:时区
Instant:时间戳
ZoneDateTime:带时区的时间
DateTimeFormatter用于时间的格式化和解析
LocalDate:年、月、日
LocalTime:时、分、秒
LocalDateTime:年、月、日、时、分、秒
Duration:时间间隔(秒,纳秒)
Period:时间间隔(年, 月,日)
ChronoUnit:时间间隔( 所有单位)
包装类:用一个对象,把基本数据类型给包起来
public class main {
public static void main(String[] args) {
//二进制
String str1 = Integer.toBinaryString(123);
System.out.println(str1);
//八进制
String str2 = Integer.toOctalString(123);
System.out.println(str2);
//十六进制
String str3 = Integer.toHexString(123);
System.out.println(str3);
// 1111011
// 173
// 7b
}
}
import java.util.Scanner;
public class main {
public static void main(String[] args) {
//键盘录入
Scanner sc = new Scanner(System.in);
System. out. println("请输入一个字符串");
/* String str = sc.next();
System. out. print1n(str);*/
//弊端:
//当我们在使用next,nextInt, nextDouble在接收数据的时候,遇到空格,回车,制表符的时候就停止了
//键盘录入的是123123那么此时只能接收到空格前面的数据
//我想要的是接收- -整行数据
//约定:
//以后我们如果想要键盘录入,不管什么类型,统一使用nextLine
//特点遇到回车才停止
String str = sc.nextLine();
System.out.println(str);
}
}
文章浏览阅读6.1k次。1、先通过显示器直接连接的方式连接到那台连接出错的服务器上。登陆以后,在桌面上的此电脑图标上面点右键,选择属性。2、然后在属性页面中我们可以看到对应的系统版本是Windows Server 2016。CPU是intel xeon型号,内存是16g。这个时候我们点击它左上角的远程设置。3、在远程设置界面,我们可以看到,它默认的设置是允许远程到这台服务器上,但是它下面勾选了”仅允许运行使用网络级别身份..._远程桌面服务无法加入服务器 win-th0hfpjn9vr 上的连接代理。 错误: 当前异步消息
文章浏览阅读109次。Special Sponsors我们组织了一个开源互助平台,方便开源组织和大 V 互相认识,互相帮助,整合资源。请回复这个帖子并注明组织/个人信息来申请加入。请回复这个帖子来推荐希望翻译的内容。如果大家遇到了做得不错的教程或翻译项目,也可以推荐给我们。我们会联系项目的维护者,一起把...
文章浏览阅读182次。记者 | 伍洋宇 袁伟腾编辑 | 文姝琪1李楠打算年底换份新工作,Python方向的、纯软件岗位,发挥空间更大的全栈开发工程师就很不错,目标月薪一万二。这使得他在今年下半年开始系统学习Python。因为本科是计算机专业,期间也自学过Python这门语言,李楠选择了继续自学。学Python真的有用吗?“当然有用啦,没用谁去学它啊。”今年24岁、刚刚毕业一年的李楠这么说。目前他在一家智能硬件公司做嵌入式开发软件工程师,月薪一万,工作是“往硬件里面写软件”,他觉得太枯燥了。“代码都是写好的,基..
文章浏览阅读2.9k次。一、安装R只需要一步命令:sudo apt-get install r-base二、升级R版本第一步给Ubuntu指定PPA:sudo add-apt-repository ppa:marutter/rrutter第二步:sudo apt-get update第三步:sudo apt-get upgrade三、安装Rstudio直接去Rstudio官网下载最新版的Rst..._marutter-ubuntu-rrutter-focal.list
文章浏览阅读9.1k次。Redis5.0集群搭建RedisCluster_rediscluster搭建 5.0
文章浏览阅读405次。多线程和单线程线程不是越多越好,假如你的业务逻辑全部是计算型的(CPU密集型),不涉及到IO,并且只有一个核心。那肯定一个线程最好,多一个线程就多一点线程切换的计算,CPU不能完完全全的把计算能力放在业务计算上面,线程越多就会造成CPU利用率(用在业务计算的时间/总的时间)下降。但是在WEB场景下,业务并不是CPU密集型任务,而是IO密集型的任务,一个线程是不合适,如果一个线程在等待数据时,把CPU的计算能力交给其他线程,这样也能充分的利用CPU资源。但是线程数量也要有个限度,一般线程数有一个公式:最佳启_面向过程的程序设计是把计算机程序视为一系列的命令集合
文章浏览阅读78次。储能8串电池,输出是2个C口,2个USBA口,功率是C1:140W,C2:100W,A1:18W,A2:18W.A1,A2不降功率,使用IP2736,IP2723T,IP2163,_pl56002
文章浏览阅读2k次。Python最新版是一款功能强大脚本编程软件。Python最新版它可以帮助编程人员更加便捷的进行代码编写,适合完成各种高层任务,兼容所有的操作系统中使用,因为它的便捷性,在程序员中得到广泛的应用,新入门的编程学习者可以使用它快速学习,欢迎前来下载!功能特点1、简单易学Python极其容易上手,因为Python有极其简单的说明文档 。2、免费开源Python是FLOSS(自由/开放源码软件)之一。3..._手机版python官网下载
文章浏览阅读3.9k次。欢迎大家光临我的博客!对坦克大战项目的解析:一、游戏模块主要是:注册模块、登录模块、我方模块、和敌方模块。①注册模块:可以跳转到登录界面!②登录模块:可以跳转到游戏界面!③我方模块:可以前后左右移动,可以发射子弹,可以死亡销毁。④敌方模块:可以可以发射子弹,追踪我方的位置,也可以随机出现,可以死亡销毁。 二、所用到的技术①键盘事件 //敌我双方通过键盘上下左右键的移动②位移 ...
文章浏览阅读3.6k次,点赞46次,收藏54次。进程和线程的状态_linux线程状态
文章浏览阅读1.1k次,点赞22次,收藏20次。免费领取项目源码,请关注●点赞●收藏并私信博主,谢谢~本系统以实际运用为开发背景,通过系统管理员可以对所有的学生和教师等人员以及学生相关联的一些学生管理、分配任务、完成任务、打卡签到、师生交流等数据信息进行统一的管理,方便资料的保留。教师和学生可以通过注册,然后登录到系统当中,对分配任务、完成任务、打卡签到以及师生交流这些信息进行查询管理。总的来说,系统的前台是通过Java页面展示,后台使用SSM这个框架,数据库采用目前流行的开源关系型数据库MYSQL。
文章浏览阅读1.2k次,点赞39次,收藏34次。群晖作为大容量存储系统,既可以作为个人的私有存储设备,也可以放在小型企业中作为数据中心使用。其强大的数据存储和管理功能,让其还能够胜任更多任务。但由于群晖的应用场景所限,这些功能通常只能在局域网内实现,想要让群晖NAS存储的数据能在公网访问到,我们可以借助cpolar的辅助,轻松实现在公共互联网访问内网群晖NAS上的数据。在这之前,我们还是需要了解下cpolar的基本操作方式。_在群晖nas安装cpolar套件