面试题1

1.sql优化（博客园上有，先总结这么多，应付面试）
  0.一般不用select *
  1.不能用null作索引，即如下这种方法是不可以的：select...form ...where xyz is null 或者 is not null 
  2.联连接  
    不推荐：select * from employss where first_name||''||last_name ='Beill Cliton';
    推荐：*** where first_name ='Beill' and last_name ='Cliton';
  3.带通配符(%)的like语句
    不推荐： select * from employee where last_name like '%cliton%';
    推荐：select * from employee where last_name like 'c%';
  4.not
    不推荐：... where not (status ='VALID')或者... where status <>'INVALID';
    推荐：select * from employee where salary<3000 or salary>3000;
    
2. instanceof 检查是否是类的对象，用于判断对象是否所属于指定类或者接口

3.
   打印1-100的6的倍数 出现的次数
   int count=0;
   for(int x=1;x<=100;x++)
   {
     if(x%6==0)
      count++;
   } 
     System.out.println("count="+count); 
   }
   ------------------------------------------
   3000米，每天去除一半，需要多少天会小于5米
   思路：定义个变量表示天数
   除的动作和天数累加的动作是重复进行。
   int day=0;
   for(int x=3000;x>=5;x/=2)
   {
           day++;    
    }
    System.out.println(day);
   }

4. break continue
   break:用于选择结构或者循环结构。
   continue: 用于循环结构，结束本次循环，开始下一次循环
 
5. 重载，overload。
   当多个函数的功能一致，只是参与运算的参数不同。为了提高代码的阅读性，以及方便调用，
   所以将这些函数都定义成一个名字，通过参数列表来进行这些函数的区分。

6.排序
  选择：
  /// <summary>
        /// 简单选择排序
        /// </summary>
        /// <param name="arry">待排序的数组</param>
        public static void SimpleSelectSort(int[] arry)
        {
            int tmp = 0;
            int t = 0;//最小数标记
            for (int i = 0; i < arry.Length; i++)
            {
                t = i;
                for (int j = i + 1; j < arry.Length; j++)
                {
                    if (arry[t] > arry[j])
                    {
                        t = j;
                    }
                }
                tmp = arry[i];
                arry[i] = arry[t];
                arry[t] = tmp;
            }
        }
  冒泡：
  /// <summary>
        /// 冒泡排序
        /// </summary>
        /// <param name="arry">要排序的整数数组</param>
        public static void BubbleSort(int[] arry)
        {
            for (int i = 0; i < arry.Length-1; i++)
            {
                for (int j = 0; j < arry.Length - 1 - i; j++)
                {
                    //比较相邻的两个元素，如果前面的比后面的大，则交换位置
                    if (arry[j] > arry[j + 1])
                    {
                        int temp = arry[j + 1];
                        arry[j + 1] = arry[j];
                        arry[j] = temp;
                    }
                }
            }
        }


7.内存图:
  栈内存：存放局部变量，函数上和函数内定义的变量都是局部变量
          变量一旦使用完毕，自动清空
  堆内存：new 关键字建立的， 都称为对象，或者实体（数组实实在在存在的东西）
          在堆内存里面
  堆里面一开辟空间，就有一个头部值。（内存地址值，16进制开始）
 
  堆内存
  1.每一个数组（数组其实也是对象，比较特殊的对象）或对象
      都有自己的内存地址值
  2.堆内存中的变量都有默认初始化值

  **引用数据类型    （null常量是给引用数据类型使用的）
      类 class
      接口  interface
      数组 （[])

  3.堆内存是通过垃圾回收机制回收

8.一个实体可以被多个引用型变量引用

9.数组遇见问题：
  异常出现在运行时期
  角标越界异常:使用到数组中不存在的角标。
  (ArrayIndexOutOfBoundsException)   数组特有异常

  空指针异常：引用型变量等于null，也就是没有指向。
 （NullPointsException）

10.数组（也可以存储对象）
   本身就是一个容器，用来存储数据。
   特点：是固定长度的。
   好处：给元素进行编号，从零开始。同时也可以通过length属性获取数组长度。
   什么时候使用数组呢？
		当数据较多时，通常为了方便操作这些数据都需要进行临时存储。	
   习惯：通常操作数组都需要进行遍历。获取数组中的元素需要一个指针。通过对指针的值的改变就可以对数组中的数据进行操作。

11.int[] arr = new int[3];
   该句代码在内存中的分配情况。
	
   堆内存：开辟一个空间，建立一个数组实体，并对数组中的元素进行了默认初始化。
   栈内存：定一个局部变量，存放了该实体在堆内存中的首地址值。

   栈内存特点：存放局部变量，当该变量使用完毕(生命周期结束)，自动被释放。
   堆内存特点：存放数组和对象，每一个实体都有内存地址值，堆内存中的变量都有默认初始化值，通过垃圾回收机制对堆内存中	
   
12.对象和类的关系。
   类描述事物，对象既该类事物实在的个体。

13.类中的变量就是成员变量
   方法中的就是局部变量

14.封装：隐藏实现细节，提高了安全性
   程序中的其中 一种体现：通常将类中的成员变量私有化（private），通过对外提供方法（set,get）对该变量进行访问。

15.对象的存在有什么好处？或者说为什么创建对象呢？
   对象可以用于封装数据。可以在对象中定义属性和行为，并被指挥。

16.静态 ：
   1.静态随着类的加载而加载，直接类名调用。静态生存周期最长。占内存。
   2.静态优先于对象存在
   3.静态被所有对象所引用
                         
   共有的静态，不共有的不静态。例：饮水机
   直接被类名所访问。

17.单例设计模式：保证类在内存中的对象唯一性
   步骤：                            
   1.定义私有并静态的本类对象
   2.私有化构造函数
   3.提供静态方法返回该对象

   有时间看看《大话设计模式》一书：
   单例模式除了可以保证唯一的实例外，还有什么好处呢？
   答：单例模式因为Singleton类封装它的唯一实例，这样它可以严格地控制客户怎样访问它以及何时访问它。简单地说就是对唯一实例的受控访问。
 
   饿汉式：即静态初始化的方式，它是类一加载就实例化的对象，所以要提前占用系统资源
   懒汉式：又面临多线程访问安全性的问题	

18.构造函数：
   对象一建立，就被调用，给对象初始化。构造函数不需要返回值。
   凡是class定义的类， 都有默认的构造函数。

   什么时候定义构造函数？
   当对象产生时，需要一些具体的属性或者行为的时候。就定义在构造函数中。
   比如，人对象一产生就需要具体的姓名和年龄，这些值都在构造函数中进行指定。

19.static关键字：可以把对象中重复的东西抽取出来，以便共用。
   静态成员，可以直接被类名访问调用。
   静态随着类的加载而加载。静态优先于对象存在。
   静态被所有对象所共享。

20.继承：
   注意：
   子类的方法权限应该是大于等于 父类方法的权限，才能覆盖

21.Override和Overload的区别?Overload是否可以改变返回值类型?
   Override方法重写：在子类中，出现和父类中一模一样的方法声明的现象
   Overload方法重载：同一个类中，出现的方法名相同，参数列表不同的现象
   方法重载能改变返回值类型，因为它和返回值类型无关

   博客园:
   父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。
   在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。
   但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。
 
   重写方法只能存在于具有继承关系中，重写方法只能重写父类非私有的方法。

22.抽象方法和接口（java面试葵花宝典，经典问题，基本上必问）。。。。重点
   
   抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。
   抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。
   举个简单的例子，飞机和鸟是不同类的事物，但是它们都有一个共性，就是都会飞。
   那么在设计的时候，可以将飞机设计为一个类Airplane，将鸟设计为一个类Bird，
   但是不能将 飞行 这个特性也设计为类，因此它只是一个行为特性，并不是对一类事物的抽象描述。
   此时可以将 飞行 设计为一个接口Fly，包含方法fly( )，然后Airplane和Bird分别根据自己的需要实现Fly这个接口。
   然后至于有不同种类的飞机，比如战斗机、民用飞机等直接继承Airplane即可，对于鸟也是类似的，不同种类的鸟直接继承Bird类即可。
   从这里可以看出，继承是一个 "是不是"的关系，而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类，
   则子类必定是抽象类的种类，而接口实现则是有没有、具备不具备的关系，比如鸟是否能飞（或者是否具备飞行这个特点），
   能飞行则可以实现这个接口，不能飞行就不实现这个接口。

   下面看一个网上流传最广泛的例子：门和警报的例子：门都有open( )和close( )两个动作，此时我们可以定义通过抽象类和接口来定义这个抽象概念：
   abstract class Door {
     public abstract void open();
     public abstract void close();
   }

   interface Door {
    public abstract void open();
    public abstract void close();
   }
   但是现在如果我们需要门具有报警alarm( )的功能，那么该如何实现？下面提供两种思路：

　　1）将这三个功能都放在抽象类里面，但是这样一来所有继承于这个抽象类的子类都具备了报警功能，但是有的门并不一定具备报警功能；

　　2）将这三个功能都放在接口里面，需要用到报警功能的类就需要实现这个接口中的open( )和close( )，也许这个类根本就不具备open( )和close( )这两个功能，比如火灾报警器。

　　从这里可以看出， Door的open() 、close()和alarm()根本就属于两个不同范畴内的行为，open()和close()属于门本身固有的行为特性，而alarm()属于延伸的附加行为。因此最好的解决办法是单独将报警设计为一个接口，包含alarm()行为,Door设计为单独的一个抽象类，包含open和close两种行为。再设计一个报警门继承Door类和实现Alarm接口。

   interface Alram {
    void alarm();
   }

   abstract class Door {
    void open();
    void close();
   }

   class AlarmDoor extends Door implements Alarm {
    void oepn() {
      //....
    }
    void close() {
      //....
    }
    void alarm() {
      //....
    }
  }