精华内容
下载资源
问答
  • Java面试要点

    2020-03-25 03:15:05
    i++是线程安全的么? 在局部变量中是线程安全的,因为方法内局部变量是线程私有的 在成员变量中是线程不安全的,因为是多个线程共享的 sql优化应该从哪些方面考虑? 1.如何合理的创建索引 2.怎么使用索引 3....
    1. i++是线程安全的么?
      在局部变量中是线程安全的,因为方法内局部变量是线程私有的 在成员变量中是线程不安全的,因为是多个线程共享的

    2. sql优化应该从哪些方面考虑?
      1.如何合理的创建索引 2.怎么使用索引 3.索引失效 4.合理创建表字段

    3. String属于基本数据类型吗?
      基础类型有8中分别是:int 、double、float、long、char、short、boolean、byte
      String属于对象

    4. 怎么防止前端重复提交?
      提交按钮后屏蔽提交按钮
      前端产生唯一id,后端通过唯一索引
      利用Session防止表单的重复提交

    5. HashMap底层实现原理
      HashMapjdk1.71.8做了一个改变
      jdk1.7HashMap使用的是数组+链表的这么一个数据结构,它的一个 内部类使用的数据节点是Entry节点,在我们数据插入的过程
      它使用的是一个头插法,但是头插法会在我们resize扩容的时候,它会把我们的Entry节点进行一个rehash,会出现链表闭环的情况,导致我们在get的时候造成一个死循环。
      然后在jdk1.8之后因为采用的是尾插法,在扩容的时候会保持链表元素原来的位置,就不会造成链表闭环的情况,所以它就不会造成死循环。
      还有就是当我们在put的过程中,多线程的情况下会造成我put进去的值跟我get获取到的值不一致的情况,造成一个线程的不安全。

    6. 如何保证线程的安全
      使用的是ConcurrentHashMap集合容器
      使用CAS+synchronized

    7. 索引的数据结构
      二叉树,红黑树,hash,B➕树
      二叉树:左边的树节点是小于右边的子节点。
      但是出现数据单边增长的话效率就不高。
      红黑树:红黑树也叫平衡二叉树,如果树的节点过高它会自动平衡,但是如果我们树太高的情况下会消耗我们的磁盘io效率变低,因为如果是最坏的情况可能要从我们的根节点查到我们的叶子节点。所以在大数据量的情况下不推荐使用。
      hash表:hash表在全等查找的时候效率较高,但是如果出现范围查找效率低
      b树:节点中的数据索引从左到右递增排列,但是任然解决不了范围查找的问题
      b➕树:非叶子节点不存储data,只存储索引可以放更多的索引。叶子节点它不存储指针。还有顺序访问指针,提高我们区间查找的能力。
      innodb:聚集索引,把索引和数据保存在一个后缀是idb文件的目录中便于查找
      支持事物 外键 行锁
      myisam:非聚集索引,把索引和数据分成两个文件保存,分别是myd和myi。
      不支持事物 外键
      支持表锁 全文索引

    展开全文
  • java面试要点

    2019-06-22 01:49:00
    基础篇 基本功 面向对象的特征 final, finally, finalize 的区别 int 和 Integer 有什么区别 重载和重写的区别 抽象类和接口有什么区别 说说反射的用途及实现 说说自定义注解的场景及实现 ...session 与 cookie 区别 ...

    基础篇

    基本功

    面向对象的特征
    final, finally, finalize 的区别
    int 和 Integer 有什么区别
    重载和重写的区别
    抽象类和接口有什么区别
    说说反射的用途及实现
    说说自定义注解的场景及实现
    HTTP 请求的 GET 与 POST 方式的区别
    session 与 cookie 区别
    session 分布式处理
    JDBC 流程
    MVC 设计思想
    equals 与 == 的区别

    集合

    List 和 Set 区别
    List 和 Map 区别
    Arraylist 与 LinkedList 区别
    ArrayList 与 Vector 区别
    HashMap 和 Hashtable 的区别
    HashSet 和 HashMap 区别
    HashMap 和 ConcurrentHashMap 的区别
    HashMap 的工作原理及代码实现
    ConcurrentHashMap 的工作原理及代码实现

    线程

    创建线程的方式及实现
    sleep() 、join()、yield()有什么区别
    说说 CountDownLatch 原理
    说说 CyclicBarrier 原理
    说说 Semaphore 原理
    说说 Exchanger 原理
    说说 CountDownLatch 与 CyclicBarrier 区别
    ThreadLocal 原理分析
    讲讲线程池的实现原理
    线程池的几种方式
    线程的生命周期

    锁机制

    说说线程安全问题
    volatile 实现原理
    synchronize 实现原理
    synchronized 与 lock 的区别
    CAS 乐观锁
    ABA 问题
    乐观锁的业务场景及实现方式

    核心篇

    数据存储

    MySQL 索引使用的注意事项
    说说反模式设计
    说说分库与分表设计
    分库与分表带来的分布式困境与应对之策
    说说 SQL 优化之道
    MySQL 遇到的死锁问题
    存储引擎的 InnoDB 与 MyISAM
    数据库索引的原理
    为什么要用 B-tree
    聚集索引与非聚集索引的区别
    limit 20000 加载很慢怎么解决
    选择合适的分布式主键方案
    选择合适的数据存储方案
    ObjectId 规则
    聊聊 MongoDB 使用场景
    倒排索引
    聊聊 ElasticSearch 使用场景

    缓存使用

    Redis 有哪些类型
    Redis 内部结构
    聊聊 Redis 使用场景
    Redis 持久化机制
    Redis 如何实现持久化
    Redis 集群方案与实现
    Redis 为什么是单线程的
    缓存奔溃
    缓存降级
    使用缓存的合理性问题

    消息队列

    消息队列的使用场景
    消息的重发补偿解决思路
    消息的幂等性解决思路
    消息的堆积解决思路
    自己如何实现消息队列
    如何保证消息的有序性

    框架篇

    Spring

    BeanFactory 和 ApplicationContext 有什么区别
    Spring Bean 的生命周期
    Spring IOC 如何实现
    说说 Spring AOP
    Spring AOP 实现原理
    动态代理(cglib 与 JDK)
    Spring 事务实现方式
    Spring 事务底层原理
    如何自定义注解实现功能
    Spring MVC 运行流程
    Spring MVC 启动流程
    Spring 的单例实现原理
    Spring 框架中用到了哪些设计模式
    Spring 其他产品(Srping Boot、Spring Cloud、Spring Secuirity、Spring Data、Spring AMQP 等)

    Netty

    为什么选择 Netty
    说说业务中,Netty 的使用场景
    原生的 NIO 在 JDK 1.7 版本存在 epoll bug
    什么是TCP 粘包/拆包
    TCP粘包/拆包的解决办法
    Netty 线程模型
    说说 Netty 的零拷贝
    Netty 内部执行流程
    Netty 重连实现

    微服务篇

    微服务

    前后端分离是如何做的
    微服务哪些框架
    你怎么理解 RPC 框架
    说说 RPC 的实现原理
    说说 Dubbo 的实现原理
    你怎么理解 RESTful
    说说如何设计一个良好的 API
    如何理解 RESTful API 的幂等性
    如何保证接口的幂等性
    说说 CAP 定理、 BASE 理论
    怎么考虑数据一致性问题
    说说最终一致性的实现方案
    你怎么看待微服务
    微服务与 SOA 的区别
    如何拆分服务
    微服务如何进行数据库管理
    如何应对微服务的链式调用异常
    对于快速追踪与定位问题
    微服务的安全

    分布式

    谈谈业务中使用分布式的场景
    Session 分布式方案
    分布式锁的场景
    分布是锁的实现方案
    分布式事务
    集群与负载均衡的算法与实现
    说说分库与分表设计
    分库与分表带来的分布式困境与应对之策

    安全问题

    安全要素与 STRIDE 威胁
    防范常见的 Web 攻击
    服务端通信安全攻防
    HTTPS 原理剖析
    HTTPS 降级攻击
    授权与认证
    基于角色的访问控制
    基于数据的访问控制

    性能优化

    性能指标有哪些
    如何发现性能瓶颈
    性能调优的常见手段
    说说你在项目中如何进行性能调优

    工程篇

    需求分析

    你如何对需求原型进行理解和拆分
    说说你对功能性需求的理解
    说说你对非功能性需求的理解
    你针对产品提出哪些交互和改进意见
    你如何理解用户痛点

    设计能力

    说说你在项目中使用过的 UML 图
    你如何考虑组件化
    你如何考虑服务化
    你如何进行领域建模
    你如何划分领域边界
    说说你项目中的领域建模
    说说概要设计

    设计模式

    你项目中有使用哪些设计模式
    说说常用开源框架中设计模式使用分析
    说说你对设计原则的理解
    23种设计模式的设计理念
    设计模式之间的异同,例如策略模式与状态模式的区别
    设计模式之间的结合,例如策略模式+简单工厂模式的实践
    设计模式的性能,例如单例模式哪种性能更好。

    业务工程

    你系统中的前后端分离是如何做的
    说说你的
    开发流程
    你和团队是如何沟通的
    你如何进行代码评审
    说说你对技术与业务的理解
    说说你在项目中经常遇到的 Exception
    说说你在项目中遇到感觉最难Bug,怎么解决的
    说说你在项目中遇到印象最深困难,怎么解决的
    你觉得你们项目还有哪些不足的地方
    你是否遇到过 CPU 100% ,如何排查与解决
    你是否遇到过 内存 OOM ,如何排查与解决
    说说你对敏捷开发的实践
    说说你对开发运维的实践
    介绍下工作中的一个对自己最有价值的项目,以及在这个过程中的角色

    软实力

    说说你的亮点
    说说你最近在看什么书
    说说你觉得最有意义的技术书籍
    工作之余做什么事情
    说说个人发展方向方面的思考
    说说你认为的服务端开发工程师应该具备哪些能力
    说说你认为的架构师是什么样的,架构师主要做什么
    说说你所理解的技术专家

    转载自:https://my.oschina.net/xiaomingnevermind/blog/1627558

    展开全文
  • 涵盖java知识点,基础,jvm,并发,锁,分布式等java全面学习面试复习题,可根据每一个点去加强
  • 前言 霸哥好久没有出现了啊!最近霸哥着实很忙,公司的项目一个接一个。这里先感谢大家的持续关注。...根据霸哥多年面试经验来说,最重要、最快能掌握的Java开发技术无非就那几个: Java基础:注解..

    迎战大厂!“金九银十”和秋招通过率达95%的Java面试要点集锦

    前言

    霸哥好久没有出现了啊!最近霸哥着实很忙,公司的项目一个接一个。这里先感谢大家的持续关注。

    这才刚刚进入8月,我就看到了许多朋友在焦急的准备“金九银十”跳槽面试,甚至很多即将毕业的大学生都在备战秋招,对于学历还算优秀的大学生来说,这是一次离大厂最近的机会,毕竟是应届毕业生,不会对技术有非常严格的要求。

    而对于工作了一两年的朋友来说,这段时间加强技术能力,多掌握一些Java核心技术点是重中之重。

    根据霸哥多年面试经验来说,最重要、最快能掌握的Java开发技术无非就那几个:

    • Java基础:注解、反射、异常、序列化、集合等
    • JVM
    • 多线程
    • SSM框架
    • 设计模式
    • 算法
    • 数据库
    • 网络

    迎战大厂!“金九银十”和秋招通过率达95%的Java面试要点集锦

     

    Java入坑与进阶核心技术

    这里我先来讲讲各个年限的程序员需要掌握的技术栈:

    • 入坑0~1年(搬砖码农):Java基础+多线程基础+JVM基础+部分开发工具+SSM框架搭建+网络+算法与数据结构+学习能力;
    • 入坑2~3年(开发工程师):并发编程+JVM+框架源码+设计模式+MySQL调优+熟悉Redis、消息、Nginx、Zookeeper、微服务的使用配置+实战项目经验
    • 入坑4~5年(初探架构师):JVM调优+源码底层机制和原理+深入分布式、缓存、消息、微服务+解决分布式场景问题+高并发实战项目经验+一定项目管理、团队管理经验
    迎战大厂!“金九银十”和秋招通过率达95%的Java面试要点集锦
    XMIND

     

    1、Java基础:JAVA 异常分类及处理、JAVA 反射、JAVA 注解、JAVA 内部类、JAVA 泛型、JAVA 序列化(创建可复用的 Java 对象)、JAVA 复制等。

    迎战大厂!“金九银十”和秋招通过率达95%的Java面试要点集锦

    2、JVM:线程、内存区域、运行时内存(新生代/老年代/永久代)、垃圾回收与算法、JAVA 四种引用类型、GC 垃圾收集器、JVM 类加载机制等。

    迎战大厂!“金九银十”和秋招通过率达95%的Java面试要点集锦

    3、多线程并发:JAVA 线程实现/创建方式、4 种线程池、线程生命周期(状态)、JAVA 后台线程、JAVA锁、线程基本方法、线程池原理、阻塞队列等。

    迎战大厂!“金九银十”和秋招通过率达95%的Java面试要点集锦

    4、SSM框架:Spring 特点、Spring 常用模块、Spring原理、Spring MVC 原理、Mybatis 缓存等。

    迎战大厂!“金九银十”和秋招通过率达95%的Java面试要点集锦

    5、数据库:存储引擎、索引、数据库三范式、数据库事务、数据库并发策略、分区分表等。

    迎战大厂!“金九银十”和秋招通过率达95%的Java面试要点集锦

    6、网络:网络 7 层架构、TCP/IP 原理、HTTP 原理、Netty等。

    迎战大厂!“金九银十”和秋招通过率达95%的Java面试要点集锦

    7、设计模式:设计原则+工厂方法模式、抽象工厂模式等

    迎战大厂!“金九银十”和秋招通过率达95%的Java面试要点集锦

    迎战大厂!“金九银十”和秋招通过率达95%的Java面试要点集锦

    文中截图均来自于已整理好的PDF文档,内容完整,目录清晰,层次分明。需要的朋友扫描【主页左侧二维码或者点击二维码下方超链接】,免费领取!

    总结

    这里没有介绍进阶很深入的技术点,就是为了方便想在“金九银十”突击面试的朋友,能更好更快的掌握在面试场上占据较高分量的技术点。

    当然,如果要达到95%甚至更高的面试通过率,仅仅把上面介绍出来的技术点搞清楚是不够的,你还得把第二张脑图(Xmind图)里面大多数的知识点过一遍,至少可以保证,在简历上多写一些“熟悉”、“掌握”等字眼。

    沉下心来学习,建立一些自己的核心竞争力,才能把面试官摁在自己的手中。

     

    展开全文
  • Java面试要点整理

    千次阅读 2016-06-24 11:13:07
    1. Java的GC的理解 Java GC(Garbage Collection,垃圾收集,垃圾回收)机制,是Java与C++/C的主要区别之一,作为Java开发者,一般不需要专门编写内存回收和垃圾清理代码,对内存泄露和溢出的问题,也不需要像C...

    1.      Java的GC的理解

    Java GC(Garbage Collection,垃圾收集,垃圾回收)机制,是Java与C++/C的主要区别之一,作为Java开发者,一般不需要专门编写内存回收和垃圾清理代码,对内存泄露和溢出的问题,也不需要像C程序员那样战战兢兢。这是因为在Java虚拟机中,存在自动内存管理和垃圾清扫机制。概括地说,该机制对 JVM(Java Virtual Machine)中的内存进行标记,并确定哪些内存需要回收,根据一定的回收策略,自动的回收内存,永不停息(Nerver Stop)的保证JVM中的内存空间,防止出现内存泄露和溢出问题。

    Java GC机制主要完成3件事:确定哪些内存需要回收,确定什么时候需要执行GC,如何执行GC然而,如果我们从事较大型的应用软件开发,曾经出现过内存优化的需求,就必定要研究 Java GC机制。学习Java GC机制,可以帮助我们在日常工作中排查各种内存溢出或泄露问题,解决性能瓶颈,达到更高的并发量,写出更高效的程序

    我们将从4个方面学习Java GC机制,

    1,内存是如何分配的;2,如何保证内存不被错误回收(即:哪些内存需要回收);3,在什么情况下执行GC以及执行GC的方式;4,如何监控和优化GC机制。

    Java程序的具体执行过程

    首先Java源代码文件(.java后缀)会被Java编译器编译为字节码文件(.class后缀),然后由JVM中的类加载器加载各个类的字节码文件,加载完毕之后,交由JVM执行引擎执行。在整个程序执行过程中,JVM会用一段空间来存储程序执行期间需要用到的数据和相关信息,这段空间一般被称作为Runtime Data Area(运行时数据区),也就是我们常说的JVM内存(虚拟机内存)。因此,在Java中我们常常说到的内存管理就是针对这段空间进行管理(如何分配和回收内存空间)。

    RDA(运行时数据区) 通常包括这几个部分:

     

    程序计数器(Program CounterRegister):是一个比较小的内存区域,用于指示当前线程所执行的字节码执行到了第几行,可以理解为当前线程的行号指示器。字节码解释器在工作时,会通过改变这个计数器的值来取下一条语句指令。

    JVM栈(VM Stack):一个线程的每个方法在执行的同时会创建一个栈帧,每个栈帧对应一个被调用的方法,在栈帧中包括局部变量表(Local Variables)、操作数栈(OperandStack)、指向当前方法所属的类的运行时常量池(运行时常量池的概念在方法区部分会谈到)的引用(Referenceto runtime constant pool)、方法返回地址(ReturnAddress)和一些额外的附加信息。当线程执行一个方法时,就会随之创建一个对应的栈帧,并将建立的栈帧压栈。当方法执行完毕之后,便会将栈帧出栈。因此可知,线程当前执行的方法所对应的栈帧必定位于Java栈的顶部。讲到这里,大家就应该会明白为什么 在 使用 递归方法的时候容易导致栈内存溢出的现象了以及为什么栈区的空间不用程序员去管理了(当然在Java中,程序员基本不用关系到内存分配和释放的事情,因为Java有自己的垃圾回收机制),这部分空间的分配和释放都是由系统自动实施的。对于所有的程序设计语言来说,栈这部分空间对程序员来说是不透明的。下图表示了一个Java栈的模型:

    本地方法栈(Native MethodStack) : 本地方法栈与Java栈的作用和原理非常相似。区别只不过是Java栈是为执行Java方法服务的,而本地方法栈则是为执行本地方法(Native Method)服务的。JVM规范中,并没有对本地方发展的具体实现方法以及数据结构作强制规定,虚拟机可以自由实现它。在HotSopt虚拟机中直接就把本地方法栈和Java栈合二为一。

     

    方法区(Method Area) :在Java虚拟机规范中,将方法区作为堆的一个逻辑部分来对待,但事实 上,方法区并不是堆(Non-Heap);另外,不少人的博客中,将Java GC的分代收集机制分为3个代:青年代,老年代,永久代,这些作者将方法区定义为“永久代”,这是因为,对于之前的HotSpot Java虚拟机的实现方式中,将分代收集的思想扩展到了方法区,并将方法区设计成了永久代。不过,除HotSpot之外的多数虚拟机,并不将方法区当做永 久代,HotSpot本身,也计划取消永久代。本文中,由于笔者主要使用Oracle JDK6.0,因此仍将使用永久代一词。

      方法区是各个线程共享的区域,用于存储已经被虚拟机加载的类信息(即加载类时需要加载的信息,包括版本、field、方法、接口等信息)、final常量、静态变量、编译器即时编译的代码等。

      方法区在物理上也不需要是连续的,可以选择固定大小或可扩展大小,并且方法区比堆还多了一个限制:可以选择是否执行垃圾收集。一般的,方法区上 执行的垃圾收集是很少的,这也是方法区被称为永久代的原因之一(HotSpot),但这也不代表着在方法区上完全没有垃圾收集,其上的垃圾收集主要是针对 常量池的内存回收和对已加载类的卸载。

      在方法区上进行垃圾收集,条件苛刻而且相当困难,效果也不令人满意,所以一般不做太多考虑,可以留作以后进一步深入研究时使用。

      在方法区上定义了OutOfMemoryError:PermGen space异常,在内存不足时抛出。

      运行时常量池(Runtime ConstantPool)是方法区的一部分,用于存储编译期就生成的字面常量、符号引用、翻译出来的直接引用(符号引用就是编码是用字符串表示某个变量、接口的位置,直接引用就是根据符号引用翻译出来的地址,将在类链接阶段完成翻译);运行时常量池除了存储编译期常量外,也可以存储在运行时间产生的常量(比如String类的intern()方法,作用是String维护了一个常量池,如果调用的字符“abc”已经在常量池中,则返回池中的字符串地址,否则,新建一个常量加入池中,并返回地址)。

     

    堆(Heap):Java中的堆是用来存储对象本身的以及数组(当然,数组引用是存放在Java栈中的)。只不过和C语言中的不同,在Java中,程序员基本不用去关心空间释放的问题,Java的垃圾回收机制会自动进行处理。因此这部分空间也是Java垃圾收集器管理的主要区域。另外,堆是被所有线程共享的,在JVM中只有一个堆。

     

    补充:直接内存并不是JVM管理的内存,可以这样理解,直接内存,就是 JVM以外的机器内存,比如,你有4G的内存,JVM占用了1G,则其余的3G就是直接内存,JDK中有一种基于通道(Channel)和缓冲区 (Buffer)的内存分配方式,将由C语言实现的native函数库分配在直接内存中,用存储在JVM堆中的DirectByteBuffer来引用。 由于直接内存收到本机器内存的限制,所以也可能出现OutOfMemoryError的异常。

    2.      Java的弱应用和强引用的理解

    强引用是和垃圾回收机制相关的。

    一般的,如果一个对象可以通过一系列的强引用引用到,那么就说明它是不会被垃圾回收机制(Garbage Collection)回收的。

    因为垃圾回收是不会回收你正在使用的对象的。

    3.      Java是多继承还是单继承

    类是单继承接口是实现是多继承的。

    4.      抽象类和接口的比较

    概述:Java接口(interface)Java抽象类(abstract class)代表的就是抽象类型,就是我们需要提出的抽象层的具体表现。OOP面向对象的编程,如果要提高程序的复用率,增加程序的可维护性,可扩展性,就必须是面向接口的编程,面向抽象的编程,正确地使用接口、抽象类这些有用的抽象类型作为你结构层次上的顶层。

    【1】Java接口和Java抽象类最大的一个区别,就在于Java抽象类可以提供某些方法的部分实现,而Java接口不可以(就是interface中只能定义方法,而不能有方法的实现,而在abstract class中则可以既有方法的具体实现,又有没有具体实现的抽象方法),这大概就是Java抽象类唯一的优点吧,但这个优点非常有用。如果向一个抽象类里加入一个新的具体方法时,那么它所有的子类都一下子都得到了这个新方法,而Java接口做不到这一点,如果向一个Java接口里加入一个 新方法,所有实现这个接口的类就无法成功通过编译了,因为你必须让每一个类都再实现这个方法才行,这显然是Java接口的缺点。这个在我的另外一篇博客mapreduce 新旧API 区别中有提到类似的问题,在新的mapreduce api中更倾向于使用抽象类,而不是接口,因为这更容易扩展。原因就是上面划线部分所说的。

    【2】一个抽象类的实现只能由这个抽象类的子类给出,也就是说,这个实现处在抽象类所定义出的继承的等级结构中,而由于Java语言的单继承性,所以抽象类作为类型定义工具的效能大打折扣。在这一点上,Java接口的优势就出来了,任何一个实现了一个Java接口所规定的方法的类都可以具有这个接口的类型,而一个类可以实现任意多个Java接口,从而这个类就有了多种类型。(使用抽象类,那么继承这个抽象类的子类类型就比较单一,因为子类只能单继承抽象类;而子类能够同时实现多个接口,因为类型就比较多。接口和抽象类都可以定义对象,但是只能用他们的具体实现类来进行实例化。)

    【3】从第2点不难看出,Java接口是定义混合类型的理想工具,混合类表明一个类不仅仅具有某个主类型的行为,而且具有其他的次要行为。

    【4】结合1、2点中抽象类和Java接口的各自优势,具精典的设计模式就出来了:声明类型的工作仍然由Java接口承担,但是同时给出一个Java 抽象类,且实现了这个接口,而其他同属于这个抽象类型的具体类可以选择实现这个Java接口,也可以选择继承这个抽象类,也就是说在层次结构中,Java 接口在最上面,然后紧跟着抽象类,这下两个的最大优点都能发挥到极至了。这个模式就是“缺省适配模式”。在Java语言API中用了这种模式,而且全都遵循一定的命名规范:Abstract +接口名。(A extends AbstractB implementsinterfaceC,那么A即可以选择实现(@Override)接口interfaceC中的方法,也可以选择不实现;A即可以选择实现(@Override)抽象类AbstractB中的方法,也可以选择不实现)

     

    5.      SDK测试了解

    什么是SDK:SDK就是一个程序,提供一些方法,调用这些方法,可以实现一些功能。如:调用银行提供的SDK,可以实现在线支付的功能。

    目前主要接手的SDK有JS SDK 和android SDK。JS SDK就是给你一个js文件,里面提供一些调用的方法。Android SDK就是提供一个jar包,引用jar包后根据说明文档,调用里面的方法。

    SDK怎么测:

    1、入参和出参:一般SDK说明文档会提供接口的入参和出参,以及入参的类型、是否必填、边界值

    是否必选:如果文档里写的参数是必选的,可以用null,“” 写用例

    边界值:一般写入操作,都会有他的边界值,这个文档里应该详细有写。如果参数为1-99 int类型。那用例就是0,1,99,100来写用例。如果参数的类型为string 长度为 1-50,就是长度为0,1,50,51来写用例

    引用类型和引用类型:如果参数是引用类型,需要测试null 和“”。如果是值类型可以对正数、负数、0以及最大值最小值。这个看需求。

    特殊字符:可以测一下键盘能打出来的特殊字符,如~@#¥%……&*()——+{}P|:"<>?还有中文的特殊字符。

    特殊情况:像一些查询类接口,可以针对*%这种通配符写用例

    注意出参细节:很多时候,很多出参往往被大家忽视。以为只要有参数就对了。比如发送图片接口,返回的width、height、和大小。这些都可能被忽视,以及返回的图片地址是不是能打开,大小是否正确。以及图片被压缩后是不是符合要求。

    注意出参格式:比如有时候客户端和服务端交互的时候是用xml,但是出参的格式是json。有时候开发忘记解析了,就变成xml,所以这也是一个bug。

    注意出参的返回顺序:如果出参是一个列表,还要看列表的返回顺序是否正确。

    2、不同的场景调用

    未登录和已登录

    网速不好的情况

    如果设计到ip电话,可以测wifi 4G 3G 2G,电话中 wifi切换4G,wifi切换3G 等等

    用户被后台删除的情况

    不走寻常路,可能会发现意外的bug:比如之前测试加好友/同意/拒绝这三个接口。如果这三个接口分开测,一点问题都没有。但是这个场景(A给B发出加好友申请,A再调用同意接口同意B,然后A和B就互为好友。其实应该B同意A才会互为好友)。

    3、兼容性测试:

    androidSDK的话,最好多找几个不同的手机多做一下自由测试。

    web SDK的话,最好多找几个浏览器和不同浏览器版本多做一下自由测试。

    4、反复测试:

    有些静态变量,在退出后没有初始化,可能会导致一些问题。比如之前测webSDK,登录退出登录退出后,请求的地址就变成http://xxx/Login/Login,原因就是在登录的时候,请求的地址就是url=url+/Login。退出后,没有对url初始化,所以多次登录后,url后面就会有很多/Login

    5、注意用例的大小写以及特殊符号的中英文:比如之前有个同事搜索用户昵称接口,用户昵称包含英文的(,但是他的入参为中文的(,搜了半天没搜到,还以为是开发的问题呢。还要后来自己发现了,不然找开发的话,开发会不高兴了。

    6、考虑全面:比如测试QQ的历史消息,不要觉得,发送一条消息然后能获取到就行了。其实我们应该想好历史消息的类型,如(文本、表情(ios的表情等等)、图片、语音、文件 等等)消息类型必须全面。其次,应该考虑QQ的客户端,看一下web端、android端、ios端、windows客户端 等等 发送的消息是否没个端都能获取历史消息。然后再细测 历史消息的时间昵称这些是否正确、以及图片是否能打开 保存的文件地址是否正确。还有一些特殊的场景,比如改QQ名称前的历史消息和改名以后的历史消 。还有其他的等等 就靠大家多想啦。

    目前问题总结

    边界值。比如用户名的最大长度为50的情况下:不能创建会议、不能收到离线消息、等等

    特殊字符:用户昵称含特殊字符不能收到短信。发短信借口,短信内容为特殊字符,会收不到短信以及短信内容为空。

    错误提示不正确。

     

    6.      Python自动化测试

    7.      Tomcat默认端口号:8080

    8.      函数覆盖和函数重载的区别

    重载和覆盖的异同点: 
    *相同【1】都要求方法同名【2】都可以用于抽象方法和非抽象方法 
    *不同:覆盖要求参数一致,而重载要求参数必须不一致;覆盖要求返回类型必须一直,重载对此不做限制;覆盖只能用于子类覆盖父类方法,重载应用于同一个类中;覆盖对方法的访问权限和异常有特殊要求,重载没有限制;父类的一个方法只能被子类覆盖一次,而一个方法可以重载多次。

    方法覆盖的问题:【1】子类的方法名称、参数名和返回类型必须与父类的方法的名称、参数名和返回类型一致【2】子类的方法不能够缩小父类方法的访问权限3】子类方法不能抛出比父类方法更多的异常。子类抛出的异常必须和父类相同或者是父类异常的子类。【4】方法覆盖仅仅是存在于子类和父类【5】父类的静态方法不能被子类覆盖为非静态方法6】子类和父类的静态方法可以重名,以便在子类中隐藏父类的方法。在编译的时候,子类定义的静态方法也必须满足与方法覆盖类似的约束;方法的参数名一致,返回类型一致,不能缩小父类的方法的权限,不能够抛出更多的异常。【7】父类的非静态方法不能够被子类覆盖为静态方法【8】父类的私有方法不能够被子类覆盖【9】父类的抽象方法可以被子类通过两种途径来覆盖:一种是实现抽象方法;另一种是重新声明父类的

    9.      安卓的权限控制文件

    AndroidManifest.xml

    10.   进程和线程的区别

    [1]一个程序至少有一个进程,一个进程至少有一个线程。线程的划分尺度小于进程,使得多线程程序的并发性高。

    [2]进程在执行过程中拥有独立的内存单元,而多个线程是共享内存的,从而极大的提高了程序的运行效率。

    [3]线程在执行过程中和进程是有区别的。每个独立的线程有一个程序运行的入口、程序顺序执行和程序运行的出口。但是线程不能够独立的执行,必须依存在应用程序中。

    [4]从逻辑的角度讲,多线程的意义在于一个应用程序中有多个执行部分可以同时执行。操作系统并没有将线程看作多个独立的应用,来实现进程的调度和管理,以及资源分配。这就是线程和进程的区别。

    [5]进程是具有一定独立功能的程序关于某个数据集合上面的一次运行活动,进程是系统进行资源分配和调度的单位。

    [6]线程是一个进程的实体,是cpu调度和分派的基本单位,它是比进程更小的能够独立运行的基本单位。线程本上基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(程序计数器、一组寄存器和栈),但是它与同属一个进程的其他线程共享进程拥有的全部资源。

    [7]一个线程可以创建和撤销另一个进程,同一个进程中的多个线程可以并发执行。 
    总结:线程和进程的主要差别在于,它们是不同操作系统资源管理方式。进程有独立的地址空间,一个进程崩溃之后,在保护模式下不会对其他的进程产生影响,而线程只是进程中的一个不同的执行路径。线程有自己的堆栈和执行变量,单线程之间没有单独的地址空间,一个线程的死掉会等于整个进程死掉,所以多进程的程序比多线程的程序健壮,但是在进程进行切换的时候,消耗资源较大,效率差一些。但是对于一些要求同时进行又需要共享某些变量的并发操作,只能用线程,不能用进程。

    11.    进程和线程的状态

    创建-》就绪-》运行-》阻塞或者等待、睡眠-》死亡状态

    1. 新建状态(New):新创建了一个线程对象。
    2.
    就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中,变得可运行,等待获取CPU的使用权。
    3.
    运行状态(Running):就绪状态的线程获取了CPU,执行程序代码。
    4.
    阻塞状态(Blocked):阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。阻塞的情况分三种:
    (一)、等待阻塞:运行的线程执行wait()方法,JVM会把该线程放入等待池中。
    (二)、同步阻塞:运行的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则JVM会把该线程放入锁池中。
    (三)、其他阻塞:运行的线程执行sleep()join()方法,或者发出了I/O请求时,JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。
    5.
    死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。

     

     

     

    12.   内部类

    内部类不是很好理解,但说白了其实也就是一个类中还包含着另外一个类:如同一个人是由大脑、肢体、器官等身体结果组成,而内部类相当于其中的某个器官之一,例如心脏:它也有自己的属性和行为(血液、跳动).

    显然,此处不能单方面用属性或者方法表示一个心脏,而需要一个类.

    Out.In in = new Out().new In()可以用来生成内部类的对象,这种方法存在两个小知识点需要注意

    Ø  开头的Out是为了标明需要生成的内部类对象在哪个外部类当中

    Ø  必须先有外部类的对象才能生成内部类的对象,因为内部类的作用就是为了访问外部类中的成员变量

    Ø  内部类在没有同名成员变量和局部变量的情况下,内部类会直接访问外部类的成员变量,而无需指定Out.this.属性名.否则,内部类中的局部变量会覆盖外部类的成员变量而访问内部类本身的成员变量可用this.属性名,访问外部类的成员变量需要使用Out.this.属性名.

    Ø  如果用static 将内部内静态化,那么内部类就只能访问外部类的静态成员变量,具有局限性.其次,因为内部类被静态化,因此Out.In可以当做一个整体看,可以直接new 出内部类的对象(通过类名访问static,生不生成外部类对象都没关系)

    Ø  如果一个内部类只希望被外部类中的方法操作,那么可以使用private声明内部类上面的代码中,我们必须在Out类里面生成In类的对象进行操作,而无法再使用Out.In in = new Out().new In() 生成内部类的对象.也就是说,此时的内部类只有外部类可控制.如同是,我的心脏只能由我的身体控制,其他人无法直接访问它

    Ø  内部类移到了外部类的方法中,然后在外部类的方法中再生成一个内部类对象去调用内部类方法.如果此时我们需要往外部类的方法中传入参数,那么外部类的方法形参必须使用final定义,至于final在这里并没有特殊含义,只是一种表示形式而已. 而心脏又在人体当中,正如同是内部类在外部内当中.

    Ø  匿名内部类 接口 抽象类都可以使用匿名内部类来实现。

    13.   设计模式: http://www.cnblogs.com/beijiguangyong/archive/2010/11/15/2302807.html

    创建型

    1. Factory Method(工厂方法):一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。

    2. Abstract Factory(抽象工厂): 提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。 

    3. Builder(建造者): 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。

    4. Prototype(原型): 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。

    5. Singleton(单例): 保证一个类仅有一个实例,并提供一个访问它的全局访问点。

    结构型

    6. Adapter Class/Object(适配器):将一个类的接口转换成客户希望的另外一个接口。Adapter 模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 

    7. Bridge(桥接): 将抽象部分与它的实现部分分离,使它们都可以独立地变化。

    8. Composite(组合): 将对象组合成树形结构以表示“部分-整体”的层次结构。C o m p o s i t e 使得用户对单个对象和组合对象的使用具有一致性。 

    9. Decorator(装饰): 动态地给一个对象添加一些额外的职责。就增加功能来说,Decorator 模式相比生成子类更为灵活。 

    10. Facade(外观): 为子系统中的一组接口提供一个一致的界面,Facade模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。

    11. Flyweight(享元): 运用共享技术有效地支持大量细粒度的对象。

    12. Proxy(代理): 为其他对象提供一种代理以控制对这个对象的访问。

    行为型

    13. Interpreter(解释器): 给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。

    14. Template Method(模板方法): 定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。TemplateMethod 使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

    15. Chain of Responsibility(责任链): 使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。

    16. Command(命令): 将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤消的操作。

    17. Iterator(迭代器): 提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。

    18. Mediator(中介者): 用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。

    19. Memento(备忘录): 在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。

    20. Observer(观察者): 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。

    21. State(状态): 允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

    22. Strategy(策略): 定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

    23. Visitor(访问者): 定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。TemplateMethod 使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

    14.    Http的方法

    关于http协议涉及方法的两个名词解释:safe型方法和Idempotent型方法。

    safe型方法通常是指不影响服务器端资源的行为,它的操作结果仅仅是读取信息,GET和HEAD多数情况下被认为具有“safe”的特性。

    Idempotent型方法正如Idempotent这个词的意思一样,如果一个方法,n次调用与一个独立请求所产生的资源消耗相同,即没有边际损耗,则我们可以认为这类方法是idempotent型方法,get、head、put、delete、options和trace都具有这样的特性。

    http协议通常包括的方法有很多,以下我只列出我在http/1.1协议定义中看到的方法:get、post、head、options、put、delete、trace、connect。

    get方法用于获取URI资源,是最为常用的一种方法。

    post方法用于向指定URI提交内容,服务器端响应其行为,该方法也极为常用。

    head方法向URI发送请求,仅仅只需要获得响应的协议头。

    put方法用于向URI发送请求,若URI不存在,则要求服务器端根据请求创建资源。当URI存在时,服务器端必须接受请求内容,将其作为URI资源的修改后版本。

    delete方法用于删除URI标识的指定资源。

    trace方法用于激活服务器端对请求的循环反馈,反馈作为http响应的正文内容被传输回客户端。

    connect方法通常被用于使用代理连接。

    对于上面提到的这些方法,相信大家如果肯花时间,自然可以在http协议的标准中看到更加详细的内容。但有一点是我需要说明的,以上提到的方法,除了get、post和head可以通过浏览器应用外,其它的方法例如put和delete使用起来有些问题。但ajax的出现为我们提供了一种解决的方式,ajax使用xmlhttprequest进行操作时,在发送请求之前,可以通过设置request type的方式来完成对请求方法的设定。

    诸位如果作为servlet开发的人可以尝试一下直接在servlet中实现doPut、doDelete等方法,并在客户端使用ajax对相同的URI使用不同的方法进行请求。

    15.    TCP的详解http://www.cnblogs.com/feitian629/archive/2012/11/16/2774065.html

    在传输层叫做段(segment),在网络层叫做数据报(datagram),在链路层叫做帧(frame)。数据封装成帧后发到传输介质上,到达目的主机后每层协议再剥掉相应的首部,最后将应用层数据交给应用程序处理。

    TCP建立连接的过程:

    【1】. 客户端发出段1,SYN 位表示连接请求。序号是1000,这个序号在网络通讯中用作临时的地址,每发一个数据字节,这个序号要加1,这样在接收端可以根据序号排出数据包的正确顺序,也可以发现丢包的情况,另外,规定SYN 位和FIN 位也要占一个序号,这次虽然没发数据,但是由于发了SYN 位,因此下次再发送应该用序号1001。mss表示最大段尺寸,如果一个段太大,封装成帧后超过了链路层的最大帧长度,就必须在IP 层分片,为了避免这种情况,客户端声明自己的最大段尺寸,建议服务器端发来的段不要超过这个长度。

    【2】 服务器发出段2,也带有SYN 位,同时置ACK 位表示确认,确认序号是1001,表示“我接收到序号1000 及其以前所有的段,请你下次发送序号为1001 的段”,也就是应答了客户端的连接请求,同时也给客户端发出一个连接请求,同时声明最大尺寸为1024。

    【3】 客户端发出段3,对服务器的连接请求进行应答,确认序号是8001。

    在这个过程中,客户端和服务器分别给对方发了连接请求,也应答了对方的连接请求,其中服务器的请求和应答在一个段中发出,因此一共有三个段用于建立连接,称为'''三方握手(three-way-handshake)'''。在建立连接的同时,双方协商了一些信息,例如双方发送序号的初始值、最大段尺寸等。

    (4)TCP数据传输过程

    【1】  客户端发出段4,包含从序号1001 开始的20 个字节数据。

    【2】  服务器发出段5,确认序号为1021,对序号为1001-1020 的数据表示确认收到,同时请求发送序号1021 开始的数据,服务器在应答的同时也向客户端发送从序号8001 开始的10 个字节数据,这称为piggyback。

    【3】  客户端发出段6,对服务器发来的序号为8001-8010 的数据表示确认收到,请求发送序号8011 开始的数据。

    在数据传输过程中,ACK 和确认序号是非常重要的,应用程序交给TCP 协议发送的数据会暂存在TCP 层的发送缓冲区中,发出数据包给对方之后,只有收到对方应答的ACK 段才知道该数据包确实发到了对方,可以从发送缓冲区中释放掉了,如果因为网络故障丢失了数据包或者丢失了对方发回的ACK 段,经过等待超时后TCP 协议自动将发送缓冲区中的数据包重发。

    (5)TCP连接的关闭

    【1】  客户端发出段7,FIN 位表示关闭连接的请求。

    【2】  服务器发出段8,应答客户端的关闭连接请求。

    【3】  服务器发出段9,其中也包含FIN 位,向客户端发送关闭连接请求。

    【4】  客户端发出段10,应答服务器的关闭连接请求。


    建立连接的过程是三方握手,而关闭连接通常需要4 个段(四次握手),服务器的应答和关闭连接请求通常不合并在一个段中,因为有连接半关闭的情况,这种情况下客户端关闭连接之后就不能再发送数据给服务器了,但是服务器还可以发送数据给客户端,直到服务器也关闭连接为止,稍后会看到这样的例子

    16.   Java反射和动态代理

    Java反射:

    1】通过一个对象获得完整的包名和类名

    2】实例化Class类对demo1=Class.forName("Reflect.Demo");

    3】通过Class实例化其他类的对象per=(Person)demo.newInstance();Class实例化其他类的对象的时候,一定要自己定义无参的构造函数。

    http://www.cnblogs.com/xiaoluo501395377/p/3383130.html

    动态代理:动态代理可以提供对另一个对象的访问,同时隐藏实际对象的具体事实。代理一般会实现它所表示的实际对象的接口。代理可以访问实际对象,但是延迟实现实际对象的部分功能,实际对象实现系统的实际功能,代理对象对客户隐藏了实际对象。客户不知道它是与代理打交道还是与实际对象打交道。

    目前Java开发包中包含了对动态代理的支持,但是其实现只支持对接口的的实现。其实现主要通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。 

    Proxy类主要用来获取动态代理对象,InvocationHandler接口用来约束调用者实现.

    17.   Java泛型的理解

      1、泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。

    2、同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。

    3、泛型的类型参数可以有多个。

    4、泛型的参数类型可以使用extends语句,例如<T extendssuperclass>。习惯上称为有界类型get extendsputsuper原则

    List<?extends E>不能添加元素,但是由于其中的元素都有一个共性--有共同的父类,因此我们在获取元素时可以将他们统一强制转换为E类型,我们称之为get原则。

    List<?super E>list中存放的都是E的父类型元素(包括E,集合中的元素都是E的父类型(包括E),其中的元素类型众多,在获取元素时我们无法判断是哪一种类型,故设计成不能获取元素,我们称之为put原则。

    5、泛型的参数类型还可以是通配符类型。例如

    Class<?>classType = Class.forName(java.lang.String);

     

     

    18.   Java容器

    Collection 
    ├List 
    │├LinkedList 
    │├ArrayList 
    │└Vector 
    └Stack 
    └Set 
    Map 
    ├Hashtable 
    ├HashMap 
    └WeakHashMap

    Iterator是迭代器类,而Iterable是接口。 
    好多类都实现了Iterable接口,这样对象就可以调用iterator()方法。 
    一般都是结合着用,比如 
    HashMap
    类就实现了Iterable接口,而要访问或打印出Map中所有内容时,就可以这样:HashMap hashMap; 
    Iterator iter = hashMap.iterator();
     
    while(iter.hashNext()) { 
      String s = iter.next(); 

    展开全文
  • JAVA技术交流QQ群:170933152  java并发之TimeUnit理解 TimeUnit是java.util.concurrent包下面的一个类,TimeUnit提供了可读性更好的线程暂停操作,通常用来替换Thread.sleep(),在很长一段时间里Thread的sleep()...
  • 前言 9月已经即将接近尾声,我就看到了...根据霸哥多年面试经验来说,最重要、最快能掌握的Java开发技术无非就那几个: Java基础:注解、反射、异常、序列化、集合等 JVM 多线程 SSM框架 设计模式 算法 数..
  • JAVA技术交流QQ群:170933152  第一步我们首先查看一下Math数学函数的API,可以看到pow()方法返回第一个参数的第二个参数次方,格式为Math.pow(m,n),代表m的n次方,如下图所示:  //获取4位短信验证码 public ...
  • 基本数据类型: ==:比较的是变量存储的值是否相等 equals:基本数据类型无法使用该方法 引用数据类型: ==:比较的是对象的地址 equals:若没有对equals重写,则比较的是对象的地址是否相同 若对equals重写则比较的是...
  • JAVA技术交流QQ群:170933152  https://www.cnblogs.com/-new/p/7256297.html 这个地方的文章还不错  ReentrantLocak特性(对比synchronized) 尝试获得锁 获取到锁的线程能够响应中断 ReentrantLock(重入锁)...
  • 好多朋友都是要在快面试...如果你是面试在即,想迅速梳理Java面试要点?如果你是已经工作,仍想扎实Java基本功?那么这份面试手册你一样需要! 这份面试手册涵盖了:JVM原理、Java基础、并发编程、数据结构和算法、...
  • JAVA技术交流QQ群:170933152  ==: == 比较的是变量(栈)内存中存放的对象的(堆)内存地址,用来判断两个对象的地址是否相同,即是否是指相同一个对象。比较的是真正意义上的指针操作。 1、比较的是操作符两端的...
  • java面试要点005---git和svn的区别

    千次阅读 2017-06-04 16:18:26
    最近开始学Git,跟以前常用的SVN来做个对比,以便对双方的优缺点了解更多些。 其实Git和SVN还是挺像的,都有提交,合并等操作,看来这是源码管理工具的基本操作。 ...1. Git是分布式的,SVN是集中式的,好处是跟...
  • JAVA技术交流QQ群:170933152 下面直接来干货,先说这三个Map的区别: HashTable 底层数组+链表实现,无论key还是value都不能为null,线程安全,实现线程安全的方式是在修改数据时锁住整个HashTable,效率低,...
  • #的作用: userMapper.xml 注意这里,写sql语句,咱们可以使用xml配置的方式,也可以使用注解的方式. E:\workspace\day76_mybatis01\src\com\credream\test2\userMapper.xml CRUD操作 ...//1....
  • Git中从远程的分支获取最新的版本到本地有这样2个命令: 1. git fetch:相当于是从远程获取最新版本到本地,不会自动merge  Git fetch origin mastergit log -p master..origin/mastergit merge origin/...
  • 下面是参考网络资源和总结一些在java编程中尽可能做到的一些地方 - 1.尽量在合适的场合使用单例 使用单例可以减轻加载的负担,缩短加载的时间,提高加载的效率,但并不是所有地方都适用于单例,简单来说,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 908
精华内容 363
关键字:

java面试要点

java 订阅