转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

面向对象基础#

• 区别

  • 面向过程把解决问题的过程拆成一个个方法，通过一个个方法的执行解决问题。
  • 面向对象会先抽象出对象，然后用对象执行方法的方式解决问题。
  • 面向对象编程 易维护、易复用、易扩展

• 对象实例与对象引用的不同
  new 运算符，new 创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。

  一个对象引用可以指向 0 个或 1 个对象（一根绳子可以不系气球，也可以系一个气球）;一个对象可以有 n 个引用指向它（可以用 n 条绳子系住一个气球）。

• 对象的相等一般比较的是内存中存放的内容是否相等；引用相等一般比较的是他们指向的内存地址是否相等

• 如果一个类没有声明构造方法，该程序能正确执行吗? 如果我们自己添加了类的构造方法（无论是否有参），Java 就不会再添加默认的无参数的构造方法了

  • 构造方法特点：名字与类名相同；没有返回值但不能用void声明构造函数；生成类的对象时自动执行
  • 构造方法不能重写(override)，但能重载 (overload)

• 面向对象三大特征

  • 封装
    把一个对象的状态信息(属性)隐藏在对象内部，不允许直接访问，但提供可以被外界访问的方法来操作属性

    public class Student {
        private int id;//id属性私有化
        private String name;//name属性私有化
    
        //获取id的方法
        public int getId() {
            return id;
        }
    
        //设置id的方法
        public void setId(int id) {
            this.id = id;
        }
    
        //获取name的方法
        public String getName() {
            return name;
        }
    
        //设置name的方法
        public void setName(String name) {
            this.name = name;
        }
    }

  • 继承
    不通类型的对象，相互之间有一定数量的共同点，同时每个对象定义了额外的特性使得他们与众不同。继承是使用已存在的类的定义作为基础建立新类的技术

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

基础概念及常识#

• Java语言特点

  • 面向对象（封装、继承、多态）
  • 平台无关性（Java虚拟机）
  • 等等

• JVM并非只有一种，只要满足JVM规范，可以开发自己专属JVM

• JDK与JRE

  • JDK，JavaDevelopmentKit，包含JRE，还有编译器（javac）和工具（如javadoc、jdb）。能够创建和编译程序
  • JRE，Java运行时环境，包括Java虚拟机、Java类库，及Java命令等。但是不能创建新程序

• 字节码，采用字节码的好处

  • Java中，JVM可以理解的代码称为字节码（.class文件)，不面向任何处理器，只面向虚拟机
  • Java程序从源代码到运行的过程
    • java代码必须先编译为字节码，之后呢，.class–>机器码，这里JVM类加载器先加载字节码文件，然后通过解释器进行解释执行（也就是字节码需要由Java解释器来解释执行）
    • Java解释器是JVM的一部分

• 编译与解释并存

  • 编译型：通过编译器将源代码一次性翻译成可被该平台执行的机器码，执行快、开发效率低
  • 解释型：通过解释器一句一句的将代码解释成机器代码后执行，执行慢，开发效率高
  • 如图

• 为什么说 Java 语言“编译与解释并存”？

  这是因为 Java 语言既具有编译型语言的特征，也具有解释型语言的特征。因为 Java 程序要经过先编译，后解释两个步骤，由 Java 编写的程序需要先经过编译步骤，生成字节码（.class 文件），这种字节码必须由 Java 解释器来解释执行。

• Java与C++区别

  • 没学过C++，Java不提供指针直接访问内存
  • Java为单继承；但是Java支持继承多接口
  • Java有自动内存管理垃圾回收机制（GC），不需要程序员手动释放无用内存

• 注释分为 单行注释、多行注释、文档注释

• 标识符与关键字 标识符即名字，关键字则是被赋予特殊含义的标识符

• 自增自减运算符 当 b = ++a 时，先自增（自己增加 1），再赋值（赋值给 b）；当 b = a++ 时，先赋值(赋值给 b)，再自增（自己增加 1）

• continue/break/return

  • continue ：指跳出当前的这一次循环，继续下一次循环。
  • break ：指跳出整个循环体，继续执行循环下面的语句。
  • return 用于跳出所在方法，结束该方法的运行。

• 变量

  • 成员变量和局部变量
    • 成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰
    • 从变量在内存中的存储方式来看,如果成员变量是使用 static 修饰的，那么这个成员变量是属于类的，如果没有使用 static 修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
    • 从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动生成，随着方法的调用结束而消亡（即方法栈弹出后消亡）。
    • final必须显示赋初始值，其他都自动以类型默认值赋值
  • 静态变量：被类所有实例共享

• 字符型常量与字符串常量区别

四种作用域#

• singleton：默认值，当IOC容器一创建就会创建bean实例，而且是单例的，每次得到的是同一个
• prototype：原型的，IOC容器创建时不再创建bean实例。每次调用getBean方法时再实例化该bean（每次都会进行实例化）
• request：每次请求会实例化一个bean
• session：在一次会话中共享一个bean

事务#

事务是什么#

逻辑上的一组操作，要么都执行，要么都不执行

事务的特性#

ACID

• Atomicity /ˌætəˈmɪsəti/原子性 , 要么全部成功，要么全部失败
• Consistency /kənˈsɪstənsi/ 一致性 , 数据库的完整性
• Isolation /ˌaɪsəˈleɪʃn/ 隔离性 , 数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致 , 这里涉及到事务隔离级别
• Durability /ˌdjʊərəˈbɪləti/ 持久性 , 事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失

Spring支持两种方式的事务管理#

• 编程式事务管理 /ˈeksɪkjuːt/ execute
  使用transactionTemplate

  @Autowired
  private TransactionTemplate transactionTemplate;
  public void testTransaction() {
  
          transactionTemplate.execute(new TransactionCallbackWithoutResult() {
              @Override
              protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
  
                  try {
  
                      // ....  业务代码
                  } catch (Exception e){
                      //回滚
                      transactionStatus.setRollbackOnly();
                  }
  
              }
          });
  }

  使用transactionManager

代码#

   static int s;
    int i;
    int j;

    {
        int i = 1;
        i++;
        j++;
        s++;
    }

    public void test(int j) {
        j++;
        i++;
        s++;
    }

    public static void main(String[] args) {
        Exam5 obj1 = new Exam5();
        Exam5 obj2 = new Exam5();
        obj1.test(10);
        obj1.test(20);
        obj2.test(30);

        System.out.println(obj1.i + "," + obj1.j + "," + obj1.s);
        System.out.println(obj2.i + "," + obj2.j + "," + obj2.s);
    }

运行结果#

2,1,5
1,1,5

分析#

就近原则#

代码中有很多修改变量的语句，下面是用就近原则+作用域分析的图

局部变量和类变量#

• 局部变量包括方法体{}，形参，以及代码块

  带static为类变量，不带的为实例变量
  代码中的变量分类

编程题#

有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;
    }

代码#

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;
    }

}

结果

代码#

 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;
	}
}

输出：

特点#

• 该类只有一个实例
  • 构造器私有化
• 该类内部自行创建该实例
  • 使用静态变量保存
• 能向外部提供这个实例
  • 直接暴露
  • 使用静态变量的get方法获取

几大方法#

饿汉式#

随着类的加载进行初始化，不管是否需要都会直接创建实例对象

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实例对象
• 静态内部类不会自动随着外部类的加载和初始化而初始化，他需要单独去加载和初始化
• 又由于他是在内部类加载和初始化时，创建的，属于类加载器处理的，所以是线程安全的

题目#

		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);

讲解#

对于操作数栈和局部变量表的理解#

• 对于下面的代码

  		int i=10;
  		int j=9;
  		j=i;

  反编译之后，查看字节码

  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);

  编译后的字节码

   0 bipush 10
   2 istore_1
   3 bipush 20
   5 istore_2
   6 iload_1
   7 iinc 1 by 1
  10 istore_1
  11 iinc 2 by 1
  14 iload_2
  15 istore_2
  16 getstatic #5 <java/lang/System.out : Ljava/io/PrintStream;>
  19 iload_1
  20 invokevirtual #6 <java/io/PrintStream.println : (I)V>
  23 getstatic #5 <java/lang/System.out : Ljava/io/PrintStream;>
  26 iload_2
  27 invokevirtual #6 <java/io/PrintStream.println : (I)V>
  30 return

  如上对于j = ++j ;是

介绍#

使用代码托管中心（远程服务器）

• 团队内写作 push–clone–push— –pull
• 跨团队写作 fork（到自己的远程库）—clone

创建远程库&创建别名#

• 官网：https://github.com
• 现在yuebuqun注册一个账号 创建一个远程库git-demo，创建成功
• 创建远程库别名 git remote -v （查看别名） 为远程库创建别名 git remote add git-demo https://github.com/lwmfjc/git-demo.git 别名创建成功 fetch和push都可以使用别名

推送本地库到远程库#

• 推送master分支 切换git checkout master
• 推送 git push git-demo master

拉取远程库到本地库#

• git pull git-demo master 结果

克隆远程库到本地#

• git clone xxxxxxx/git-demo.git clone之后有默认的别名，且已经初始化了本地库

团队内写作#

• lhc修改了git-demo下的hello.txt
• 之后进行git add hello.txt
• git commit -m “lhc-commit " hello.txt
• 现在进行push git push origin master 出错了
• 使用ybq，对库进行设置，管理成员
• 添加成员即可 输入账号名
• 将邀请函 发送给lhc
• 现在再次推送，则推送成功

团队外合作#

• 先把别人的项目fork下来