面试--JavaSE高频面试题

1. 问题一（自增变量）：

   1. package com.model.number;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/8/7 14:55
       * ++i 和 i++
       */
      public class NumberDemo01 {
          public static void main(String[] args) {
      
              int i=1;
              i=i++;  //运算，会把i压入栈中，（再对i执行++，i变成了2）,执行弹栈操作将最后的结果复制为i,i又变成了1
              System.out.println("i="+i);
              int j=i++;  //当i++是，的运算时，先对其原值进行压栈操作，再对其执行++操作改变原来的值
              System.out.println("i="+i+"\tj="+j);
              int k=i+ ++i*i++; //压栈，压入2，  先执行++i,i变成了3再次压入栈中3,在执行i++,i变成了4，栈中分别是2+3*3=11
              System.out.println("i="+i+"\tj="+j+"\tk="+k);
      
          }
      }

      

2. 问题二：（单例模式）

   1. 

   2. package com.model.question;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/8/7 15:38
       * 单例模式
       */
      public class QuestionDemo02 {
      
          public static void main(String[] args) {
              Single1 single1 = Single1.getSingle1();
      
      
          }
      }
      //饿汉式，普通方法实现
      class Single1{
      //    1.构造器私有化，
      //    2.自行创建实例，并用静态变量保存
      //    3.向外提供实例
      //    4.强调这是一个单例，我们可以使用final修饰
          private  static final Single1 SINGLE_1=new Single1();
      
          private Single1() {
          }
          public static Single1 getSingle1(){
              return SINGLE_1;
          }
      }
      //饿汉式，枚举实现
      enum Single2{
          SINGLE_2;
      }
      //饿汉式，静态代码快实现
      class Single3{
          private static final Single3 SINGLE_3;
          static {
      //        还可以通过获取配置文件的信息，对实例进行复制
              SINGLE_3=new Single3();
          }
          private Single3() {
          }
          public static Single3 getSingle3(){
              return SINGLE_3;
          }
      }
      
      //  懒汉式_DCl，普通方法实现
      class  Single4{
          private static volatile Single4 SINGLE_4;
      
          private Single4() {
          }
          public static Single4 getSingle4(){
              if (SINGLE_4==null){
                  synchronized(Single4.class) {
                      if (SINGLE_4==null) {
                          SINGLE_4 = new Single4();
                      }
                  }
              }
              return SINGLE_4;
          }
      
      }
      //懒汉式，
      // 1.构造器私有化
      //2.声明私有静态一个实例变量
      //3.创建一个公共的方法，返回实例对象
      class Single5{
          private static Single5 single5;
      
          private Single5() {
          }
          public Single5 getSingle5(){
              if (single5==null){
                  single5=new Single5();
              }
              return single5;
          }
      }
      //懒汉式，静态内部类形式
      //静态内部类，不会随着外部类的加载和初始化而进行初始化，他是单独存在的（单独加载和初始化）
      //因为是在内部类加载和初始化的，不存在线程安全问题
      class Single6{
          private Single6() {
          }
          public static class Inner{
              private static final Single6 SINGLE_6=new Single6();
          }
          public static Single6 getInstance(){
              return Inner.SINGLE_6;
          }
      }

3. 问题三 （类初始化和实例初始化）：

   1. 执行顺序：父类的静态变量的赋值和静态代码块(谁在上面谁先执行)>子类的静态变量的赋值和静态代码块(谁在上面谁先执行)　>父类的初始化块和实例变量的初始化（谁在前面实现执行）>父类的构造方法
   2. >子类的初始化块和实例变量的初始化（谁在前面谁先执行）>子类的构造方法　
   3. 
   4. 
   5. 

4.  方法的参数传递机制：

   1. 
   2. 

   3. 

   4. package com.model.question;
      
      import java.util.Arrays;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/8/7 18:18
       * 参数传参问题
       */
      public class QuestionDemo03 {
          public static void main(String[] args) {
              int num=1;
              Integer integer=128;//包装类和字符串类对象的不可变形，不会改变他原来的值，他会在内存中重新创建一个对象。
              // 如果是-128-127的数都是在常量池中的，如果超过这个数是在堆中产生
      
              String str="张紫韩";
              int[] arr={1,2,3,4,5,6};
              change(num, integer, str, arr);
              System.out.println(num);
              System.out.println(integer);
              System.out.println(str);
              System.out.println(Arrays.toString(arr));
      
          }
      
          public static void change(int num,Integer integer,String str,int[] arr){
              num++;
              integer++;
              str+="zzh";
              arr[0]=100;
          }
      }

       

5. 递归与迭代：

   1. 上台阶问题：
   2. 

   3. package com.model.question;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/8/7 17:24
       * 迭代和递归实现上台阶问题
       */
      public class QuestionDemo04 {
          public static void main(String[] args) {
              System.out.println(f(4));
              System.out.println(fb(4));
      
          }
      
      //    递归
          public static int f(int n){
              if (n==1||n==2){
                  return n;
              }else {
                  return f(n-1)+f(n-2);
              }
          }
      
      //    迭代
          public static int fb(int n){
              if (n==1||n==2){
                  return n;
              }else {
                  int one=2;//最后是一步的情况
                  int two=1;//最后是两步的情况
                  int sum=0;
                  for (int i = 3; i <=n; i++) {
                      sum=one+two;
                      two=one;
                      one=sum;
      
                  }
                  return sum;
              }
          }
      }

6. 成员变量与局部变量：

   1. 

   2. 

7.