2022年9月22日 21:20 周四编程题
#
有n步台阶，一次只能上1步或2步，共有多少种走法
分析
#
分析
n = 1，1步 f(1) = 1
n = 2, 两个1步,2步 f(2) = 2
n = 3, 分两种情况： 最后1步是2级台阶/最后1步是1级台阶，
即 f(3) = f(1)+f(2)
n = 4, 分两种情况： 最后1步是2级台阶/最后1步是1级台阶，
即f(4) = f(2)+f(3)
也就是说，不管有几(n)个台阶，总要分成两种情况：最后1步是2级台阶/最后1步是1级台阶，即 f(n)= f(n-2) + f(n-1)
递归
#
public static int f(int n){
if(n==1 || n==2){
return n;
}
return f(n-2)+f(n-1);
}
public static void main(String[] args) {
System.out.println(f(1)); //1
System.out.println(f(2)); //2
System.out.println(f(3)); //3
System.out.println(f(4)); //5
System.out.println(f(5)); //8
}
- debug调试
方法栈
f(4)—->分解成f(2)+f(3)
f(2)—返回-
f(3)—f(2)返回—f(1)返回 【f(3)分解成f(2)和f(1)】
方法栈的个数：
使用循环
#
public static int loop(int n){
if (n < 1) {
throw new IllegalArgumentException(n + "不能小于1");
}
if (n == 1 || n == 2) {
return n;
}
int one=2;//最后只走1步，会有2种走法
int two=1;//最后走2步，会有1种走法
int sum=0;
for(int i=3;i<=n;i++){
//最后跨两级台阶+最后跨一级台阶的走法
sum=two+one;
two=one;
one=sum;
}
return sum;
}
...
2022年9月22日 10:24 周四 代码
#
public class Exam4 {
public static void main(String[] args) {
int i = 1;
String str = "hello";
Integer num = 2;
int[] arr = {1, 2, 3, 4, 5};
MyData my = new MyData();
change(i, str, num, arr, my);
System.out.println("i = " + i);
System.out.println("str = " + str);
System.out.println("num = " + num);
System.out.println("arr = " + Arrays.toString(arr));
System.out.println("my.a = " + my.a);
}
public static void change(int j, String s, Integer n, int[] a,
MyData m) {
j+=1;
s+="world";
n+=1;
a[0]+=1;
m.a+=1;
}
}
结果
...
2022年9月22日 08:50 周四 代码
#
public class Son extends Father{
private int i=test();
private static int j=method();
static {
System.out.print("(6)");
}
Son(){
System.out.print("(7)");
}
{
System.out.print("(8)");
}
public int test(){
System.out.print("(9)");
return 1;
}
public static int method(){
System.out.print("(10)");
return 1;
}
public static void main(String[] args) {
Son s1=new Son();
System.out.println();
Son s2=new Son();
}
}
public class Father {
private int i=test();
private static int j=method();
static {
System.out.print("(1)");
}
Father(){
System.out.print("(2)");
}
{
System.out.print("(3)");
}
public int test() {
System.out.print("(4)");
return 1;
}
public static int method() {
System.out.print("(5)");
return 1;
}
}
输出：
...
2022年9月21日 14:22 周三 特点
#
- 该类只有一个实例
- 该类内部自行创建该实例
- 能向外部提供这个实例
几大方法
#
饿汉式
#
随着类的加载进行初始化，不管是否需要都会直接创建实例对象
public class Singleton1 {
public static final Singleton1 INSTANCE=new Singleton1();
private Singleton1() {
}
}
枚举
#
枚举类表示该类型的对象是有限的几个
public enum Singleton2 {
INSTANCE
}
使用静态代码块
#
随着类的加载进行初始化
public class Singleton2 {
public static final Singleton2 INSTANCE;
static {
INSTANCE = new Singleton2();
}
private Singleton2() {
}
}
如图，当初始化实例时需要进行复杂取值操作时，可以取代第一种方法
懒汉式
#
延迟创建对象
public class Singleton4 {
//为了防止重排序，需要添加volatile关键字
private static volatile Singleton4 INSTANCE;
private Singleton4() {
}
/**
* double check
* @return
*/
public static Singleton4 getInstance() {
//2 先判断一次,对于后面的操作(此时已经创建了对象)能减少加锁次数
if (INSTANCE == null) {
//如果这里不加锁会导致线程安全问题，可能刚进了判断语句之后，执行权被剥夺了又创建好了对象，
//所以判断及创建对象必须是原子操作
synchronized (Singleton4.class) {
if (INSTANCE == null) {
//用来模拟多线程被剥夺执行权
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//如果这个地方不加volatile,会出现的问题是,指令重排 1,2,3是正常的,
//会重排成1,3,2 然后别的线程去拿的时候，判断为非空，但是实际上运行的时候，发现里面的数据是空的
//1 memory = allocate();//分配对象空间
//2 instance(memory); //初始化对象
//3 instance = memory; //设置instance指向刚刚分配的位置
INSTANCE = new Singleton4();
}
}
}
return INSTANCE;
}
}
使用静态内部类
#
public class Singleton6 {
private Singleton6(){
}
private static class Inner{
private static final Singleton6 INSTANCE=new Singleton6();
}
public static Singleton6 getInstance(){
return Inner.INSTANCE;
}
}
- 只有当内部类被加载和初始化的时候，才会创建INSTANCE实例对象
- 静态内部类不会自动随着外部类的加载和初始化而初始化，他需要单独去加载和初始化
- 又由于他是在内部类加载和初始化时，创建的，属于类加载器处理的，所以是线程安全的
2022年9月21日 10:04 周三 题目
#
int i=1;
i=i++;
int j=i++;
int k = i+ ++i * i++;
System.out.println("i="+i);
System.out.println("j="+j);
System.out.println("k="+k);
讲解
#
对于操作数栈和局部变量表的理解
#
对于下面的代码
反编译之后，查看字节码
0 bipush 10
2 istore_1
3 bipush 9
5 istore_2
6 iload_1
7 istore_2
8 return
如下图，这三行代码，是依次把10，9先放到局部变量表的1，2位置。
之后呢，再把局部变量表中1位置的值，放入操作数栈中
最后，将操作数栈弹出一个数(10)，将数值赋给局部变量表中的位置2
如上图，当方法为静态方法时，局部变量表0位置存储的是实参第1个数
(当方法为非静态方法时，局部变量表0位置存储的是this引用)
对于下面这段代码
int i=10;
int j=20;
i=i++;
j=++j;
System.out.println(i);
System.out.println(j);
编译后的字节码
...
2022年7月17日 09:49 周日 场景介绍
#
- 业务依赖
- 多模块管理
版本管理
第1种方式
#
创建父工程
#
介绍pom文件
#
pom 项目对象模型，project object model，该文件可以子工程被继承
maven多模块管理，其实就是让它的子模块的pom文件来继承父工程的pom
创建maven java子工程
#
新建一个module
注意路径，002在IDEA-maven的目录下
查看pom文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<!--指向父工程的gav坐标-->
<parent>
<artifactId>001-maven-parent</artifactId>
<groupId>com.bjpowernode.maven</groupId>
<version>1.0.0</version>
<!--相对路径-->
<relativePath>../001-maven-parent/pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>002-maven-java</artifactId>
</project>
创建maven web子工程
#
clone之后有默认的别名，且已经初始化了本地库
发送给lhc
多出一个文件夹
默认在master分支
untracketd files 未被追踪的文件，也就是这个文件还在工作区
LF 将会被替换成 CRLF，windows里面是CRLF，也就是说
