lengjingbuliaoyidian
文章15
标签7
分类7
建造者模式

建造者模式

建造者模式(Builder Pattern)

  • 概述:主要目的是将一个复杂对象的构建过程与其表示相分离,从而可以创建具有不同表示形式的对象。(使得同样的构造过程可以创建不同的表示)

结构:

建造者模式包含以下几个主要角色:

  1. 抽象建造者(Builder):规定了实现复杂对象的哪些部分的创建,并不设计具体的部件对象的创建。

  2. 具体建造者(Concrete Builder):实现抽象建造者接口,完成复杂产品的各个部件的具体创建方法。在构建过程完成之后,提供产品的实例。

  3. 产品(Product):要构建的复杂对象。产品类通常包含多个部分或属性。

  4. 指导者(Director):负责调用具体建造者的方法来构建产品,指导者并不了解具体的构建过程,只关心产品的构建顺序和方式

-Bike产品.java

public class Bike{
private String frame;
private String seat;

public String getFrame(){
return frame;
}
public void setFrame(String frame){
this.frame=frame;
}
public String getSeat(){
return seat;
}
public void setSeat(String seat){
this.seat=seat;
}
}
  • Builder抽象建造者.java

    public abstract class Builder{

    protected Bike bike=new Bike();

    public abstract void buildFrame();
    public abstract void buildSeat();

    //返回建造产品

    public abstract Bike createBike();

    }
  • 具体建造者1.java

        public class MobikeBuider extends Builder {
    @Override
    public void builerFrame() {
    bike.setFrame("摩拜碳钎维车架");
    }

    @Override
    public void builerSeat() {
    bike.setSeat("摩拜真皮车座");

    }

    @Override
    public Bike createBike() {
    return bike;
    }
    }
  • 具体建造者2.java

    public class OfoBuilder extends Builder{
    @Override
    public void builerFrame() {
    bike.setFrame("Ofo铝合金车架");
    }

    @Override
    public void builerSeat() {
    bike.setSeat("Ofo橡皮车座");

    }

    @Override
    public Bike createBike() {
    return bike;
    }
    }
  • 指导者(Director).java

    private Builder builder;

    public Direactor(Builder builder){
    this.builder=builder;
    }
    public Bike construct(){
    builder.buildFrame();
    builder.buildSeat();
    return builder.createBike();

    }
  • 总结:

  1. 指挥者用于指导具体构建者如何构建产品,控制调用的先后顺序,并向调用者返回完整的产品类,但是有些情况下需要简化系统结构,就可以把指挥者类和抽象建造者进行合并。
   public  abstract class Builder {
/*
Builder 构造器相当于一个构建成品的骨架蓝图
*/
//声明Bike类型的变量
protected Bike bike = new Bike();

public abstract void builerFrame();

public abstract void builerSeat();

public abstract Bike createBike();

public Bike build(){
this.builerFrame();
this.builerSeat();
return this.createBike();
}
}
  1. 这样做确实简化了系统结构,但是同时家中了抽象建造者类的职责,也不太符合单一职责原则,如果construct过于复杂,建议还是封装到Director中。

使用场景:

  • 需要生成的对象具有复杂的内部结构。
  • 需要生成的对象内部属性相互依赖。

优点

分离构建过程和表示,使得构建过程更加灵活,可以构建不同的表示。
可以更好地控制构建过程,隐藏具体构建细节。
代码复用性高,可以在不同的构建过程中重复使用相同的建造者。

缺点

如果产品的属性较少,建造者模式可能会导致代码冗余。
增加了系统的类和对象数量。

原型模式

原型模式

原型模式(Prototype Pattern)

  • 概述:
    原型模式(Prototype Pattern)是创建型模式,用于当创建对象的成本高时,通过复制一个现有对象来创建一个新对象,从而避免创建一个新对象的 。
    这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时,则采用这种模式。例如,一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象,在下一个请求时返回它的克隆,在需要的时候更新数据库,以此来减少数据库调用。
  • 结构:
    • 抽象原型类:定义了一个克隆自身的接口,即规定了具体原型对象必须实现的clone()方法。
    • 具体原型类:实现抽象原型类的clone()方法,它是可被复制的对象。
    • 客户端类:使用具体原型类中的clone()方法来克隆新的对象。
  • 实现:
    原型模式的克隆分为:浅克隆和深克隆。
  1. 浅克隆创建一个新对象,新对象的属性和原来对象完全相同,对于非基本类型属性,任指向原有属性所指向的对象的内存地址。
  2. 深克隆:创建一个新对象,属性中引用的其他对象也会被克隆,不会指向原有对象地址。
  • 注意:Java中的Object类提供了clone()方法,该方法返回一个对象,该对象是当前对象的一个副本。
    • 浅克隆:调用Object类的clone()方法。
    • 深克隆:
      1. 实现Cloneable接口。
      2. 重写clone()方法。
      3. 在clone()方法中,使用super.clone()方法创建一个新对象,然后将当前对象的属性值复制到新对象中。
      4. 如果属性是引用类型,需要递归调用clone()方法。

在Java中,原型模式(Prototype Pattern)是一种创建型设计模式,它允许通过复制现有对象来创建新对象,而不是通过新建类实例的方式。在实现原型模式时,我们通常会使用clone()方法,而复制对象时就会涉及到浅克隆(Shallow Clone)和深克隆(Deep Clone)的概念。

浅克隆(Shallow Clone)

浅克隆是指当复制一个对象时,对于基本数据类型的成员变量,会直接复制其值;而对于引用类型的成员变量,则只复制其引用地址(也就是内存地址),而不会复制引用所指向的实际对象。因此,在浅克隆中,原始对象和克隆对象中的引用类型成员变量将指向同一个对象。
在Java中,通过实现Cloneable接口并重写Object类的clone()方法来实现浅克隆。Object类的clone()方法默认实现就是浅克隆。
示例代码:

class Address {
private String city;
public Address(String city) {
this.city = city;
}
// getter and setter
}
class Person implements Cloneable {
private String name;
private Address address;
public Person(String name, Address address) {
this.name = name;
this.address = address;
}
// getter and setter
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone(); // 浅克隆
}
}
// 使用
Address address = new Address("Beijing");
Person p1 = new Person("Tom", address);
Person p2 = (Person) p1.clone();
// 此时,p1和p2的address引用指向同一个Address对象
System.out.println(p1.getAddress() == p2.getAddress()); // true

深克隆(Deep Clone)

深克隆是指复制对象时,不仅复制对象本身,而且递归复制对象所引用的其他对象。因此,深克隆会复制整个对象网络,使得原始对象和克隆对象之间互不影响,它们拥有各自独立的内存空间。
实现深克隆的方式有多种:

  1. 重写clone()方法,并在其中对引用类型进行递归克隆(需要引用类型也实现Cloneable接口并重写clone()方法)。
  2. 使用序列化(Serialization)和反序列化(Deserialization)来实现深克隆。将对象写入到字节流中,然后再从字节流中读取回来,这样会创建一个完全独立的副本。
    示例代码(通过重写clone方法实现深克隆):
    class Address implements Cloneable {
    private String city;
    public Address(String city) {
    this.city = city;
    }
    // getter and setter
    @Override
    protected Object clone() throws CloneNotSupportedException {
    return super.clone();
    }
    }
    class Person implements Cloneable {
    private String name;
    private Address address;
    public Person(String name, Address address) {
    this.name = name;
    this.address = address;
    }
    // getter and setter
    @Override
    protected Object clone() throws CloneNotSupportedException {
    Person cloned = (Person) super.clone();
    // 对引用类型单独克隆
    cloned.address = (Address) address.clone();
    return cloned;
    }
    }
    // 使用
    Address address = new Address("Beijing");
    Person p1 = new Person("Tom", address);
    Person p2 = (Person) p1.clone();
    // 此时,p1和p2的address引用指向不同的Address对象
    System.out.println(p1.getAddress() == p2.getAddress()); // false

序列化实现深克隆

如果引用类型嵌套层次很深,或者引用类型没有实现Cloneable接口,则可以通过序列化的方式实现深克隆。需要确保所有涉及的类都是可序列化的(实现Serializable接口)。
示例代码:

import java.io.*;
class Address implements Serializable {
private String city;
public Address(String city) {
this.city = city;
}
// getter and setter
}
class Person implements Serializable {
private String name;
private Address address;
public Person(String name, Address address) {
this.name = name;
this.address = address;
}
// getter and setter
public Person deepClone() throws IOException, ClassNotFoundException {
// 序列化
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
// 反序列化
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return (Person) ois.readObject();
}
}
// 使用
Address address = new Address("Beijing");
Person p1 = new Person("Tom", address);
Person p2 = p1.deepClone();
System.out.println(p1.getAddress() == p2.getAddress()); // false

总结

  • 浅克隆:复制基本数据类型的值,对于引用类型,只复制引用地址,因此原对象和克隆对象会共享引用类型的成员变量。修改其中一个对象的引用类型成员变量,另一个对象也会受到影响。
  • 深克隆:复制基本数据类型的值,同时递归复制引用类型的对象。因此,原对象和克隆对象之间完全独立,互不影响。
    在实际应用中,选择浅克隆还是深克隆取决于具体需求。如果对象的引用类型成员变量在创建后不会改变,或者你希望共享这些对象,那么浅克隆就足够了,并且效率更高。如果需要完全独立的副本,则应该使用深克隆。但要注意深克隆可能带来的性能问题,特别是在对象图很大的情况下。

关键区别总结

特性 浅克隆 深克隆
引用类型复制 复制内存地址(共享对象) 递归复制实际对象(完全独立)
修改影响 修改引用类型成员会影响所有副本 修改引用类型成员不影响其他副本
实现复杂度 简单(默认clone() 复杂(需递归处理所有引用类型)
性能 高效(不创建新对象) 较低(递归创建新对象)
适用场景 引用类型不可变或无需隔离时 引用类型需完全隔离时

注意事项

  1. String的特殊性
    虽然String是引用类型,但其不可变性(Immutable)使得浅克隆中修改String值会创建新对象,不会影响原对象(行为类似深克隆)。但其他引用类型(如自定义类)仍需谨慎。
  2. 深克隆的替代方案
    序列化(Serializable)是另一种深克隆实现,但要求所有涉及的对象都实现Serializable接口:
    public static <T> T deepClone(T obj) throws IOException, ClassNotFoundException {
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(bos);
    oos.writeObject(obj);

    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
    ObjectInputStream ois = new ObjectInputStream(bis);
    return (T) ois.readObject();
    }
单例模式

单例模式

Singleton(单例模式)

  1. 意图:
    确保一个类只有一个实例,并提供一个全局访问点来访问该实例

  2. 注意事项

  • 线程安全:getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成实例被多次创建。
  • 延迟初始化:实例在第一次调用 getInstance() 方法时创建。
  • 序列化和反序列化:重写 readResolve 方法以确保反序列化时不会创建新的实例。
  • 反射攻击:在构造函数中添加防护代码,防止通过反射创建新实例。
  • 类加载器问题:注意复杂类加载环境可能导致的多个实例问题。
  1. 结构
    单例模式包含以下几个主要角色:
  • 单例类:包含单例实例的类,通常将构造函数声明为私有。
  • 静态成员变量:用于存储单例实例的静态成员变量。
  • 获取实例方法:静态方法,用于获取单例实例。
  • 私有构造函数:防止外部直接实例化单例类。
  • 线程安全处理:确保在多线程环境下单例实例的创建是安全的。

单例模式的实现

  1. 单例设计模式分类两种:
  • 饿汉式:类加载就会导致该单例实例对象被创建,适用于单线程环境。
  • 懒汉式:类加载不会导致该单例实例对象被创建,而是首次使用该对象时才会创建,适用于多线程环境。

饿汉式——静态成员变量

public class Singleton{
//1. 私有构造方法
private Singleton(){}

//2. 在本类中创建本类对象
private static Singleton instance =new Singleton();

//3. 提供一个公共的访问方式,让外界获取该对象
public static Singleton getInstance(){
return instance;
}
}

测试类

public calss Client{
public static void main(String[] args) {
//创建Singleton对象
Singleton instance = Singleton.getInstance();
Singleton instance1 = Singleton.getInstance();
//判断获取到的两个对象是否是同一个对象
if(instance==instance1){
System.out.println("两个对象是同一个对象");
}else{
System.out.println("两个对象不是同一个对象");
}
}
}
//结果: 两个对象是同一个对象
//原因: 饿汉式是在类加载时就创建了实例对象,所以在多线程环境下也不会出现多个实例的情况。

饿汉式——静态代码块

public class Singleton{
//1. 私有构造方法
private Singleton(){}

//2. 先申明Singleton对象
private static Singleton instance;//null

//3. 在静态代码块中进行赋值——创建Singleton对象
static{
instance = new Singleton();
}

//3. 提供一个公共的访问方式,让外界获取该对象
public static Singleton getInstance(){
return instance;
}
}

饿汉式——枚举

  • 原由:枚举类实现单例模式是极力推荐的单例实现模式,因为枚举类型是线程安全的,并且只会加载一次。而且枚举类型是所用单例实现中唯一不会被破坏的单例实现模式。
public enum Singleton{
INSTANCE;
}

测试类

 public class Client{
public static void main(String[] args){
//创建Singleton对象
Singleton instance = Singleton.INSTANCE;
Singleton instance1 = Singleton.INSTANCE;
System.out.println(instance==instance1);
}
}
// 结果为true,说明是同一个对象
  • 总结:
    优点: 内存中只有一个实例,减少内存开销,尤其是频繁创建和销毁实例时(如管理学院首页页面缓存)。
    避免资源的多重占用(如写文件操作)。
    缺点:饿汉式在类加载时就创建了实例对象,可能造成内存的浪费。

懒汉式——线程不安全情况

public class Singleton{
//1. 私有构造方法
private Singleton(){}

//2. 先申明Singleton对象
private static Singleton instance;//null

//3. 提供一个公共的访问方式,让外界获取该对象
public static Singleton getInstance(){
//首先判断instance是否为null,如果为null,说明还没有创建实例对象,则创建
if(instance==null){
//当有两个线程同时调用getInstance()方法时,线程1等待,线程2获取到了cpu的执行权,也会进入判断里面————》可能会创建多个实例对象,因此需要使用同步锁synchronized --》public static synchronized Singleton getInstance()
instance = new Singleton();
}
//如果instance不为null,则直接返回
return instance;
}
}

测试类


public class Client{
public static void main(String[] args){
//创建Singleton对象
Singleton instance = Singleton.getInstance();
Singleton instance1 = Singleton.getInstance();
//判断获取到的两个对象是否是同一个对象
System.out.println(instance==instance1);
}
}
//结果为ture

懒汉式——线程安全情况

public class Singleton{
//1. 私有构造方法
private Singleton(){}

//2. 先申明Singleton对象
private static Singleton instance;//null

//3. 提供一个公共的访问方式,让外界获取该对象,同时加上synchronized锁保证线程的安全
public static synchronized Singleton getInstance(){
//首先判断instance是否为null,如果为null,说明还没有创建实例对象,则创建
if(instance==null){

instance = new Singleton();
}
//如果instance不为null,则直接返回
return instance;
}
}

懒汉式——双重检查锁

  • 优势:解决了单例、性能、线程安全问题。因为在多线程的情况下,可能会出现空指针问题,出现问题的原因是JVM在实例化对象的时候会进行优化和指令重新排序操作。可以使用 volatile 关键字修饰成员变量和静态成员变量,防止指令重排序。
public class Singleton{
//1. 私有构造方法
private Singleton(){}

//2.声明Singleton对象
public static volatile Singleton instance;

//3.提供一个公共的访问方式,让外界获取该对象
public static Singleton getInstance(){
//第一次判断,如果instance不为null,则直接返回
if(instance==null){
synchronized (Singleton.class){
//第二次判断,如果instance不为null,则直接返回,为空就创建该对象
if(instance==null){
instance=new Singleton();
}
}
}
return instance;
}
}

懒汉式——静态内部类

  • 原由:静态内部类单里模式由内部类创建,由于JVM在加载外部类的过程中,是不会加载静态内部类的,只有内部类的属性、方法被调用时才会被加载,并初始化其静态资源,静态资源由于被static修饰,因此只会被创建一次,并且创建时是线程安全的。
public class Singleton{
//1.私有构造方法
private Singleton(){}
//2.定义一个静态内部类
public static class SingletonHolder{
//在内部类中声明并初始化外部类的对象
private static final Singleton INSTANCE = new Singleton();
}
//3.提供公共的访问方式
public static Singleton getInstance(){
return SingletonHolder.INSTANCE;
}
}

测试类


public class Client{
public static void main(String[] args){
//创建Singleton对象
Singleton instance = Singleton.getInstance();
Singleton instance1 = Singleton.getInstance();
//判断获取到的两个对象是否是同一个对象
System.out.println(instance==instance1);
}
}
结果为ture
  • 说明:第一次加载Singleton类时并不会初始化instance,只有第一次调用getInstance()方法时,虚拟机加载SingletonHolder类并初始化instance,并且instance是static的,因此只会被创建一次。这样不仅能保证线程的安全性,还能保证Singleton类的唯一性。

存在的问题——破坏单例模式

破会啊单例模式:使上面定义的单例类可以创建多个对象,美剧方式除外,有两种方式:序列化和反射。
例子:

  1. 序列化与反序列化
public class Singleton implements Serializable{
//1.私有构造方法
private Singleton(){}
//2.定义一个静态内部类
public static class SingletonHolder{
//在内部类中声明并初始化外部类的对象
private static final Singleton INSTANCE = new Singleton();
}
//3.提供公共的访问方式
public static Singleton getInstance(){
return SingletonHolder.INSTANCE;
}
}

测试类:

public class Client{
public static void main(String[] args) throws Exception {
//writeObject2File(); //执行结果为:C:\\Users\\j.txt 文件创建成功
readObjectFromFile(); //执行结果为:地址1
readObjectF romFile(); //执行结果为:地址2
//说明:序列化和反序列化后的对象不是同一个对象,因此破坏了单例模式。
}
//从文件中读取数据(对象)
public static void readObjectFromFile() throw Exception{
//1.创建输入流对象
ObjectInputStream ois =new ObjectInputStream(new FileInputStream("C:\\Users\\j.txt"));
//2.读取对象
Singleton instance=(Singleton) ois.readObject();
System.out.println(instance);
//3。释放资源
ois.close();
}
//从文件中写数据(对象)
public static void writeObject2File() throws Exception{
//1.获取Singleton对象
Singleton instance = Singleton.getInstance();
//2.创建输出流对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\j.txt"));
//3.写对象
oos.writeObject(instance);
//4.释放资源
oos.close();
}
}
  1. 反射
    public class Client{
    public static void main(String[] args) throws Exception{
    //1.获取Singleton的Class字节码对象
    Class class =Singleton.class;
    //2.获取无参构造方法对象
    Constructor constructor = class.getDeclaredConstructor();
    //3.取消访问检查
    constructor.setAccessible(true);
    //4.通过无参构造方法创建对象
    Singleton instance1 = (Singleton) constructor.newInstance();
    Singleton instance2 = (Singleton) constructor.newInstance();
    //5.判断两个对象是否相等,如果相等,说明反射成功,如果不相等,说明反射失败(破坏了单例模式)
    System.out.println(instance1 == instance2);
    }
    //结果为false
    }

上述问题的解决

1.序列化与反序列化破坏单例模式的解决方法:

  • 在Singleton类中添加readResolve()方法,在序列化时被反射调用,如果定义了这个方法,就返回这个方法的值,反之,就返回新new出来的对象。
    public class Singleton implements Serializable{
    //1.私有构造方法
    private Singleton(){}
    //2.定义一个静态内部类
    public static class SingletonHolder{
    //在内部类中声明并初始化外部类的对象
    private static final Singleton INSTANCE = new Singleton();
    }
    //3.提供公共的访问方式
    public static Singleton getInstance(){
    return SingletonHolder.INSTANCE;
    }
    //4.当进行反序列化时,会自动调用该方法,将该方法的返回值直接返回
    public Object readResolve(){
    return SingletonHolder.INSTANCE;
    }
    }

    测试类:
    public class Client{
    public static void main(String[] args) throws Exception {
    //writeObject2File(); //执行结果为:C:\\Users\\j.txt 文件创建成功
    readObjectFromFile(); //执行结果为:地址1
    readObjectF romFile(); //执行结果为:地址1
    //说明:创建对象时,使用的是同一个对象
    }
    //从文件中读取数据(对象)
    public static void readObjectFromFile() throw Exception{
    //1.创建输入流对象
    ObjectInputStream ois =new ObjectInputStream(new FileInputStream("C:\\Users\\j.txt"));
    //2.读取对象
    Singleton instance=(Singleton) ois.readObject();
    System.out.println(instance);
    //3。释放资源
    ois.close();
    }
    //从文件中写数据(对象)
    public static void writeObject2File() throws Exception{
    //1.获取Singleton对象
    Singleton instance = Singleton.getInstance();
    //2.创建输出流对象
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\j.txt"));
    //3.写对象
    oos.writeObject(instance);
    //4.释放资源
    oos.close();
    }
    }
    2.反射破坏单例模式的解决方法:
    public class Singleton {
    private static boolean flag = false;

    //1.私有构造方法
    private Singleton(){

    synchronized (Singleton.class) {
    //判断flag的值是否为true,
    //如果为true,说明已经创建了对象,直接抛出异常
    //如果为false,说明没有创建对象,创建对象
    if (flag) {
    throw new RuntimeException("不能创建多个对象");
    }
    flag = true;
    }
    }

    //2.定义一个静态内部类
    public static class SingletonHolder{
    //在内部类中声明并初始化外部类的对象
    private static final Singleton INSTANCE = new Singleton();
    }

    //3.提供公共的访问方式
    public static Singleton getInstance(){
    return SingletonHolder.INSTANCE;
    }
    }

    public class Client{
    public static void main(String[] args) throws Exception{
    //1.获取Singleton的Class字节码对象
    Class class =Singleton.class;
    //2.获取无参构造方法对象
    Constructor constructor = class.getDeclaredConstructor();
    //3.取消访问检查
    constructor.setAccessible(true);
    //4.通过无参构造方法创建对象
    Singleton instance1 = (Singleton) constructor.newInstance(); //正常
    Singleton instance2 = (Singleton) constructor.newInstance(); //抛出异常:不能创建多个对象
    //5.判断两个对象是否相等,如果相等,说明反射成功,如果不相等,说明反射失败(破坏了单例模式)
    System.out.println(instance1 == instance2);
    }

    }
工厂模式

工厂模式

工厂模式(Factory Pattern)

在Java中,万物皆对象,这些对象都需要创建,如果创建的时候直接new该对象,就会对该对象耦合严重,又假如我们要更换对象,就要将所有new对象的地方都要需改一遍,这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象,我们就只要和工厂打交道就可以了,彻底和对象解耦,如果要更换对象,直接在工厂中更换对象即可,达到了与对象解耦的目的。所以说,工厂模式最大的优点是:减低耦合。

工厂模式类型

  1. 简单工厂模式(Simple Factory Pattern):不属于23中设计模式,因为违反了开闭原则

简单工厂模式不是一个正式的设计模式,但它是工厂模式的基础。它使用一个单独的工厂类来创建不同的对象,根据传入的参数决定创建哪种类型的对象。

  1. 工厂方法模式(Factory Method Pattern):

工厂方法模式定义了一个创建对象的接口,但由子类决定实例化哪个类。工厂方法将对象的创建延迟到子类。

  1. 抽象工厂模式(Abstract Factory Pattern):

抽象工厂模式提供一个创建一系列相关或互相依赖对象的接口,而无需指定它们具体的类。

简单工厂模式:

  • 结构:
  • 抽象产品:定义了产品的规范,描述了产品的主要特征和功能
  • 具体产品:实现了抽象产品接口,定义了产品的具体功能(实现或者继承了抽象产品的子类)
  • 具体工厂:提供了创建产品的方法,调用者通过该方法来创建产品
  • 步骤 1:
    创建一个接口:Shape.java
    public interface Shape{
    void Shape();
    }
  • 步骤 2:
    创建实现接口的实体类。
    Rectangle.java
    public class Restangle implements Shape{
    @Override
    public void Shape(){
    System.out.println("Rectangle");
    }
    }

Square.java

public class Square implements Shape{
@Override
public void Shape(){
System.out.println("Square");
}
}
  • 步骤 3:
    创建一个工厂,生成基于给定信息的实体类的对象。
    ShapeFactory.java
    public calss ShapeFactory{

    //使用getShape()方法获取到形状类型的对象
    public Shape getShape(String shapeType){
    if(shapeTuype==null){
    return null;
    }
    if(shapeType.equalsIgnoreCase("Rectangle")){
    return new Restangle();
    }
    if(shapeType.equalsIgnoreCase("Square")){
    return new Square();
    }

    }
    }
  • 步骤4:
    使用该工厂,通过传递类型信息来获取实体类对象
    FactoryPatternDemo.java
    public class FactoryPatternDemo{
    public static void main(String[] args){
    ShapeFactory shapeFactory =new ShapeFactory();
    //获取矩形对象,并调用绘制方法
    Shape shape1=shapeFactory.getShape("Rectangle");
    shape1.Shape();

    }
    }
    //结果是:Rectangle

工厂方法模式

  • 结构:
    工厂模式主要包含一下几个主要角色:

  • 抽象产品:定义产品的共同接口或抽象类。它可以是具体产品类的父类或接口,规定了该产品对象的共同方法。

  • 具体产品:实现了抽象产品接口,定义了具体产品的特定行为和属性。

  • 抽象工厂:声明了创建产品的抽象方法,可以是接口或者抽象类,它可以有多个方法用于创建不同类型的产品。

  • 具体工厂:实现了抽象工厂接口,定义了创建具体产品的方法,并返回具体产品对象。

  • 抽象工厂:

    public interface CoffeeFactory{
    //创建Coffee对象的方法
    Coffee createCoffee();

    }
  • 具体工厂:

    public class AmericanCoffeeFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee(){
    return new AmericanCoffee();
    }

    }
    public class LatteCoffeeFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee(){
    return new LatteCoffee();
    }
    }
  • 抽象产品:

    public abstract class Coffee{
    // 抽象方法声明
    public abstract String getName();
    public void addMilk(){
    System.out.println("加奶");
    }
    public void addSugar(){
    System.out.println("加糖");
    }

    }
  • 具体产品:

    public class AmericanCoffee extends Coffee{

    public String getName(){
    return "AmericanCoffee";
    }
    }
    public class LatteCoffee extends Coffee{

    public String getName(){
    return "LatteCoffee";
    }
    }

    中间依赖类:

    public class CoffeeStore{

    private CoffeeFactory factory;

    public void SetFactory(CoffeeFactory factory){
    this.factory=factory;
    }
    //实现点Coffee功能
    public Coffee OrderCoffee(){
    Coffee coffee=factory.CreateCoffee();
    coffee.addMilk();
    coffee.addSugar();
    return coffee;
    }

    }

    Client 测试类

    public class Client{
    public static void main(String[] args){
    //创建咖啡店对象
    CoffeeStore store=new CoffeeStore();
    //创建咖啡工厂对象
    CoffeeFactory factory=new AmericanCoffeeFactory();
    //设置咖啡工厂对象
    store.SetFactory(factory);
    //点咖啡
    Coffee coffee=store.OrderCoffee();

    System.out.println(coffee.getName());
    }
    }
    //结果是:加奶 加糖 AmericanCoffee
  • 工厂方法模式优势:

  1. 解耦:客户端与具体产品类解耦,调用者只需要知道对象的名称即可创建对象。

  2. 扩展性:添加新产品只需新增具体工厂和产品类

  3. 单一职责:每个工厂只负责创建一种产品

  4. 开闭原则:对扩展开放,对修改关闭

  • 工厂方法模式缺点:
  1. 每次增加一个产品时,都需要增加一个具体类和对应的工厂,使系统中类的数量成倍增加,增加了系统的复杂度和具体类的依赖。

抽象工厂模式

抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口,而无需指定具体实现类。通过使用抽象工厂模式,可以将客户端与具体产品的创建过程解耦,使得客户端可以通过工厂接口来创建一族产品。

抽象工厂模式通常涉及一族相关的产品,每个具体工厂类负责创建该族中的具体产品。客户端通过使用抽象工厂接口来创建产品对象,而不需要直接使用具体产品的实现类。

  • 结构:
    抽象工厂模式的主要角色如下:

  • 抽象工厂:提供了创建产品的接口,它包含了多个创建产品的方法,可以创建多个不同等级的产品。

  • 具体工厂:主要是实现抽象工厂中的多个抽象方法,完成具体产品的创建。

  • 抽象产品:定义了产品的规范,描述了产品的主要特性和功能,抽象工厂模式有多个抽象产品。

  • 具体产品:实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间是多对一的关系。

  • 优点:
    确保同一产品族的对象一起工作。
    客户端不需要知道每个对象的具体类,简化了代码。

  • 缺点:
    扩展产品族非常困难。增加一个新的产品族需要修改抽象工厂和所有具体工厂的代码。

  • 适用场景:
    1.当系统需要创建多个相关或依赖的对象,而不需要指定具体类时。
    2.当需要创建的对象是一系列相互关联或相互依赖的产品族时,如电器工厂中的电视机、电冰箱、空调等。
    3.系统中有多个产品族,而系统只消费其中的一族产品。
    4.当一个产品族中的多个对象被设计成一起工作时,需要确保客户端代码不会依赖于具体的产品类。

  • 抽象工厂:

          
    public interface DessertFactory {
    //生产咖啡的功能
    Coffee createCoffee();
    //生产甜品的功能
    Dessert createDessert();
    }
  • 具体工厂:

    //抽象工厂模式 美式风味的甜品工厂:美式咖啡、抹茶慕斯
    public class AmerricanDessertFactory implements DessertFactory {


    @Override
    public Coffee createCoffee() {
    return new AmericanCoffee();
    }

    @Override
    public Dessert createDessert() {
    return new MatchMousse();
    }
    }
//意大利风味甜品工厂:创建意大利风味的咖啡和甜品
public class ItalyDessertFactory implements DessertFactory{

@Override
public Coffee createCoffee() {
return new LatteCoffee();
}

@Override
public Dessert createDessert() {
return new Trimisu();
}
}
  • 抽象产品:
    public abstract class Dessert {
    public abstract void show();
    }
public abstract class Coffee{
// 抽象方法声明
public abstract String getName();
public void addMilk(){
System.out.println("加奶");
}
public void addSugar(){
System.out.println("加糖");
}

}
  • 具体产品:
    public class Trimisu extends Dessert{
    @Override
    public void show() {
    System.out.println("Trimisu");
    }
    }
    public class MatchMousse extends Dessert{
    @Override
    public void show() {
    System.out.println("MatchMousse");
    }
    }
public class AmericanCoffee extends Coffee{

public String getName(){
return "AmericanCoffee";
}
}
public class LatteCoffee extends Coffee{

public String getName(){
return "LatteCoffee";
}
}
  • 测试类:
    public class Client {
    public static void main(String[] args) {
    //创建的是意大利风味甜品工厂对象
    ItalyDessertFactory factory=new ItalyDessertFactory();
    //再从工厂里面获取所需要的产品
    Coffee coffee=factory.createCoffee();
    Dessert dessert=factory.createDessert();

    System.out.println(coffee.getName());
    dessert.show();

    }
    }

    //结果为:LatteCoffee Trimisu

模式扩展:

简单工厂+配置文件接触耦合:
可以通过工厂模式+配置文件的方式可解除工厂对象和产品对象的耦合,在工厂类中加载配置文件的全类名,并创建对象进行存储,客户端如果需要对象,直接进行获取即可。

  • 第一步:定义配置文件
    创建一个配置文件,将产品类全限定名保存在文件中,文件名任意,如:bean.properties
    <bean.properties>
    coffee=com.liuyue.factorymethod.Coffee
    dessert=com.liuyue.factorymethod.Dessert
    american=com.liuyue.factorymethod.AmericanCoffee
    latte=com.liuyue.factorymethod.LatteCoffee
    match=com.liuyue.factorymethod.MatchMousse
    trimisu=com.liuyue.factorymethod.Trimisu
    <bean.properties>

  • 第二部:改进工厂类:

        public class DessertFactory {
            public static Dessert createDessert(String type){
                try {
                    //加载配置文件
                    Properties properties=new Properties();
                    properties.load(new FileInputStream("bean.properties"));
                    //获取type全限定类名
                    String className=properties.getProperty(type);
                    //通过反射创建对象
                    return (Dessert) Class.forName(className).newInstance();
                } catch (Exception e) {
                    e.printStackTrace();
                    return null;
                }
            }
            public static Coffee createCoffee(String type){
                try {
                    //加载配置文件
                    Properties properties=new Properties();
                    properties.load(new FileInputStream("bean.properties"));
                    //获取type全限定类名
                    String className=properties.getProperty(type);
                    //通过反射创建对象
                    return (Coffee) Class.forName(className).newInstance();
                } catch (Exception e) {
                    e.printStackTrace();
                    return null;
                }
            }
        }
        //测试类
        public class Client {
            public static void main(String[] args) {
                //创建的是意大利风味甜品工厂对象
                ItalyDessertFactory factory=new ItalyDessertFactory();
                //再从工厂里面获取所需要的产品
                Coffee  coffee=factory.createCoffee();
                Dessert dessert=factory.createDessert();

                System.out.println(coffee.getName());
                dessert.show();
                //通过简单工厂+配置文件的方式创建对象
                Coffee coffee1=DessertFactory.createCoffee("latte");
                Dessert dessert1=DessertFactory.createDessert("trimisu");
                System.out.println(coffee1.getName());
                dessert1.show();
            }
        }       

















JavaWeb

JavaWeb

Vue

  1. Vue是一款用于构建用户界面的渐进式的JavaScript框架(基于数据渲染成用户能看到的界面)

  2. 使用 ES 模块构建版本​
    在本文档的其余部分我们使用的主要是 ES 模块语法。现代浏览器大多都已原生支持 ES 模块。因此我们可以像这样通过 CDN 以及原生 ES 模块使用 Vue:

     html
     <div id="app">{{ message }}</div>
    
     <script type="module">
       import { createApp, ref } from 'https://unpkg.com/vue@3/dist/vue.esm-browser.js'
    
       createApp({
         setup() {
           const message = ref('Hello Vue!')
           return {
             message
           }
         }
       }).mount('#app')
     </script>
    
     注意我们使用了 <script type="module">,且导入的 CDN URL 指向的是 Vue 的 ES 模块构建版本。
    

vue的常用指令

  1. v-for:列表渲染,遍历容器的元素或者对象的属性

         <body>
             <div id="app">
                 <table border="3px" style="padding: 0; background-color: pink; width: 100px; height: 40px;">
                     <tr v-for="(u,index) in users" :key="index">
                         <!--index是指序号-->
                         <td>{{index +1}}</td>
                         <td>{{u.id}}</td>
                         <td>{{u.name}}</td>
                         <td>{{u.gender ===1?'男':'女'}}</td>
                     </tr>
                 </table>
             </div>
             <script type="module">
                 import { createApp } from 'https://unpkg.com/vue@3/dist/vue.esm-browser.js'
                 createApp({
                     data() {
                         return {
                             users: [
                                 { "id": 1, "name": "张三", "gender": 1 },
                                 { "id": 2, "name": "李四", "gender": 2 },
                                 { "id": 3, "name": "王五", "gender": 1 }
    
                             ]
                         }
    
                     }
                 }).mount('#app');
    
             </script>
    
  2. v-bind: 动态为HTML标签绑定属性值,如设置href css样式等

       注意:动态的为标签的属性绑定值,不能使用差值表达式,得使用v-bind指令。且绑定得数据,必须在data中定义。差值表达式不能出现在标签内部
    
  3. v-if/v-else-if/v-else: 条件性的渲染某元素,判定为true时渲染,否则反之

  4. v-show: 根据条件展示某元素,区别在于切换的是display属性的值

     区别:
          1.v-if="表达式",基于条件判断,来控制创建或移除元素节点(条件渲染)例如<span v-if="gender==1">男生</span> ,适用的场景`不频繁切换得场景`。
          2.v-show="表达式",基于css样式display来控制显示与隐藏,适用的场景`频繁切换显示隐藏得场景`。
    
  5. v-model: 在表单元素上创建双向数据绑定

     <select id="position" name="position" v-model="Searchfrom.job">
     注意:v-model指令用于在表单元素上创建双向数据绑定。
         1. v-model指令用于在表单元素上创建双向数据绑定。
         2. 当表单元素的值发生改变时,绑定的数据也会发生改变。
         3. 当绑定的数据发生改变时,表单元素的值也会发生改变。
    
  6. v-on:为HTML标签绑定事件

       <button type="button" v-on:click="search">查询</button>
       注意:v-on:事件名="方法名",方法名不能加引号,且方法名必须在methods中定义。
    

Ajax

  1. Ajax是一种用于创建快速动态网页的技术,通过在后台与服务器进行少量数据交换,获取服务器响应的数据。Ajax可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下,对网页的某部分进行更新。
    2.异步交互技术Axios:
    1. 是一个基于Promise的HTTP客户端,用于浏览器和Node.js
    2. Axios对原生态的Ajax进行了封装,提供了更加方便的API
    3. 步骤:
      1.安装axios:npm install axios
      2.引入axios:import axios from ‘axios’
      3.发送请求:axios.get(url)
    4. 官网:https://www.axios-http.cn可查看使用情况

Maven使用

  1. maven的作用:

    依赖管理、项目构建、统一项目结构(插件执行框架)

  2. 创建maven项目

  3. 导入maven项目

    建议将要导入的maven项目直接复制到项目目录下

    建议选择maven项目的pom.xml文件进行导入

  4. 依赖配置的方式例如:

             <dependencies>
    
             <dependency>
    
                     <groupId>org.springframework.boot</groupId>
    
                     <artifactId>spring-boot-starter-test</artifactId>
    
                     <scope>test</scope>
    
                 </dependency>
    
             </dependencies>
    
  5. 移除依赖

             <exclusions>
    
                 <exclusion>
    
                     <groupId>org.springframework.boot</groupId>
    
                         <artifactId>spring-boot-starter-test</artifactId>
    
                 </exclusion>
    
             </exclusions>
    
  6. 生命周期

每套生命周期包含一些阶段,阶段都是有顺序的,后面的阶段依赖于前面的阶段

clean(clean阶段):移除上一次构生成的文件

default(compile:编译项目源代码、test:使用合适的单元测试框架进行测试如junit、package:将编译后的文件打包,如jar\\waR等、install:		安装项目到本地仓库)

site(site阶段)

值得注意的是:在同一套生命周期中,当运行后面的阶段时,前面的阶段都会运行

执行指定周期的方式:
1.在ideal中,右侧的maven工具栏,选中对应的生命周期,双击运行

2.在ideal中,找到对应的项目,右键点击open in进入磁盘,用cmd命令行执行对应的生命周期的阶段

例如:mvn clean
  1. 单元测试Junit:

用法:测试类中的方法的正确性

优点(对于main方法而言):测试代码与应用程序代码分开,便于维护;可以自动生成测试报告;一个测试方法执行失败,不影响其他的测试方法。

前置工作:在pom.xml文件中引入Junit的jar包依赖,然后在相应的项目中的main同级中的test文件中编写junit测试类

  1. 断言:

由于测试方法运行不报错,不代表业务方法逻辑没问题,所以通过断言可以检测方法运行结果是否和预期一致,从而判断业务方法的正确性。

    在测试方法中使用断言的方法:

                            Assertions.assertXxxx()

    就是接口的具体实现类,直接以参数的形式写出来
  1. 依赖范围:

         <dependency>
    
             <groupId>org.springframework.boot</groupId>
    
             <artifactId>spring-boot-starter-test</artifactId>
    
         <scope>test</scope>  指定maven的依赖范围,参见的取值有:compile(默认)、test、provided、runtime**
    
         </dependency>
    
  2. maven常见爆红问题解决:

要是依赖下载不成功就会爆红,在maven本地仓库中生成了xxxx.lastUpdated文件,若是该文件不删除,依赖就不会再下载了

方法:
根据maven依赖的坐标,找到仓库中对于的xxxx.lastUpdated文件,删除,删除之后重新加载项目即可
或者在本地仓库中通过命令行的形式,执行del /s *.lastUpdated 批量删除指定目录下面的xxxx.lastUpdated文件,删除之后重新加载项目即可
注意:要是重新加载依赖,依赖下载之后还是爆红,此时可以关闭IDEA,重新打开IDEA加载项目即可

SpringBoot项目创建

  • SpringBoot的官网:spring.io
  • 如何创建Spring web项目:
    社区版IDEA:
    示例:通过插件创建SpringBoot项目

打开 Settings/Preferences,进入 Plugins。

搜索并安装 Spring Assistant 插件。

重启IDEA后,新建项目时选择 Spring Assistant 标签。

按照提示填写项目信息并选择依赖,完成后即可生成SpringBoot项目。

org.springframework.boot spring-boot-starter-web 方法1:使用Spring官方工具

访问 Spring Initializr 网站,选择语言、依赖等配置后生成项目。下载解压后,用IDEA打开即可。

方法2:手动创建Maven项目

在IDEA中创建一个普通的Maven项目。

修改 pom.xml 文件,添加SpringBoot相关依赖。

配置主类和资源文件,如 application.yml。

@SpringBootApplication
public class App {
public static void main(String[] args) {
SpringApplication.run(App.class, args);
}
}
通过以上方法,即使在社区版中也可以顺利开发SpringBoot项目。

Web基础——HTTP协议

  1. HTTP协议特点:
    1.基于TCP协议,面向连接,安全
    2.基于请求——响应模型:一次请求对应一次响应
    3.HTTP协议是无状态的协议:对于事务处理没有记忆功能。每次请求——响应都是独立的
    缺点:多次请求间不能共享数据
    优点:速度快

——所以在Web开发中一般使用会话解决上述多次请求间不能共享数据的问题

  1. HTTP协议——请求数据格式:
    请求行:请求方式、资源路径、协议
    请求头:格式key-value
    请求体:(对于POST请求独有的)存放请求的参数

对于两种不同的请求方式来说请求参数的存放位置是不同的,
GET:请求参数在请求行中,可见安全性不高,没有请求体
POST:请求参数在请求体中,不可见安全性高,POST请求大小是没有限制的

  1. HTTP协议数据获取:
    Web服务器(Tomcat)对HTTP协议的请求数据进行解析,并进行封装到HttpServletRequest,所以可以直接调用Controller方法的时候传递给了该方法。

  2. HTTP响应数据:
    Web服务器(Tomcat)对HTTP协议的请求数据进行解析,并进行封装到HttpServletRseponse ,所以可以直接调用Controller方法的时候传递给了该方法。

Mybatis入门:

mybatis 属于一种持久层框架,用于简化JDBC的开发。 用于数据访问dao持久层

官网:https://mybatis.net.cn/getting-started.html

数据库连接池:是一个容器,负责分配管理数据库连接(Connection),允许应用程序重复使用一个现有的数据库连接,而不是在重新建立一个。同时释放空闲时间超过最大空闲时间的连接,来避免因为没有释放连接而引起的数据库连接遗漏。

切换数据库连接池(又spring boot默认的Hikari的数据库连接池转换到Druid):,优势:资源复用,提升系统的响应速度,使用接口DataSource
1.在pom.xml配置文件中,加入配置信息

<dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
    </dependency>
    2.application.yml配置文件中
spring.datasource.type/url/driver-class-name/username/password

Mybatis中的#号和$号

#{...}:占位符。执行时,会将#{...}替换为?,生成预编译SQL,使用场景为参数值传递,安全性能高:
${...}:拼接符。直接将参数拼接在SQL语句中,存在SQL注入问题,使用场景为表明,字段名动态设置时使用,不安全,性能低

例子:

    @Delete("delete from dept where id=#{id}");
    @Select("selectn id,name,score from ${tableName} order by ${sortField}")    


       
注解和反射

注解和反射

注解的含义:

  • Annotation的作用:不是程序本身,可以对程序做出解释;可以被其他程序(比如:编译器等)读取,注解可以用来修饰类、方法、变量、参数等,可以用来检查代码质量、约束开发者的编程风格、提高代码的可读性和可维护性(检查、约束)。
  • 格式:以“@注释名”在代码中存在,还可以在后面添加一些参数值
  • 使用范围:可以附加在package、class、method、filed等上面,相当于给他们添加了额外的辅助信息,可以通过反射机制编程实现对这些元数据的访问

内置注解:

  • @Override: 定义在java.lang.Override中,此注解只适用于修饰方法,表示一个方法声明打算重写超类中的另外一个方法声明。

  • @Deprecated:定义在Java.lang.Deprecated中,此注解可以用于修饰方法,属性,类,表示不鼓励程序员使用这样的元素(通常事因为它很危险或者存在更好的选择),但是可以此方法可以运行。

  • @SuppressWarnings:定义在Java.lang.SuppressWarnings中,用来抑制编译时的警告信息(后面要有参数才能正确使用),例如:

      @SuppressWarnings("all");
      @SuppressWarnings("unchecked");
      @SuppressWarnings("unchecked","deprecation");
    

元注解:

  • 作用:负责注解其他注解,Java定义了4个标准的meta-annotation类型,他们被用来提供对其他annotation类型作说明。

  • 类型:@Target ,@Retention, @Documented ,@Inherited (这些类型和他们所支持的类在Java。狼。annotation包中可以找到。)

          @Target:用于描述注解的使用范围(即被描述的代码可以用在那些地方)
    
          @Retention:表示需要在说明级别保存该注解信息,用于描述注解的生命周期(Runtime>class>source)
          @Document:说明该注解将被包含在Javadoc 中
          @Inherited:说明子类可以继承父类中的该注解
    
  • 格式:
    @Target(value ={ElementType.METHOD,ElementType.TYPE})
    @Retention(value=RetentionPolicy.RUNTIME)

自定义注解:

  • 用法:使用@interface自定义注解时,自动继承java.lang.annotation.Annotation接口
  • 归纳:
  1. @interface用来声明一个注解,格式:public @interface 注解名{定义内容}
  2. 其中的每一个方法实际上是声明一个配置参数
  3. 方法的名称就是参数的名称
  4. 返回值类型就是参数的类型(返回值只能是基本类型,Class,String,enum)
  5. 可以通过default来声明参数的默认值
  6. 如果只有一个参数成员,一般参数名为value
  7. 注解元素必须要由值,定义注解元素时,经常使用空字符串0作为默认值
  • 代码如下:
    package com.st.test;

    //测试自定义注解

    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;

    public class Test03 {
    //注解可以显示赋值,如果没有默认值(default 数值),我们就必须给注解赋值
    @MyAnnotation2(name=”李明” ,schools ={“湖南大学”,”清华大学”} )
    public void test(){}

    //如果自定义的注解只有一个值的时候可以使用value表示,在方法注解表示的时候可以直接省略value
    @MyAnnotation3(“李明”)
    public void test2(){}
    }

    @Target(value={ElementType.METHOD,ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @interface MyAnnotation2{
    //注解的参数:参数类型+参数名();
    String name() ; //赋值为李明
    int age() default 0;
    int id() default -1; //如果默认值为-1,则代表不存在

    String[] schools();
    }
    @Target(value={ElementType.METHOD,ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @interface MyAnnotation3{
    String value();
    }

java反射

  • 特点:Java不是动态语言,但Java可以称之为“准动态语言”。即Java有一定的动态性,我们可以利用反射机制获得此类似动态语言的特性。Java的动态性让在编程的时候更加灵活!

  • 反射:被视为是动态语言的关键,反射机制允许程序在执行期间借助于’Reflection API’获取任何类的内部信息,并直接操作任意对象的内部属性及方法

           Class c=Class.forName("java.lang.String")
    

    加载完类之后,在堆内存的方法中就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子,通过镜子看到类的结构,所以形象的称为:反射

  • 对比:

  1. 正常的方式:先引用需要的“包类”名称——> 通过new实例化——> 取得实例化对象
  2. 反射方式: 实例化对象——> getClass()方法——> 得到完整的“包类”名称。
  • 反射机制在运行时提供的功能:
  1. 判断任意一个对象所属的类
  2. 可构造任意一个类的对象
  3. 可判断任意一个类所具有的成员变量和方法
  4. 可获取泛型信息
  5. 可调用任意一个对象的成员变量和方法
  6. 可处理注解
  7. 生成动态代理(AOP)
  • 反射使用流程:
  1. 获取class 对象:首先获取目标对象类的class对象

  2. 获取成员信息:通过 class对象,可以获取类的字段、方法、构造器等信息

  3. 操作成员:通过反射API可以读取和修改字段的值、调用方法以及创建对象

  • 反射API:
  1. java.lang.Class:表示类的对象。提供了方法来获取类的字段、方法、构造函数等
  2. java.lang.reflect.Method:表示类的方法。提供了调用方法的能力。
  3. java.lang.reflect.Field:表示类的字段(属性)。提供了访问和修改字段的能力。
  4. java.lang.reflect.Constructor:表示类的构造函数。提供了创建对象的能力。
  • 创建对象的五种方式: new、newInstance、clone、反序列化、反射。

  • 代码:

        package com.st.reflection;
        public class Test002 {
        public static void main(String[] args) throws ClassNotFoundException {
      //通过反射获取类的Class对象
     Class c1=Class.forName("com.st.reflection.User");
      System.out.println(c1);
    
     //查看他们是不是属于同一个类,就可以查看他们的哈希一不一样
      Class c2=Class.forName("com.st.reflection.User");
      Class c3=Class.forName("com.st.reflection.User");
      Class c4=Class.forName("com.st.reflection.User");
     //结果是一样的
      //一个类在内存中只有一个Class对象,一个类被加载之后,类的整个结构都会被封装在Class对象中
      System.out.println(c2.hashCode());
      System.out.println(c3.hashCode());
      System.out.println(c4.hashCode());
       }
    }
      
      //实体类:pojo entity
      class User{
       private String name;
       private int id;
       private  int age;
    
      public User(){
    
       }
      public User(String name, int id, int age) {
      this.name = name;
      this.id = id;
      this.age = age;
      }
    
      public String getName() {
          return name;
      }
    
      public int getId() {
          return id;
      }
    
      public int getAge() {
          return age;
      }
    
      public void setName(String name) {
          this.name = name;
      }
    
      public void setId(int id) {
          this.id = id;
      }
    
      public void setAge(int age) {
          this.age = age;
      }
    
      @Override
      public String toString() {
          return "User{" +
                  "name='" + name + '\'' +
                  ", id=" + id +
                  ", age=" + age +
                  '}';
      }
    }
    

获取Class类的实例

  • 若已知具体的类,通过类的class属性获取,该方法最为安全可靠,程序性能最高

              Class clazz =Person.class;
    
  • 已知一个类的全类名,且该类在类路径下,可通过Class类的静态方法forName()获取,可能抛出ClassNotFoundException

              Class clazz=Class.forName("demo01.Student");
    
  • 已知某个类的实例,调用实例的getClass()方法获取Class对象

              Classclazz=person.getClass();
    
  • 内置基本数据类型可以用类名.TYPE

  • 还可以利用ClassLoader

  • 综合示例:

              package com.st.reflection;
              //测试Class 类的创建方式有哪些
              public class Test003 {
                  public static void main(String[] args) throws ClassNotFoundException {
                      Person person=new Student();
                      System.out.println("这个人是:"+person.name);
    
                      //方式一:通过对象获得
                      Class c1=person.getClass();
                      System.out.println(c1.hashCode());
    
                      //方式二:通过forname获得
                      Class c2 = Class.forName("com.st.reflection.Student");
                      System.out.println(c2.hashCode());
    
                      //方式三:通过类名。class 获得
                      Class<Student> c3 = Student.class;
                      System.out.println(c3.hashCode());
    
                      //方式四:基本内置类型的包装类都有一个Type属性
                      Class c4=Integer.TYPE;
                      System.out.println(c4.hashCode());
    
                      //获取父类类型
                      Class c5=c1.getSuperclass();
                      System.out.println(c5);
    
    
                  }
              }
    
              class Person{
                  public String name;
                  public Person(){
    
                  }
    
                  public Person(String name) {
                      this.name = name;
                  }
    
                  @Override
                  public String toString() {
                      return "Person{" +
                              "name='" + name + '\'' +
                              '}';
                  }
              }
    
              class Student extends Person{
                  public Student(){
                      this.name="学生";
                  }
              }
              class Teacher extends Person{
                  public Teacher() {
                      this.name="老师";
                  }
              }
    

哪些类型可以有Class对象

  1. class:外部类,成员(成员内部类,静态内部类),局部内部类,匿名内部类。
  2. interface:接口
  3. []:数组(多维)
  4. enum:枚举
  5. annotation:注解@interface
  6. primitive type:基本数据类型
  7. void
完全背包问题.md

完全背包问题.md

题目:

  • 有 N 种物品和一个容量是 V 的背包,每种物品都有无限件可用。第 i 种物品的体积是 vi,价值是 wi。

求解将哪些物品装入背包,可使这些物品的总体积不超过背包容量,且总价值最大。

输出最大价值。

输入格式:第一行两个整数,N,V,用空格隔开,分别表示物品种数和背包容积。

接下来有 N 行,每行两个整数 vi,wi,用空格隔开,分别表示第 i 种物品的体积和价值。

输出格式:
输出一个整数,表示最大价值。

数据范围:
0<N,V≤1000
0<vi,wi≤1000

输入样例
4 5
1 2
2 4
3 4
4 5
输出样例:
10

-题解:

1.二维数组:

import java.util.Scanner;
public class Main{
public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    //读取物品得数量和背包得体积
    int N=sc.nextInt();
    int V=sc.nextInt();
    
    // 分别用于存储物品的体积和价值,数组下标从1开始使用,方便对应物品编号
    int[] v=new int[N+1];
    int[] w=new int[N+1];
    for(int i=1;i<=N;i++){
        v[i]=sc.nextInt();
        w[i]=sc.nextInt();
    }
    //定义一个二维dp数组,通过两层循环来填充dp数组,dp[i][j]表示在前i个物品中,背包容量为j时能获得的最大价值
    int[][] dp = new int[N + 1][V + 1];

    // 初始化边界情况,当没有物品可选(i = 0)时,无论背包容量是多少,最大价值都为0
    for (int j = 0; j <= V; j++) {
        dp[0][j] = 0;
    }
    //核心代码:
    for(int i=1;i<=N;i++){
        for(int j=0;j<=V;j++){
            //如果装得下
            if(j>=v[i]){
                dp[i][j]=Math.max(dp[i][j-v[i]]+w[i],dp[i-1][j]);
            }else{
                dp[i][j]=dp[i-1][j];
            }
        }
    }
    System.out.println(dp[N][V]);
}
}

总结:

01背包问题

01背包问题

题目:

  • 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。第 i 件物品的体积是 vi,价值是 wi。

求解将哪些物品装入背包,可使这些物品的总体积不超过背包容量,且总价值最大。
输出最大价值。

输入格式
第一行两个整数,N,V,用空格隔开,分别表示物品数量和背包容积。

接下来有 N 行,每行两个整数 vi,wi,用空格隔开,分别表示第 i 件物品的体积和价值。

输出格式
输出一个整数,表示最大价值。

数据范围
0<N,V≤1000

0<vi,wi≤1000

输入样例
4 5
1 2
2 4
3 4
4 5
输出样例:
8

  • 看会了,就来试一试吧:经典的01背包问题
  • 哈哈哈,祝你的代码状态为:Accepted
  • 要是还不会就看看这几个大佬的视频讲解吧:黑马程序员(多看几遍,多动动手)、代码随想录中的算法公开课
  • 文字版的讲解:代码随想录
  • 题解:创建了二维数组 dp,其中 dp[i][j] 表示在前 i 个物品中,当背包容量为 j 时所能获得的最大价值,通过这样使用二维数组的动态规划方法,全面地考虑了放入和不放入每个物品的各种情况,最终准确地求出满足条件的背包能够装入物品的最大总价值。
  • 代码:

二维数组dp数组

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    // 读取物品数量N和背包容积V
    int N = scanner.nextInt();
    int V = scanner.nextInt();

    // 分别用于存储物品的体积和价值,数组下标从1开始使用,方便对应物品编号
    int[] v = new int[N + 1];
    int[] w = new int[N + 1];
    for (int i = 1; i <= N; i++) {
        v[i] = scanner.nextInt();
        w[i] = scanner.nextInt();
    }

    // dp[i][j]表示在前i个物品中,背包容量为j时能获得的最大价值
    int[][] dp = new int[N + 1][V + 1];

    // 初始化边界情况,当没有物品可选(i = 0)时,无论背包容量是多少,最大价值都为0
    for (int j = 0; j <= V; j++) {
        dp[0][j] = 0;
    }

    // 动态规划核心逻辑,通过两层循环来填充dp数组
    for (int i = 1; i <= N; i++) {
        for (int j = 0; j <= V; j++) {
            if (j >= v[i]) {
                // 如果背包容量j大于等于第i个物品的体积v[i],可以选择放或不放该物品
                // 取放与不放该物品能得到的最大价值
                dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]);
            } else {
                // 如果背包容量j小于第i个物品的体积v[i],无法放入该物品,价值与前i - 1个物品时相同
                dp[i][j] = dp[i - 1][j];
            }
        }
    }

    // 输出在前N个物品中,背包容量为V时能获得的最大价值
    System.out.println(dp[N][V]);

}
}

一维数组:

import java.util.Scanner;
public class KnapsackProblemOneDArray {
public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    // 读取物品数量N和背包容积V
    int N = scanner.nextInt();
    int V = scanner.nextInt();

    // 分别用于存储物品的体积和价值
    int[] v = new int[N + 1];
    int[] w = new int[N + 1];
    for (int i = 1; i <= N; i++) {
        v[i] = scanner.nextInt();
        w[i] = scanner.nextInt();
    }

    // dp[j]表示背包容量为j时能获得的最大价值(使用一维数组进行优化)
    int[] dp = new int[V + 1];

    // 动态规划核心逻辑,通过两层嵌套循环来填充dp数组
    for (int i = 1; i <= N; i++) {
        // 注意这里要从V开始逆序遍历到v[i],避免重复使用更新后的数据
        for (int j = V; j >= v[i]; j--) {
            dp[j] = Math.max(dp[j], dp[j - v[i]] + w[i]);
        }
    }

    // 输出背包容量为V时能获得的最大价值
    System.out.println(dp[V]);
 }
}
不同路径I、II-动态规划

不同路径I、II-动态规划

动态规划的理论基础

  • 总结:动态五部曲
    1.确定dp数组(dp table)以及下标的含义
    2.确定递推公式
    3.dp数组如何初始化
    4.确定遍历顺序
    5.举例推导dp数组
    详细来源:代码随想录

不同路径I

  1. 题目:
  • 一个机器人位于一个 m x n 网格的左上角 (起始点在下图中标记为 “Start” )。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为“Finish” )。问总共有多少条不同的路径?
  1. 公开课:不同路径I
  2. 思路:

-

代码如下:

class Solution {
public int uniquePaths(int m, int n) {
    //定义一个dp的二维数组
    int[][] dp=new int[m][n];
    //初始化dp[i][0]和dp[0][i]
    for(int i=0;i<m;i++){
        dp[i][0]=1;
    }
    for(int i=0;i<n;i++){
        dp[0][i]=1;
    }
    //深推递推公式
   
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            dp[i][j] = dp[i-1][j]+dp[i][j-1];
        }
    }
     return dp[m-1][n-1];
    
}
}
最大子序和-贪心算法

最大子序和-贪心算法

贪心算法的理论基础

最大子序和

  1. 给定一个整数数组 nums ,找到一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。
  • 例如:对于数组 [ -2, 1, -3, 4, -1, 2, 1, -5, 4 ]
  • 它能够找出和最大的连续子数组(子数组是数组中的一个连续部分。在这里是 [ 4, -1, 2, 1 ],其和为 6)
  • 并返回这个最大和的值。
  • Leetcode题目链接

思路

  1. 说实话一开始看到这个题目,脑子的反应就是想用暴力解法,结果一试一试,还真行。哈哈。
  • 思路:暴力解法的思路,第一层 for 就是设置起始位置,第二层 for 循环遍历数组寻找最大值。

代码如下:

class Solution {
public int maxSubArray(int[] nums) {
    int result =Integer.MIN_VALUE;
    int count = 0;
    for (int i = 0; i < nums.length; i++) { // 设置起始位置
        count = 0;
        for (int j = i; j < nums.length; j++) { // 每次从起始位置i开始遍历寻找最大值
            count += nums[j];
            result = count > result ? count : result;
        }
    }
    return result;


}
}
  • 但是时间复杂度:O(n^2)
  • 空间复杂度:O(1),不推荐,还有更好的算法
  1. 那么就是贪心算法(其实也还有其他的解法,例如:dp动态规划)

代码:

class Solution {
public int maxSubArray(int[] nums) {
    if (nums.length == 1){
        return nums[0];
    }
    int sum = Integer.MIN_VALUE; //sum:用于记录在遍历数组过程中找到的最大子数组的和,
    //初始化为 Integer.MIN_VALUE(Java 中 int 类型能表示的最小值),这样可以确保后续在比较和更新最大和时,任何有效的子数组和都能够比初始值大,从而可以正确地更新 sum 的值。
    int count = 0; //count:用于累计当前正在考虑的连续子数组的元素和,初始化为 0,随着遍历数组不断累加元素的值来更新这个累计和
    for (int i = 0; i < nums.length; i++){
        count += nums[i];
        sum = Math.max(sum, count); // 取区间累计的最大值(相当于不断确定最大子序终止位置)
        if (count <= 0){
            count = 0; // 相当于重置最大子序起始位置,因为遇到负数一定是拉低总和
        }
    }
   return sum;
}
}