阿空实训日记——永别牢笼计划第三天

前言

今天正式开始上课了，教室有网线和空调，以后学习就不待在寝室了，老师第一天讲了一些网络知识

---

7月1日 天气晴 25~38℃

1.每日一道算法题

今天做的是 剑指 Offer II 020. 回文子字符串的个数

解题思路 动态规划 递推公式 如果chars[i]==chars[j] 则 dp[i][j]= dp[i+1][j-1] 否则 dp[i][j]=0

 public int countSubstrings(String s) {
        char[] chars = s.toCharArray();
        int length = s.length();
        int answer=0;
        int dp [][] =new int[length+1][length+1];
        // bbaba
        for (int j = 1; j <=length; j++) {

            for (int i = 1; i+j-1 <=length; i++) {

                if (chars[i-1]==chars[i+j-2]){

                    if (j==1||i+1>i+j-2||dp[i+1][i+j-2]==1) {
                        dp[i][i + j - 1] = 1;
                        answer++;
                    }

                }else {
                    dp[i][i+j-1]=0;
                }
            }

        }
        return answer;
    }

2.每日一道面试题
今天学习到的面试题是

Q：深拷贝和前拷贝的区别？
A：深拷贝拷贝的是多层，每一层次的数据都会拷贝，并且深拷贝只拷贝内容，拷贝的两个对象也拥有不同的地址。拷贝出来的对象发生改变时，原来的对象不会发生改变，两者互不影响。
浅拷贝只拷贝一层，更深层次对象级别只拷贝引用地址。当浅拷贝的对象发生改变时，原来的对象也会发生相同的改变。

补充

深拷贝
深拷贝和浅拷贝是指对象的拷贝，一个对象存在两种类型的属性，一种是基本数据类型，一种是引用类型。

深拷贝：即拷贝基本数据类型的值，也会针对实例对象的引用地址所指向的对象进行复制，深拷贝出来的对象，类的内部执行的对象不是同一个深拷贝是一个整个独立的对象拷贝，并且深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。

深拷贝把要复制的对象所引用的对象都复制了一遍。

浅拷贝
浅拷贝浅拷贝将原对象或原数组的引用直接赋给新对象，新数组，新对象／数组只是原对象的一个引用（拷贝后的引用都是指向同一个对象的实例，彼此之间的操作会互相影响）

浅拷贝复制的只是一层的变量，并不会复制深层变量绑定的变量。

当目标对象实现了接口时，Spring AOP会使用JDK动态代理来生成代理对象。JDK动态代理是Java提供的一种基于接口的代理技术。它通过在运行时创建一个实现目标对象接口的代理对象，并将目标对象的方法调用转发到代理对象进行处理。通过动态代理，Spring AOP能够在目标对象的方法执行前、执行后或异常抛出时插入横切逻辑。

示例代码

浅拷贝

  package com.akong.wineguard.model.entity;



import com.akong.wineguard.model.vo.UserInfoVO;
import lombok.Data;

import java.io.Serializable;
import java.util.List;
@Data
public class Comment implements Cloneable {
    private static final long serialVersionUID = 1L;
    UserInfoVO user;

    long commentid;

    long topicid;

    String content;
    String time;
    int  num;

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

  

深拷贝

  public class Comment implements Cloneable {
    private static final long serialVersionUID = 1L;
    UserInfoVO user;

    long commentid;

    long topicid;

    String content;
    String time;
    int  num;

    @Override
    public Object clone() throws CloneNotSupportedException {
        Comment clone = (Comment) super.clone();
        UserInfoVO clone1 =(UserInfoVO) user.clone();
        clone.setUser(clone1);
        return clone;
    }
}


public class UserInfoVO implements Cloneable{


    /**
     * 用户昵称
     */
    private String userName;

    /**
     * 用户简介
     */
    private String userProfile;

    /**
     * 用户头像
     */
    private String userAvatar;


    /**
     * 用户账号
     */
    private String userAccount;

    private static final long serialVersionUID = 1L;

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
   

测试代码

   Comment comment = new Comment();                      
   UserInfoVO  user =new UserInfoVO();                   
   user.setUserName("yhy");                              
   user.setUserProfile("3");                             
   user.setUserAvatar("1");                              
   user.setUserAccount("2");                             
   comment.setUser(user);                                
   comment.setNum(1);                                    
   Comment clone =(Comment) comment.clone();             
   UserInfoVO user1 = clone.getUser();                   
   user1.setUserName("yjx");                             
   clone.setUser(user1);                                 
   System.out.println(clone.getUser().getUserName());    
   System.out.println(comment.getUser().getUserName());  
   输出
   yjx
   yhy

在深拷贝时对象的所有引用类型的对象都必须递归调用 super.clone(); 然后在赋值给 对象属性

总结

提示：这里对文章进行总结：

以上就是今天要讲的内容