java基础之设计模式

1 设置模式之单例设计模式

概念:保证一个类仅有一个实例,并提供一个访问它的全局访问点。

(1)饿汉式:

/*** @Description 饿汉式* @author refuel* @version v1.0*/
public class TestSingleton{public static void main(String[] args) {Singleton sing = Singleton.getInstance(); sing.show();}
}
class Singleton {	//1、将构造器私有化private Singleton() {}//2、定义创建一个私有对象 private static Singleton Sing = new Singleton();//3、定义公共静态方法返回该类类型的对象 public static Singleton getInstance() {return Sing;}
}

(2)饱汉式,线程不安全

/*** @Description 饱汉式,线程不安全* @author refuel* @version v1.0*/
public class TestSingleton{public static void main(String[] args) {Singleton sing = Singleton.getInstance(); sing.show();}
}
class Singleton {	//1、将构造器私有化private Singleton() {}//2、定义创建一个私有对象 private static Singleton Sing;//3、定义公共静态方法返回该类类型的对象 public static Singleton getSingleton() {if(Sing == null) {Sing = new Singleton();}return Sing;}
}

 

2 设置模式之工厂模式

2.1 简单工厂

简单工厂模式其实不是一个设计模式,反而比较像一种编程习惯。主要我们定义一个非常简单的类主要负责帮我们生产不同的产品。例子如下:

/*** @Description 简单工厂* @author refuel* @version v1.0*/
public class SimpleFactory {//④使用工厂方法,通过传递类型信息来获取实体类的对象public static void main(String[] args) {Factory1 w = new Factory1();//获取Student1Work的对象,并调用他的doWork方法Product1 product = w.getExamples("Student1Work");product.show();//获取Teacher1Work的对象,并调用他的doWork方法Product1 product1 = w.getExamples("Teacher1Work");product1.show();//获取Worker1Work的对象,并调用他的doWork方法Product1 product2 = w.getExamples("Worker1Work");product2.show();}}//①创建一个 Product接口
interface Product1{void show();
}
// ②实现Product 接口的实体类
class Student1 implements Product1 {@Overridepublic void show() {System.out.println("学生学习");}	
}
class Teacher1 implements Product1 {@Overridepublic void show() {System.out.println("老师教书育人");}	
}
class Worker1 implements Product1 {@Overridepublic void show() {System.out.println("工人建高楼大厦");}	
}
//③定义工厂类 生成基于给定信息的实体类的对象
class Factory1 {//使用getExamples方法获取工作性质类型的对象public Product1 getExamples(String workType) {if(workType ==null) {return null;}if(workType.equalsIgnoreCase("Student1Work")) {return new Student1();}else if(workType.equalsIgnoreCase("Teacher1Work")) {return new Teacher1();}else if(workType.equalsIgnoreCase("Worker1Work")) {return new Worker1();}return null;}
}

2.2 工厂方法模式

简单工厂模式有一个缺点是不同的产品需要不同的额外参数的时候,是不支持的,而且如果使用时传递的type、Class出错,将不能得到正确的对象,容错率不高。而多方法的工厂模式为不同产品,提供不同的生产方法,使用时 需要哪种产品就调用该种产品的方法,使用方便、容错率高。

工厂方法模式概念:定义一个用于创建对象的接口,但是让子类决定将哪一个类实例化。工厂父类负责定义创建产品对象的公共接口,而工厂子类则负责生成具体的产品对象,目的是将产品类的实例化操作延迟到工厂子类中完成,即通过工厂子类来确定究竟应该实例化哪一个具体产品类

何时使用:主要解决接口选择的问题,我们明确地计划不同条件下创建不同实例时。

/*** @Description 工厂模式* @author refuel* @version v1.0*/
public class FactoryPattern {public static void main(String[] args) {Factory2 s = new StudentFactory2();s.getExamples().show();Factory2 t = new TeacherFactory2();t.getExamples().show();Factory2 w = new WorkerFactory2();w.getExamples().show();}}//①创建一个 Product接口
interface Product2{void show();
}
// ②实现Product 接口的实体类
class Student2 implements Product2 {@Overridepublic void show() {System.out.println("学生学习");}	
}
class Teacher2 implements Product2 {@Overridepublic void show() {System.out.println("老师教书育人");}	
}
class Worker2 implements Product2 {@Overridepublic void show() {System.out.println("工人建高楼大厦");}	
}
//③定义一个工厂接口
interface Factory2 {Product2 getExamples();
}
//④定义一个学生工厂接口
class StudentFactory2 implements Factory2 {public Product2 getExamples() {return new Student2();}
}
//⑤定义一个老师工厂接口
class TeacherFactory2 implements Factory2 {public Product2 getExamples() {return new Teacher2();}
}
//⑥定义一个工人工厂接口
class WorkerFactory2 implements Factory2 {public Product2 getExamples() {return new Worker2();}
}

2.3 抽象工厂模式

为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类。

抽象工厂模式,他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于,工厂方法模式针对的是一个产品等级结构;而抽象工厂模式则是针对的多个产品等级结构。通常一个产品结构,表现为一个接口或者抽象类,也就是说,工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类,而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

/*** @Description 抽象工厂模式* @author refuel* @version v1.0*/
public class AbstractFactoryPattern {public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {AbstractFactory sbstractFactory = SuperFactory.getFactory("com.refuel.factory.StudentFactory");Product SmallStudent = sbstractFactory.getExamples("com.refuel.factory.SmallStudent");SmallStudent.show();}}//最高级抽象产品,用于抽象工厂的建造方法的返回值
abstract class Product{abstract void show();
}
//学生产品类
abstract class StudentProduct extends Product{}
//小学生产品
class SmallStudent extends StudentProduct{public void show() {System.out.println("小学生");}		
}//中学生产品
class MiddleStudent extends StudentProduct{public void show() {System.out.println("小学生");}		
}
//老师产品类
abstract class TeacherProduct extends Product{}
//数学老师产品
class MathTeacher extends TeacherProduct{public void show() {System.out.println("数学老师");}		
}//历史老师产品
class HistoryTeacher extends TeacherProduct{public void show() {System.out.println("历史老师");}		
}//超级工厂类
class SuperFactory {public static AbstractFactory getFactory(String type) throws ClassNotFoundException, InstantiationException, IllegalAccessException {Class cl = Class.forName(type);System.out.println("创建工厂" + type);return (AbstractFactory) cl.newInstance();}
}
//抽象工厂类
abstract class AbstractFactory {protected abstract Product getExamples(String type) throws ClassNotFoundException, InstantiationException, IllegalAccessException;
}//学生工厂类,覆盖所有学生的生产方法
class StudentFactory extends AbstractFactory{public Product getExamples(String type) throws ClassNotFoundException, InstantiationException, IllegalAccessException {Class cl = Class.forName(type);return (StudentProduct)cl.newInstance();}
}
//老师工厂类,覆盖所有老师的生产方法
class TeacherFactory extends AbstractFactory{public Product getExamples(String type) throws ClassNotFoundException, InstantiationException, IllegalAccessException {Class cl = Class.forName(type);return (TeacherProduct)cl.newInstance();}
}

2.4 简单工厂模式,工厂模式与抽象工厂模式的比较

简单工厂模式:(1)优点:工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖。(2)缺点:没有遵守开放—封闭原则(开放接口,封闭修改)。如果将来需要添加一个产品,那么,在简单工厂模式中,就必须在简单工厂类中添加相应的判断语句,这对程序的扩展本身就不利。

工厂模式:(1)优点 1、一个调用者想创建一个对象,只要知道其名称就可以了。 2、扩展性高,如果想增加一个产品,只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现,调用者只关心产品的接口。(2)缺点每次增加一个产品时,都需要增加一个具体类和对象实现工厂,使得系统中类的个数成倍增加,在一定程度上增加了系统的复杂度,同时也增加了系统具体类的依赖。这并不是什么好事。

抽象工厂模式:(1)优点:能够从多个产品族的多个产品中,简洁的获取想要的具体产品。解决了工厂模式中的不符合开闭原则的问题(增加新的产品时候,不修改工厂,而是增加工厂)。(2)缺点:产品族扩展比较困难,要增加一个系列的某一产品,要增加具体的产品类,还要增加对应的工厂类(或者修改对应产品族的工厂类)。产品族难扩展,产品等级易扩展。】

 

3 代理模式

提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。如果需改别人写好的代码时,可以通过代理的方式来扩展该方法。

3.1 静态代理

静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类。

/*** @Description 静态代理* @author refuel* @version v1.0*/
public class TestProxy {public static void main(String[] args) {//客户租房子,找代理ProcyObject proxy = new ProcyObject(new SubjectImpl());proxy.action();}
}
//接口
interface Subject{void action();
}
//中介(代理)
class ProcyObject implements Subject {//中介和业主有关系,所以定义关联关系SubjectImpl subject = null;public ProcyObject(SubjectImpl subject) {this.subject = subject;}@Overridepublic void action() {//调用业主的方法,自己没有subject.action();}}
//业主
class SubjectImpl implements Subject{@Overridepublic void action() {System.out.println("业主的房子");}}

 

3.2 动态代理

动态代理也叫做:JDK代理,接口代理。代理对象不需要实现接口,但是目标对象一定要实现接口。代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)。

代理类所在包:java.lang.reflect.Proxy,JDK代理使用newProxyInstance方法。

/*** @Description 动态代理* @author refuel* @version v1.0*/
public class DynamicProxy {public static void main(String[] args) {//目标对象Subject1 s = new SubjectImpl1();//给目标对象创建代理对象,内存中动态生成的代理对象Subject1 proxy = (Subject1)new ProxyFactory(s).getProxyInstance();proxy.action();}
}interface Subject1 {void action();
}/*** @Description 业主类* @author refuel* @version v1.0*/
class SubjectImpl1 implements Subject1 {@Overridepublic void action() {System.out.println("业主的房子");}}/*** @Description 代理工厂类* @author refuel* @version v1.0*/
class ProxyFactory {// 中介和业主有关系,所以定义关联关系,来维护一个目标对象Object subject = null;public ProxyFactory(Object subject) {this.subject = subject;}// 给目标对象生成一个代理对象public Object getProxyInstance() {// ClassLoader loader:指定当前对象使用类加载器,获取类加载器的方法是固定的// Class<?>[] interfaces:目标对象实现的接口类型,使用泛型方式确认// InvocationHandler h:事件处理,执行目标对象时,会触发事件处理器的方法,会把当前执行的目标对象作为的方法作为参数传入return Proxy.newProxyInstance(subject.getClass().getClassLoader(), subject.getClass().getInterfaces(),new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("开始事务");// 执行目标对象方法Object invokeValue = method.invoke(subject, args);System.out.println("提交事务");return invokeValue;}});}
}

 

3.3 Cglib代理

Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。静态代理和动态代理模式都是要求目标对象实现一个接口,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候就可以使用以目标对象子类的方式类实现代理,这种方法就叫做:Cglib代理。

/*** @Description Cglib类* @author refuel* @version v1.0*/
public class CglibProxy {public static void main(String[] args) {//目标对象SubjectImpl2 target = new SubjectImpl2();//代理对象SubjectImpl2 proxy = (SubjectImpl2)new ProxyFactory(target).getProxyInstance();//执行代理对象的方法proxy.action();}
}
/*** @Description 业主类,目标对象,没有实现任何接口* @author refuel* @version v1.0*/
class SubjectImpl2 {public void action() {System.out.println("业主的房子");}
}
/*** @Description Cglib子类代理工厂,对SubjectImpl2在内存中动态创建一个子类对象* @author refuel* @version v1.0*/
class ProxyFactory implements MethodInterceptor{// 中介和代理有关系,所以定义关联关系,来维护一个目标对象Object subject = null;public ProxyFactory(Object subject) {this.subject = subject;}// 给目标对象创建一个代理对象public Object getProxyInstance() {//1.工具类Enhancer en = new Enhancer();//2.设置父类en.setSuperclass(subject.getClass());//3.设置回调函数en.setCallback(this);//4.创建子类(代理对象)return en.create();}@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {System.out.println("开始");//执行目标对象的方法Object returnValue = method.invoke(subject, args);System.out.println("提交");return returnValue;}}

2.4 静态代理,动态代理,Cglib代理的比较

静态代理:(1)优点:可以做到在不修改目标对象的功能前提下,对目标功能扩展.。(2)缺点:因为目标对象要与代理对象实现一样的接口,所以会产生很多的代理类,导致类太多。接口增加方法,目标对象与代理对象都要进行维护。

动态代理:(1)优点:由于java封装了newProxyInstance这个方法的实现细节,所以使用起来非常方便。(2)缺点:静态代理和JDK代理有一个共同的缺点,就是目标对象必须实现一个或多个接口

Cglib代理:(1)优点:目标对象与代理对象都不用实现接口。(2)缺点:因为没有使用接口,所以系统的耦合性没有使用JDK的动态代理好。

在Spring的AOP编程中,如果加入容器的目标对象有实现接口,用JDK代理,如果目标对象没有实现接口,用Cglib代理

 

4 策略模式(Strategy Pattern)

4.1 什么是策略模式

针对一组算法,将每一种算法(策略类)都封装到具有共同接口的独立类中,从而他们可以相互替换,可以在不影响客户端的情况下发生改变,从而改变不同的功能。

一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

特点:封装变化的概念;面向接口编程(编程中使用接口而不是使用具体的实现类)。

组成部分:(1)抽象策略角色:是抽象的角色,一般使用接口或抽象类实现,如Comparator接口;

(2)具体策略角色:包装了具体的算法和行为,如一组实现了Comparator接口的实现类;

(3)环境角色:内部有一个抽象角色的引用,给客户端调用,如TreeSet类,内部一定有一个策略类的一个成员变量,这样在创建TreeSet对象的时候可以接收向它传递的具体的策略类。

4.2 为什么使用策略模式

在有多种算法相似的情况下,使用 if...else 所带来的复杂和难以维护。算法可以自由切换,扩展良好;不过策略类会增多,还要对外暴露。

4.3 什么情况下可以使用

(1)如果一个系统中有很多的类,他们之间的区别是他们的行为不同,就可以用策略模式让一个对象在那么多的行为中选择一种;

(2)一个系统需要动态的在几种算法中实现一种。

如果一个系统的策略多于四个,就需要考虑使用混合模式,解决策略类膨胀的问题。

4.4 案例

实现List集合增删查的功能

编写步骤:(1)定义抽象策略角色(定义一个策略对象的公共接口);(2)编写具体策略角色(实现抽象策略角色这个公共接口);(3)定义环境变量(内部一定要持有一个策略类的引用)。

(1) 定义抽象策略角色:

/*** @Description 定义抽象策略角色* @author refuel* @version v1.0*/
public interface AbstarctStrategy<T> {//实现对List集合的操作public Boolean handle(List<T> list,T t);
}

(2)编写具体策略角色

/*** @Description 定义增加策略* @author refuel* @version v1.0*/
public class AddStrategy<T> implements AbstarctStrategy<T> {//实现handle方法,完成增加元素操作@Overridepublic Boolean handle(List<T> list, T t) {return list.add(t);}}/*** @Description 定义删除策略* @author refuel* @version v1.0*/
public class RemoveStrategy<T> implements AbstarctStrategy<T> {//实现handle方法,完成删除元素操作@Overridepublic Boolean handle(List<T> list, T t) {return list.remove(t);}}/*** @Description 定义查询策略* @author refuel* @version v1.0*/
public class QueryStrategy<T> implements AbstarctStrategy<T> {//实现handle方法,完成查看元素是否存在操作@Overridepublic Boolean handle(List<T> list, T t) {return list.contains(t);}}

(3)定义环境变量

/*** @Description 环境角色* @author refuel* @version v1.0*/
public class Environment<T> {//策略类的引用private AbstarctStrategy<T> strategy;public Environment(AbstarctStrategy<T> strategy) {this.strategy = strategy;}public Boolean handleList(List<T> list,T t) {return strategy.handle(list, t);}
}

(4)测试

/*** @Description 测试类* @author refuel* @version v1.0*/
public class Test {public static void main(String[] args) {Environment<Integer> en = new Environment<>(new AddStrategy<Integer>());List<Integer> arrList = Arrays.asList(10,20,30,40,50);List<Integer> list = new ArrayList<>(arrList);en.handleList(list, 60);for (Integer i : list) {System.out.print(i + " ");  //运行结果 10 20 30 40 50 60 }}
}

 

 

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/473923.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

数组排序(冒泡、排序)

目前对于数组的排序有主要的两种&#xff0c;一种是选择排序&#xff0c;一种是冒泡排序。当然大学学过数据结构的知道&#xff0c;还有一些其他的排序&#xff0c;这里就不说明了&#xff0c;有时间自己上网查查。其实排序在开发中并不常用&#xff0c; 我们学习它是学一种思想…

LeetCode 1598. 文件夹操作日志搜集器

文章目录1. 题目2. 解题1. 题目 每当用户执行变更文件夹操作时&#xff0c;LeetCode 文件系统都会保存一条日志记录。 下面给出对变更操作的说明&#xff1a; "../" &#xff1a;移动到当前文件夹的父文件夹。如果已经在主文件夹下&#xff0c;则 继续停留在当前文…

Java集合Set,List和Map等

Java集合Set,List和Map等 1 Java集合框架 因为Java是面向对象的语言&#xff0c;对事物的体现都是以对象的形式&#xff0c;为了方便对多个对象的操作&#xff0c;就要对对象进行存储。另一方面&#xff0c;使用Array存储对象方面具有一些弊端 。Java集合就像一个容器&#x…

利用bootstrap框架做了一个采摘节节日活动网页

效果欣赏如下&#xff1a; 总共主要是一下两个块代码&#xff1a; 1.主题&#xff1a; <!DOCTYPE html><html lang"en"><head><meta charset"UTF-8"><meta name"viewport" content"width, initial-scale1.0&qu…

FC网络学习笔记02 -网络配置方法

随着新一代飞机的综合化航电系统对通信需求的不断提高&#xff0c;传统的ARINC429、1553B总线的传输速率分别只有100Kbps和1Mbps&#xff0c;其带宽已远远不 论文联盟 http://Www.LWlm.cOm能满足系统通信的需求&#xff0c;无法为高性能数据处理提供有力的通信支撑。 FC网络是…

LeetCode 1599. 经营摩天轮的最大利润(模拟)

文章目录1. 题目2. 解题1. 题目 你正在经营一座摩天轮&#xff0c;该摩天轮共有 4 个座舱 &#xff0c;每个座舱 最多可以容纳 4 位游客 。你可以 逆时针 轮转座舱&#xff0c;但每次轮转都需要支付一定的运行成本 runningCost 。摩天轮每次轮转都恰好转动 1 / 4 周。 给你一…

1.数据库基本概念知识

数据库 存储数据的仓库 描述一个事物的基本信息 优点: 持久化存储 读写速度极高 保证数据的有效性 RDBMS 当前主要使用两种类型的数据库&#xff1a;关系型数据库、非关系型数据库 所谓的关系型数据库RDBMS&#xff0c;是建立在关系模型基础上的数据库&#xff0c;借助于…

LeetCode 1600. 皇位继承顺序(图的深度优先遍历)

文章目录1. 题目2. 解题1. 题目 一个王国里住着国王、他的孩子们、他的孙子们等等。每一个时间点&#xff0c;这个家庭里有人出生也有人死亡。 这个王国有一个明确规定的皇位继承顺序&#xff0c;第一继承人总是国王自己。我们定义递归函数 Successor(x, curOrder) &#xff…

Java泛型,枚举,注解

Java泛型&#xff0c;枚举&#xff0c;注解 1 泛型 1.1 什么是泛型 泛型&#xff1a;即参数化类型。在不创建新的类型的情况下&#xff0c;通过泛型指定的不同类型来控制形参具体限制的类型。允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值…

2.数据完整性

使用数据类型的原则是&#xff1a;够用就行&#xff0c;尽量使用取值范围小的&#xff0c;而不用大的&#xff0c;这样可以更多的节省存储空间 常用数据类型如下&#xff1a; 整数&#xff1a;int&#xff0c;bit 小数&#xff1a;decimal 字符串&#xff1a;varchar,char 日期…

LeetCode 1601. 最多可达成的换楼请求数目(回溯+剪枝)

文章目录1. 题目2. 解题1. 题目 我们有 n 栋楼&#xff0c;编号从 0 到 n - 1 。每栋楼有若干员工。由于现在是换楼的季节&#xff0c;部分员工想要换一栋楼居住。 给你一个数组 requests &#xff0c;其中 requests[i] [fromi, toi] &#xff0c;表示一个员工请求从编号为 …

3.数据库基本操作

数据库操作&#xff1a; 查看所有数据库 show databases; 使用数据库 use 数据库名; 查看当前使用的数据库 select database(); 创建数据库 create database 数据库名charsetutf8; 例&#xff1a;create database python charsetutf8; 删除数据库 drop database 数据库名…

Nginx + PHP(php-fpm)遇到的502 Bad Gateway错误

我一个统计程序估计要跑1分多钟以上 查看了一个php-fpm 配置文件 [13-Oct-2013 12:06:07] WARNING: [pool www] child 7458, script /home/wwwroot/admin/index.php (request: "GET /index.php") execution timed out (101.515909 sec), terminating [13-Oct-2013 12…

4.数据库(增删改查)备份及恢复

查询所有列 select * from 表名; 例&#xff1a;select * from classes; 查询指定列&#xff0c;可以使用as为列或表指定别名 select 列1,列2,...from 表名; 例&#xff1a;select id,name from classes; 增加 全列插入&#xff1a;值的顺序与表中字段的顺序对应 insert in…

LeetCode 767. 重构字符串(堆)

文章目录1. 题目2. 解题1. 题目 给定一个字符串S&#xff0c;检查是否能重新排布其中的字母&#xff0c;使得两相邻的字符不同。 若可行&#xff0c;输出任意可行的结果。若不可行&#xff0c;返回空字符串。 示例 1: 输入: S "aab" 输出: "aba"示例 2…

5.数据库设计

三范式 经过研究和对使用中问题的总结&#xff0c;对于设计数据库提出了一些规范&#xff0c;这些规范被称为范式 数据库设计中一共有6个范式&#xff0c;一般需要遵守3范式即可 第一范式&#xff08;1NF)&#xff1a;数据库表的每一列都是不可分割的原子数据项&#xff0c;…

minix中atoi、atol、atof的实现

在minix2.0源代码中&#xff0c;有将字符串类型转换为int、long、double类型的函数实现&#xff0c;相关的实现函数分别在atoi.c、atol.c、atof.c文件中&#xff0c;我们来逐一学习其中的源码&#xff1a; 1、int atoi(register const char *nptr) &#xff1a;将字符串类型转换…

LeetCode 729. 我的日程安排表 I(set 二分查找)

文章目录1. 题目2. 解题2.1 set 二分查找2.2 差分思想1. 题目 实现一个 MyCalendar 类来存放你的日程安排。如果要添加的时间内没有其他安排&#xff0c;则可以存储这个新的日程安排。 MyCalendar 有一个 book(int start, int end)方法。 它意味着在 start 到 end 时间内增加…

java基础之lambda表达式

java基础之lambda表达式 1 什么是lambda表达式 lambda表达式是一个匿名函数&#xff0c;允许将一个函数作为另外一个函数的参数&#xff0c;将函数作为参数传递&#xff08;可理解为一段传递的代码&#xff09;。 2 为什么要用lambda表达式 lambda表达式可以写出更简洁更灵…

6.数据查询(条件

查询所有字段select * from 表名; 例&#xff1a;select * from students; 查询指定字段 在select后面的列名部分&#xff0c;可以使用as为列起别名&#xff0c;这个别名出现在结果集中 select 列1,列2,... from 表名; -- 表名.字段名 select students.id,students.name,su…