Jamie, j'aime...: 面试经验2012

2011-2012最多的是等待，耐心等待的最后，虽然一开始不是好的结果，但是相信神所预备的，不是人所能看透的。惟有求神赐下智慧，让我能清楚如何倚靠他，如果他愿意，求他指示我在他的计划中该做什么。

从4月中旬又开始找工作了，虽然重新开始不是一件容易的事，但总算林林总总有些面试。面试的职位基本上都是Ingenieur developpement en Java/J2EE，或是test。大部分是SSII，只有少数几家是非SSII。可能因为最后一次实习是在路透的缘故，很多金融方面的SSII会主动找我。

1.Adneom （SSII）
地点：Levallois perret
面试时间：2012年4月25日
面试内容：
与RH面试，问的都是基本的问题，介绍做过的项目等等，用英语介绍自己的实习，这一点之前没准备过，说起来结结巴巴，虽说本以为自己英文没什么问题，但是一到介绍专业技术问题就开始舌头打结。
面完之后跟Ingenieur d'affaire面，说要和我前任负责人联系。
面试结果：
5月2日再度联系说可以有进一步，ingenieur d'affair至今未与我联系。

2.Meritis （SSII）
地点：巴黎2区，opera附近
面试时间：2012年4月27日
面试内容：
与RH面试，问的也都是基本的问题，介绍做过的项目等等。
没有后续联系

3.Addstones Consulting （SSII）
地点：巴黎8区
面试时间：2012年4月30日
面试内容：
与RH面试，关于9月以后在干什么，说到changement de statut，可能有负面作用
面试结果：
5月10日被拒

4.Finaxys （SSII）
地点：Neuilly-sur-Seine
面试时间：2012年5月4日
面试内容：
第一面：与RH面试，RH对我的英语大加赞许，听了changement de statut的问题，反而建议我去找律师，觉得Sogeti可能不太合乎法律。本来安排了技术面试，结果她说为了让我准备好一点，推迟技术考试的时间；
第二面：技术考试
时间：5月7日
面试内容：
考的都是概念性的东西，都是java core和多线程之类的问题。
不会的知识点有：

Byte-code是什么？

L'ensemble des instructions exécutables sur une machine virtuelle java.

Application, applet, servlet有什么区别。

Application:un programme utilisant le langage java qui généralisement tourne sur la machine où se trouve au départ le code.

Applet:L'applet est récupéré à distance à travers un navigateur Web et s'exécute sur celui-ci.

Un servlet sert à ajouter les fonctionnalités à un serveur Web.

关键字包括Trans和Volatile吗？

没有Trans，Volatile est utilisé sur les variables qui peuvent être modifiées de maniers asychrone.

hashCode（）是哪个类里面的？

Les classes Object.

Java对于eqauls方法和hashCode方法是这样规定的：1、如果两个对象相同，那么它们的hashCode值一定要相同；2、如果两个对象的hashCode相同，它们并不一定相同上面说的对象相同指的是用eqauls方法比较。

Date（）类如何操作，如何获取时间？

格式化输出日期时间（这个用的比较多）

Date date=new Date();
SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
String time=df.format(date);
System.out.println(time);

List 和 Set有什么区别？

Java中的集合（Collection）有两类，一类是List，再有一类是Set。你知道它们的区别吗？前者集合内的元素是有序的，元素可以重复；后者元素无序，但元素不可重复。

introspection是什么？

L'introspection est un mécanisme qui permet de connaître le contenu d'une classe dynamiquement. Il permet notamment de savoir ce que contient une classe sans en avoir les sources. Ces mécanismes sont largement utilisés dans des outils de type IDE (Integrated Development Environnement : environnement de développement intégré).

Java Bean是什么？
import static会带来什么影响？
autoboxing？
AWT 和Swing有什么不同？
JLabel的方法包括setPicture（）和setForeground()吗？
Look&Feel？
EJB有哪几种Session？
EJB有哪些组件（composants）？
EJB的stateless和statefull是什么？
如何创建EJB？
EJB session stateless是什么？
Java Mail使用什么协议？

面试完后5月9日接到人力的电话，说47题对了27题，算是bon，之后ingenieur d'affaire给我电话，口头问了一些问题，涉及形容一下Polymophism，Multithread， deadlock是怎么形成的，如何解决，wait（）用法是什么；memory leak；Java类里面Objet的class有哪些；Design Pattern有哪些；等等。

之后另一个Ingenieur d'affaire就跟我联系了一个mission，和客户的chef de projet面试。
面试时间：5月16日

面试内容：
主要问的是Collection和多线程的问题，还有一点SWING。
不会的知识点：

重写hashcode的时候有什么限制？

Si une classe redéfinit la méthode equals() alors elle doit aussi redéfinir la méthode hashCode() et inversement. Le comportement de ces deux méthodes doit être symétrique : si les méthodes hashCode() et equals() sont redéfinies alors elles doivent utiliser, de préférence, toutes les deux les même champs car deux objets qui sont égaux en utilisant la méthode equals() doivent obligatoirement avoir tous les deux la même valeur de retour lors de l'invocation de leur méthode hashCode(). L'inverse n'est pas forcement vrai.

Le hashcode ne fournit pas un identifiant unique pour un objet : de toute façon le hashcode d'un objet est de type int, ce qui limiterait le nombre d'instances possible d'une classe.

Deux objets pouvant avoir le même hashcode, il faut alors utiliser la méthode equals() pour déterminer si deux objets sont identiques.

———————————————contraintes————————————————————

La redéfinition des méthodes equals() et hashcode() doit respecter quelques contraintes qui sont précisées dans la documentation de la classe Object :
Symétrie : pour deux références a et b, si a.equals(b) alors il faut obligatoirement que b.equals(a)
Réflexivité : pour toute référence non null, a.equals(a) doit toujours renvoyer true
Transitivité : si a.equals(b) et b.equals(c) alors a.equals(c)
Consistance avec la méthode hashCode() : si deux objets sont égaux en invoquant la méthode equals() alors leur méthode hashCode() doit renvoyer la même valeur pour les deux objets
Pour toute référence non null, a.equals(null) doit toujours renvoyer false

L'implémentation de la méthode hashcode() doit être consistante avec la méthode equals() : si la méthode equals() renvoie true pour deux objets alors la méthode hashCode() invoquée sur les deux objets doit renvoyer la même valeur. L'inverse n'est pas vrai, deux objets dont la méthode hashCode() renvoie la même valeur, n'implique pas obligatoirement que l'invocation de la méthode equals() sur les deux objets renvoie true.

Il est donc nécessaire de redéfinir les méthodes hashCode() et equals() de manière coordonnée si l'une ou l'autre est redéfinie. Pour garantir le contrat entre les méthodes equals() et hashCode() et leur efficacité maximale, il est préférable que leur implémentation utilise les mêmes champs de la classe.

notify，notifyAll，和wait的具体使用方法。

wait()、notify()、notifyAll()是三个定义在Object类里的方法，可以用来控制线程的状态。

这三个方法最终调用的都是jvm级的native方法。随着jvm运行平台的不同可能有些许差异。

如果对象调用了wait方法就会使持有该对象的线程把该对象的控制权交出去，然后处于等待状态。
如果对象调用了notify方法就会通知某个正在等待这个对象的控制权的线程可以继续运行。
如果对象调用了notifyAll方法就会通知所有等待这个对象控制权的线程继续运行。

其中wait方法有三个over load方法：

wait()
wait(long)
wait(long,int)

wait方法通过参数可以指定等待的时长。如果没有指定参数，默认一直等待直到被通知。

La méthode wait suspend l'exécution d'un thread, en attendant qu'une certaine condition soit réalisée. La réalisation de cette condition est signalée par un autre thread par les méthodes notify ou notifyAll.

Lorsque la méthode wait est invoquée à partir d'une méthode synchronized, en même temps que l'exécution est suspendue, le verrou posé sur l'objet par lequel la méthode a été invoquée est relâché. Dès que la condition de réveil survient, le thread attend de pouvoir reprendre le verrou et continuer l'exécution. Notez qu'une autre version de wait prend en argument un entier de type long qui définit la durée d'attente maximale (en millisecondes). Si ce temps est dépassé, le thread est réveillé.

La méthode notify réveille un seul thread. Si plusieurs threads sont en attente, c'est celui qui a été suspendu le plus longtemps qui est réveillé. Lorque plusieurs threads sont en attente et qu'on veut tous les réveiller, il faut utiliser la méthode notifyAll.

http://blog.csdn.net/alex197963/article/details/6863662

在调用wait的时候，线程自动释放其占有的对象锁，同时不会去申请对象锁。当线程被唤醒的时候，它才再次获得了去获得对象锁的权利。
所以，notify与notifyAll没有太多的区别，只是notify仅唤醒一个线程并允许它去获得锁，notifyAll是唤醒所有等待这个对象的线程并允许它们去获得对象锁，只要是在synchronied块中的代码，没有对象锁是寸步难行的。其实唤醒一个线程就是重新允许这个线程去获得对象锁并向下运行。

notifyAll，虽然是对每个wait的对象都调用一次notify，但是这个还是有顺序的，每个对象都保存这一个等待对象链，调用的顺序就是这个链的顺序。其实启动等待对象链中各个线程的也是一个线程，在具体应用的时候，需要注意一下。

wait(),notify(),notifyAll()不属于Thread类,而是属于Object基础类,也就是说每个对像都有wait(),notify(),notifyAll()的功能。因为都个对像都有锁,锁是每个对像的基础,当然操作锁的方法也是最基础了。

wait():

等待对象的同步锁,需要获得该对象的同步锁才可以调用这个方法,否则编译可以通过，但运行时会收到一个异常：IllegalMonitorStateException。

调用任意对象的 wait() 方法导致该线程阻塞，该线程不可继续执行，并且该对象上的锁被释放。

notify():

唤醒在等待该对象同步锁的线程(只唤醒一个,如果有多个在等待),注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。

调用任意对象的notify()方法则导致因调用该对象的 wait()方法而阻塞的线程中随机选择的一个解除阻塞（但要等到获得锁后才真正可执行）。

notifyAll():

唤醒所有等待的线程,注意唤醒的是notify之前wait的线程,对于notify之后的wait线程是没有效果的。

死锁，以及如何避免

Un inter-blocage (ou deadlock) est un blocage qui intervient lorsque par exemple un thread A attend un thread B en même temps que B attend A.

class DeadLock {

    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    void a() throws InterruptedException {
        lock1.wait();
        lock2.notify();
    }

    void b() throws InterruptedException {
        lock2.wait();
        lock1.notify();
    }

}

Si un thread T1 exécute a() et qu'un thread T2 exécute b(), il y a inter-blocage. En effet, T1 attend le notify() de T2, mais pour que T2 appelle le notify(), il faut d'abord queT1 exécute son notify()...

il ne faut pas tout synchroniser. Si une méthode ne peut être appelée que d'un seul et unique thread, ne la synchronisez pas. En l'occurence, les méthodes d'écouteurs Swing seront forcément appelés dans l'EDT, donc inutile de synchroniser quoi que ce soit (sauf si vous créez à partir de là de nouveaux threads).

数据库的死锁是怎么发生的

Il est possible que deux transactions se bloquent mutuellement, chacune attendant des données verrouillées par l'autre. C'est ce qu'on appelle un interblocage (deadlock).

MySQL détecte automatiquement les interblocages, et annule (ROLLBACK) l'une des deux transactions (celle qui a modifié le moins de lignes).

SWING中的监听

Les interfaces EventListener permettent à un composant de générer des événements utilisateurs. Une classe doit contenir une interface auditrice pour chaque type de composant :

ActionListener : clic de souris ou enfoncement de la touche Enter
ItemListener : utilisation d'une liste ou d'une case à cocher
MouseMotionListener : événement de souris
WindowListener : événement de fenêtre

监听是用的那个线程

Le Thread dans lequel s'exécute le code qui gère l'interface graphique
est appelé Event Dispatch Thread ou EDT (ce n'est pas le Thread
principal de l'application).

Dès qu'un composant a été rendu visible (realized), tout le code
qui dépend ou qui pourrait affecter l'état du composant doit être
exécuté dans le Event Dispatch Thread (EDT).

Toutes les tâches qui prennent du temps doivent être exécutées en dehors du EDT.
Les composants de l'interface graphique ne doivent être accédés que depuis le EDT

• Le Thread principal (Main Thread) qui exécute les instructions au
lancement de l'application
• Le Event Dispatch Thread qui exécute le code de tous les gestionnaires
d'événement (Event Listeners)
• Les Worker Threads (ou Background Threads) qui sont les threads dans
lesquels sont exécutés les tâches qui prennent du temps (ou qui sont en
attente d'un signal asynchrone quelconque

如何管理多个线程

En java, il est possible de simuler l'exécution de plusieurs programmes en même
temps . C'est le multithreading. L'exécution de chaque programme est alors
appelé un thread.

Démarrage, suspension, reprise et arrêt d'un thread.

Pour gérer l'exécution des threads, on dispose de différentes méthodes dont celles ci-dessous.
public void start() : cette méthode permet de démarrer un thread. En effet, si on invoque la méthode run (au lieu de start),
le code s'exécute bien, mais aucun nouveau thread n'est lancé dans le système.
Inversement, la méthode start, lance un nouveau thread dans le système dont le code à exécuter démarre par le run.

public void suspend() : cette méthode permet d'arrêter temporairement un thread en cours d'exécution.
public void resume() : celle-ci permet de relancer l'exécution d'un thread, au préalable mis en pause via suspend.
Attention, le thread ne reprend pas au début du run, mais continue bien là où il s'était arrêté.
public void stop() : cette dernière méthode permet de stopper, de manière définitive, l'exécution du thread.
Une autre solution pour stopper un thread consiste à simplement sortir de la méthode run.

Dans certaines situations, il peut donc être indispensable de créer un
ou plusieurs Threads (pour effectuer les opérations qui prennent beaucoup
de temps) et de mettre à jour l'interface graphique en invoquant l'une
des deux méthodes utilitaires invokeLater() ou éventuellement
invokeAndWait() qui permettront d'insérer les instructions
nécessaires dans le EDT.

RMI。

RMI (Remote Method Invocation) est une API Java permettant de manipuler des objets distants (c'est-à-dire un objet instancié sur une autre machine virtuelle, éventuellement sur une autre machine du réseau) de manière transparente pour l'utilisateur, c'est-à-dire de la même façon que si l'objet était sur la machine virtuelle (JVM) de la machine locale.

之前打电话的ingenieur d'affaire也跟我联系了一个mission，和另一个客户的chef de projet面试。
包含知识点：

polymorphisme, héritage, classe abstraite

Une méthode abstraite est signalée par le modificateur abstract placé au début de son en-tête. Une telle méthode n'a alors que son prototype, c'est-à-dire son type de retour suivi, de son nom, suivi de la liste de ses paramètres entre des parenthèses, suivi d'un point-virgule. Une méthode abstraite ne peut pas être déclarée static ou private ou final.

Dès qu'une classe contient une méthode abstraite, elle doit elle aussi être déclarée abstraite, avec le modificateur abstract placé au début de son en-tête .

Une classe abstraite ne peut pas être instanciée. Il faudra l'étendre et définir toutes les méthodes abstraites qu'elle contient pour pouvoir l'utiliser.

Une sous-classe d'une classe abstraite sera encore abstraite si elle ne définit pas toutes les méthodes abstraites dont elle hérite.

Les classes abstraites sont très utiles pour définir des méthodes dépendant d'autres méthodes qui ne sont pas précisées.

Design patterns

public class Singleton {

private static Singleton uniqueInstance = null;

private Singleton()
{
}

public static Singleton getInstance()
{
if(uniqueInstance == null){
uniqueInstance = new Singleton();
}

return uniqueInstance;
}

...

...

}

Bases de données : requêtes SQL simples

SELECT, INSERT, DELETE, UPDATE

SELECT Champ_1,Champ_2,Champ_n FROM Nom_de_la_table WHERE condition

INSERT INTO

la_table

(champ1, champ2, ... champX)

VALUES

('valeur1', 'valeur2, ... 'valeurX');

DELETE FROM

la_table

WHERE

{ condition };

UPDATE Nom_de_la_table SET Champ_1 = 'Valeurs_1', Champ_n = 'Valeurs_n'

CREATE TABLE Nom_de_la_table ( Nom_de_colonne_1 Types_de_données, Nom_de_colonne_2 Types_de_données, Nom_de_colonne_n Types_de_données )

procédures stockées

Les procédures stockées contiennent du code SQL compilé, permettant d'exécuter des requêtes lourdes ou des instructions régulièrement utilisées sur des bases de données.

Les procédures stockées sont conservées dans la base de données dans une forme exécutable et sont capables d'appeler d'autres procédures ou fonctions comme d'être appelées par d'autres programmes.

(1)重复使用。存储过程可以重复使用，从而可以减少数据库开发人员的工作量。

(2)提高性能。存储过程在创建的时候就进行了编译，将来使用的时候不用再重新编译。一般的SQL语句每执行一次就需要编译一次，所以使用存储过程提高了效率。

(3)减少网络流量。存储过程位于服务器上，调用的时候只需要传递存储过程的名称以及参数就可以了，因此降低了网络传输的数据量。

(4)安全性。参数化的存储过程可以防止SQL注入式的攻击，而且可以将Grant、Deny以及Revoke权限应用于存储过程。

indexes

Un index est un objet complémentaire (mais non indispensable) à la base de données permettant d'"indexer" certaines colonnes dans le but d'améliorer l'accès aux données par le SGBDR, au même titre qu'un index dans un livre ne vous est pas indispensable mais vous permet souvent d'économiser du temps lorsque vous recherchez une partie spécifique de ce dernier...

CREATE [UNIQUE] INDEX Nom_de_l_index

ON Nom_de_la_table

(Nom_de_champ [ASC/DESC], ...)

triggers

CREATE TRIGGER — Définir un nouveau déclencheur

CREATE TRIGGER nom { BEFORE | AFTER } { evenement [ OR ... ] }

ON table [ FOR [ EACH ] { ROW | STATEMENT } ]

EXECUTE PROCEDURE nomfonc ( arguments )

Votre méthodologie de tests/ Tests unitaires : JUnit

Les étapes de la méthodologie

Définition du Contexte
Description de l'organisation
Formalisation des tests
Exécution des tests
Gestion des fiches d'anomalie
Révision des fournitures

public class FourOpCalculatorTest extends TestCase {}{

public void testSub() {

int result = a - b;

assertEquals(result, simpleCalculator.sub(a, b));

}

public class AllTests {

public static Test suite() {

TestSuite suite =

new TestSuite("Suite de teste pour les outils de calcul");

//$JUnit-BEGIN$

suite.addTest(new TestSuite(FourOpCalculatorTest.class));

suite.addTest(new TestSuite(ExtendedCalculatorTest.class));

//$JUnit-END$

return suite;

}

Qualité logicielle : Maven

Le coeur d'un projet Maven 2 est le modèle objet projet (appelé POM pour project object model). Il contient une description détaillée de votre projet, avec en particulier des informations concernant le versionnage et la gestion des configurations, les dépendances, les ressources de l'application, les tests, les membres de l'équipe, la structure et bien plus encore. Le POM prend la forme d'un fichier XML (pom.xml) qui est placé dans le répertoire de base de votre projet.

5.Extia （SSII）
地点：SEVRES
面试时间：5月10日
面试内容：
先是RH面，最后RH丢下一份总共11个题目的题目。主要涉及继承，多态，封装，transient关键字，等等。
不会的知识点：

继承
JDBC，statement，preparedstatement，callablestatement，parameterisedstatement，多条SQL语句的时候用哪个statement，调用已经储存的数据用哪个语句。
finalize有什么用处？
匿名内部类
final，static

5月21日第二面

6.Key Consulting （SSII）
地点：Suresnes
面试时间：5月11日
面试内容：
先是RH面，然后也是丢下两份题目，一份是Java，一份是J2EE。
不会的知识点：

où on utilise "this"?
La nouveautés de J2SE5 et J2SE6
errreur grave non récupérable
Comment utiliser JBuilder?
Comment on peut écrire la boucle en Java 5
verrou exclusif?
Singleton
Différence entre run et start?
Qu'est-ce que JAX-WS, JAX-RS?
MVC
Struts
La différence de Tomcat et Jetty
La différence entre Servlet et JSP
Qu'est-ce que WAR, EAR?
Architecture en couches.

5月14日第二面

先是Directeur technique面，主要是问一下，了解一下情况，介绍一下他们的projet，之后就换一个技术人员面，居然问到实习以前具体的东西，hibernate如何调用数据库问了我两遍，哎，谁记得两年前做了什么，闹心，闹心，闹心……本以为这个公司大有希望，虽然工资低点，但是不是重点，可是，可是，

7.Altran （SSII）
地点：巴黎17区
面试时间：5月11日
面试内容：
RH面，找的是做test的，介绍了一下公司，然后换我介绍，问我为什么喜欢做测试等等的，altran吸引我的地方在哪里。
5月15日被拒。

8.Criteo （e-commerce）
面试时间：5月3日
面试内容：
电话面，基本上相当于第一面，因为电话里问了很多细节，时间也很长，完了之后用email发我一个codality上的测试，测试时间为1小时，共两题。都是编程题，第一题跟数组有关，是金融的应用题；第二题是跟堆栈有关。
第一题没做完，时间不够。
5月9日给我发信让我去面试
地点：巴黎9区
面试时间：5月15日
面试内容：会见QA Manager，并有test technique
做的test正好是在网上看到的，写cas de test。
可惜，可惜，这没有结束，哎，╮(╯▽╰)╭，真是让人十分郁闷，manager立马让我写一个list的类，然后说让这个类指向[1,2,5]，之后又要写个方法reverse。过程十分纠结，基本上就是java教学过程，郁闷，书到用时方恨少。估计，估计，这个我最向往的公司，没戏了。。。
5月18日被拒

9.Alyotech France（SSII）
地点：Antony
面试时间：5月14日
面试内容：
基本内容，然后进行test technique，是qcm，不过是多选题，有的题目很纠结，考得都懵了，什么重点题都不记得了。。。。
之后ingenieur d'affaire面，随便问了一下实习用的技术等等

10.Algofi（SSII）
地点：Boulogne
面试时间：5月15日
面试内容：
基本内容，然后test technique：

Jamie, j'aime...

Pages

2012/05/12

面试经验2012

4 comments: