面试一

  最近参加了几次面试，发现公司的笔试题目有一些相似之处，就总结一下：

一般会从下面几个方面考，不管是面试C++,C#,java都是

首先是关于关键字和标示常量的考察

然后是关于类和接口的试题

然后是关于array,io和socket的试题

然后是关于数据库的各种sql语句的考察

然后是排序，包括快速排序，插入排序，选择排序

然后是设计模式的考察

一下以java为例子说明一些自己遇到的：

访问控制:

private 私有的

protected 受保护的

public 公共的

类、方法和变量修饰符

abstract 声明抽象

class 类

extends 扩允,继承

final 终极,不可改变的

implements实现

interface 接口

native 本地

new 新,创建

static 静态 

strictfp 严格,精准

synchronized 线程,同步

transient 短暂

volatile 易失

程序控制语句

break 跳出循环

continue 继续

return 返回

do 运行

while 循环

if 如果

else 反之

for 循环

instanceof 实例

switch 开关

case 返回开关里的结果

default 默认

错误处理

catch 处理异常

finally 有没有异常都执行

throw 抛出一个异常对象

throws 声明一个异常可能被抛出

try 捕获异常

包相关

import 引入

package 包

基本类型

boolean 布尔型

byte 字节型

char 字符型

double 双精度,

float 浮点

int 整型

long 长整型

short 短整型

null 空

true 真

false 假

变量引用

super 父类,超类

this 本类

void 无返回值

无const 和 goto, 不过这两个词是保留字而不是关键词。保留字是系统保留起来不给用户使用，系统自己也不会用

无friendly和sizeof哦！！！

标识符变量,类与方法都需要一定的名称,我们将这种名称叫做标识符.java中对标识符有一定的限制.首先:所有的标识符的首字符必须是字母（大小写）.下划线＿或美元符$;其次标示符是由数字（0--9）,所有从a--z的大写字母.a--z的小写字母与下划线＿.美元符$与所有在十六进制0xc0前的 ascii码等构成;第三注意表示符不能使用系统保留的关键字做标示符.

Java关键字this、super使用总结

 一、this

        Java关键字this只能用于方法方法体内。当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是this。因此，this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this，这在“Java关键字static、final使用总结”一文中给出了明确解释。并且this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this。下面给出一个使用this的综合实例，以便说明问题：

package org.leizhimin;

public class Test6 {

 private int number;

 private String username;

 private String password;

 private int x = 100;

 public Test6(int n) {

  number = n;  // 这个还可以写为: this.number=n;

 }

 public Test6(int i, String username, String password) {

  // 成员变量和参数同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.

  this.username = username;

  this.password = password;

 }

 // 默认不带参数的构造方法

 public Test6() {

  this(0, "未知", "空"); // 通过this调用另一个构造方法

 }

 public Test6(String name) {

  this(1, name, "空"); // 通过this调用另一个构造方法

 }

 public static void main(String args[]) {

  Test6 t1 = new Test6();

  Test6 t2 = new Test6("游客");

  t1.outinfo(t1);

  t2.outinfo(t2);

 }

 private void outinfo(Test6 t) {

  System.out.println("-----------");

  System.out.println(t.number);

  System.out.println(t.username);

  System.out.println(t.password);

  f(); // 这个可以写为: this.f();

 }

 private void f() {

  // 局部变量与成员变量同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.

  int x;

  x = this.x++;

  System.out.println(x);

  System.out.println(this.x);

 }

  //返回当前实例的引用

 private Test6 getSelf() {

  return this; 

 }

}

 运行结果如下：

-----------

0

未知

空

100

101

-----------

0

游客

空

100

101

         看着上面的例子，说明在什么情况下需要用到this：

        第一、通过this调用另一个构造方法，用发是this(参数列表)，这个仅仅在类的构造方法中，别的地方不能这么用。

        第二、函数参数或者函数中的局部变量和成员变量同名的情况下，成员变量被屏蔽，此时要访问成员变量则需要用“this.

成员变量名”的方式来引用成员变量。当然，在没有同名的情况下，可以直接用成员变量的名字，而不用this，用了也不为错，呵呵

        第三、在函数中，需要引用该函所属类的当前对象时候，直接用this。

        其实这些用法总结都是从对“this是指向对象本身的一个指针”这句话的更深入的理解而来的，死记不然容易忘记而且容易

搞错，要理解！

 二、super

         super关键和this作用类似，是被屏蔽的成员变量或者成员方法或变为可见，或者说用来引用被屏蔽的成员变量和成员成员

方法。

不过super是用在子类中，目的是访问直接父类中被屏蔽的成员，注意是直接父类（就是类之上最近的超类）。下面是一个综合运用

super的例子，有两个类：一个Father类，一个Father类的子类Son，通过这两个类完全演示了super的用法，一下是代码：

package org.leizhimin;

public class Father {

 public String v="Father";

 public String x="输出了Father类的public成员变量x!!!";

 

 public Father() {

  System.out.println("Father构造方法被调用!");

 }

 public Father(String v){

  this.v="Father类的带参数构造方法!运行了.";

 }

 public void outinfo(){

  System.out.println("Father的outinfo方法被调用");

 } 

 public static void main(String[] args) {

  // TODO 自动生成方法存根

 }

}

 package org.leizhimin;

public class Son extends Father{

 public String v="Son";

 public Son() {

  super();      //调用超类的构造方法,只能放到第一行.

  System.out.println("Son无参数构造方法被调用!");

  //super();      //错误的,必须放到构造方法体的最前面.

 } 

  public Son(String str){

  super(str);

  System.out.println("Son带参数构造方法被调用!");

 }

 //覆盖了超类成员方法outinfo()

 public void outinfo(){ 

  System.out.println("Son的outinfo()方法被调用");

 } 

  public void test(){

    String v="哈哈哈哈!";   //局部变量v覆盖了成员变量v和超类变量v

    System.out.println("------1-----");

  System.out.println(v);   //输出局部变量v

  System.out.println(this.v);  //输出(子类)成员变量v

  System.out.println(super.v); //输出超类成员变量v 

    System.out.println("------2-----");

  System.out.println(x);   //输出超类成员变量v,子类继承而来

  System.out.println(super.x); //输出超类成员变量v

    System.out.println("------3-----");

  outinfo();   //调用子类的outinfo()方法

  this.outinfo();  //调用子类的outinfo()方法

  super.outinfo(); //调用父类的outinfo()方法

 } 

  public static void main(String[] args) {

  new Son().test();

   }

}

 子类Son运行结果：

 Father构造方法被调用!

Son无参数构造方法被调用!

------1-----

哈哈哈哈!

Son

Father

------2-----

输出了Father类的public成员变量x!!!

输出了Father类的public成员变量x!!!

------3-----

Son的outinfo()方法被调用

Son的outinfo()方法被调用

Father的outinfo方法被调用

 

        说明：次例子仅仅为了说明super的用法，实际在设计类的时候一般都尽可能私有(private)化。

        通过上面的例子，下面总结一下super的用法：

        第一、在子类构造方法中要调用父类的构造方法，用“super(参数列表)”的方式调用，参数不是必须的。同时还要注意的一点是：“super(参数列表)”这条语句只能用在子类构造方法体中的第一行。

        第二、当子类方法中的局部变量或者子类的成员变量与父类成员变量同名时，也就是子类局部变量覆盖父类成员变量时，用“super.成员变量名”来引用父类成员变量。当然，如果父类的成员变量没有被覆盖，也可以用“super.成员变量名”来引用父类成员变量，不过这是不必要的。

        第三、当子类的成员方法覆盖了父类的成员方法时，也就是子类和父类有完全相同的方法定义（但方法体可以不同），此时，用“super.方法名(参数列表)”的方式访问父类的方法。