Spring学习笔记（一）Java基础知识复习

对象的创建方式、获取对象并且进行比较、==和equals的区别、单例模式(饿汉和懒汉)、对象的初始化数据操作、数组的数据初始化操作有几种、各个类型的初始值是什么，User u1 = new User();这句话包含的知识点、无参构造函数和有参构造函数

源码获取github

学习spring的时候，都是用的maven项目学习，idea如何创建maven项目教程，传送门

1.项目结构

2.需要的jar包

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.11</version>
  <scope>test</scope>
</dependency>

3.对象的创建方式

• 使用new关键字实例化对象

• 使用Class_forName实例化对象

  User.java

  package com.hs.model;
  
  public class User {
  
   private String user_name;
   private Integer user_id;
  
  
   public String getUser_name() {
      return user_name;
   }
  
   public void setUser_name(String user_name) {
      this.user_name = user_name;
   }
  
   public Integer getUser_id() {
      return user_id;
   }
  
   public void setUser_id(Integer user_id) {
      this.user_id = user_id;
   }
  }

  CreateObject.java

  package com.hs.test;
  
  import com.hs.model.User;
  import org.junit.Test;
  
  /** * 对象的创建方式 */
  public class CreateObject {
   /** * 使用new关键字实例化对象 */
   @Test
   public void test01() {
      User u = new User();
      System.out.println(u);
   }
  
   /** * 使用Class_forName实例化对象 * @throws ClassNotFoundException * @throws IllegalAccessException * @throws InstantiationException */
   @Test
   public void test02() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
      User u = (User) Class.forName("com.hs.model.User").newInstance();   //com.hs.model.User为类的全路径，newInstance()实例化对象
      System.out.println(u);
      u.setUser_name("悟空");
      System.out.println(u.getUser_name());
   }
  
  }

4.获取对象并且进行比较

• new 一次，就产生一个新的对象，两个对象都是不一样的，都是新的
• 对象每次都可以是一样的、同一个实例

GetObject.java

package com.hs.test;

import com.hs.model.User;
import org.junit.Test;

/** * 获取对象并且进行比较 */
public class GetObject {
   /** * 考查知识点，对象每次都可以是新的 */
   @Test
   public void test01() {
      User u1 = this.getUser();
      User u2 = this.getUser();
      System.out.println(u1);
      System.out.println(u2);
      System.out.println(u1 == u2);   //结果是false
      System.out.println(u1.equals(u2));  //结果是false
      //百度==和equals比较的是什么？是内存地址，如果对象(都是继承了object(里面有equals方法))里重写equals，又是什么结果，
   }

   public User getUser() {
      //new 一次，就产生一个新的对象(内存地址不一样)，两个对象都是不一样的，都是新的
      return new User();
   }

   /** * 考查知识点，对象每次都可以是一样的、同一个实例 */
   @Test
   public void test02() {
      User u1 = this.getUser02();
      User u2 = this.getUser02();
      System.out.println(u1);
      System.out.println(u2);
      System.out.println(u1 == u2);   //结果是true
      System.out.println(u1.equals(u2));  //结果是true
      //百度==和equals比较的是什么？是内存地址，如果对象(都是继承了object(里面有equals方法))里重写equals，又是什么结果，
      u1.setUser_name("悟空");

      System.out.println(u2.getUser_name());  //输出悟空，为什么会这样？设计到一个叫引用传递的

   }

   private static User u1 = new User();    //设计模式-单例的设计 饿汉(不管你用不用，我都先创建好),加了一个static，表示这是一个共享数据

   public User getUser02() {
      return this.u1;
   }

   //懒汉(你用我才创建)---线程不安全
   /*private static User u2; public User getUser002() { if (u2 == null) { u2 = new User(); } return this.u2; }*/
}

5.==和equals的区别

1. ==是判断两个变量或实例是不是指向同一个内存空间
   equals是判断两个变量或实例所指向的内存空间的值是不是相同

2. ==是指对内存地址进行比较
   equals()是对字符串的内容进行比较

3. ==指引用是否相同
   equals()指的是值是否相同

4. 如果对象(都是继承了object(里面有equals方法))里重写equals了，又是不同结果

6.单例模式-设计模式

• 饿汉:不管你用不用，我都先创建好

  private static User u1 = new User();    //加了一个static，表示这是一个共享数据

• 懒汉：你用我才创建，线程不安全

  private static User u2;
   public User getUser002() {
      if (u2 == null) {
         u2 = new User();
      }
      return this.u2;
   }

7.对象的初始化数据操作

1. 构造函数—初始化数据
2. Setter方法
3. 如果对象的属性不是private，可以实例化对象.属性=xx赋值

InitObject.java

/** * 构造函数—初始化数据 */
@Test
public void test01() {
   User u1 = new User();
   /*这一句话设计到的知识点： new 开辟一块堆内存空间 User(); 构造函数 1.创建对象 2.对数据进行初始化操作 u1: 在栈内存中定义了一个变量指向了堆内存空间 * */
   /*构造函数知识点： 1.默认有一个无参构造函数 2.若写了一个有参构造函数，覆盖了默认的无参，直接new User()报错 3.第2点解决办法就是，再写一次无参构造函数 4.每个构造函数默认一个super(),不写也有，并且得在首行 * */
   System.out.println(u1.getUser_name());  //初始化的数据为空
}

/** * setter方法初始化数据，其实如果属性不private，可以直接对象的变量.属性赋值 */
@Test
public void test02() {
   User u1 = new User();
   u1.setUser_id(200);
   u1.setUser_name("八戒");
}

8.数组的初始化操作有几种

1. 动态初始化
2. 静态初始化

InitObject.java

Test
public void test03() {
   //动态初始化
   int[] arr = new int[3];
   //char[] arr = new char[3];
   System.out.println(arr[2]);
   //静态初始化
   boolean[] arr2 = {false, true, true};   //下面的那种简写
   boolean[] arr3 = new boolean[]{false, true, true};
}

9.数组各个类型的初始值(默认值)

10.User u1 = new User();这句话包含的知识点

1. new 开辟一块堆内存空间
2. User(); 构造函数
   1.创建对象
   2.对数据进行初始化操作
3. u1: 在栈内存中定义了一个变量指向了堆内存空间

11.无参构造函数和有参构造函数

1. 默认有一个无参构造函数
2. 若写了一个有参构造函数，覆盖了默认的无参，直接new User()报错
3. 第2点解决办法就是，再写一次无参构造函数
4. 每个构造函数默认一个super(),不写也有，并且得在首行