1）transient和volatile是java关键字吗？（瞬联）
若是用transient声明一个实例变量，当对象存储时，它的值不需要维持。例如：
class T
{
设计模式之Interpreter
int b; //需要维持
}
5.
volatile润饰符告诉编译器被volatile润饰的变量可以被程序的其他部分改变。在多线程程序中，有时两个或更多的线程共享一个沟通的实例变量。考虑效率问题，每个线程可以自己保存该共享变量的私有拷贝。实际的变量副本在不同的时候更新，如当进进synchronized方法时。 用strictfp润饰类或方法，可以确保浮面运算（以及一切切断）正如早期的Java版本那样粗确。切断只影响某些操作的指数。当一个类被strictfp润饰，一切的方法自动被strictfp润饰。
strictfp的意思是FP-strict，也就是说粗确浮面的意思。在Java虚拟机举行浮面运算时，若是没有指定strictfp关键字时，Java的编译器以及运行环境在对浮面运算的表达式是采取一种近似于我行我素的行为来完成这些操作，以致于得到的了局往往无法令您满意。而一旦使用了strictfp来声明一个类、接口或者方法时，那么所声明的范围内Java的编译器以及运行环境会完全遵照浮面规范IEEE-754来执行。因此若是您想让您的浮面运算更加粗确，而且不会因为不同的硬件平台所执行的了局不一致的话，那就请用关键字strictfp。
您可以将一个类、接口以及方法声明为strictfp，但是不答应对接口中的方法以及构造函数声明strictfp关键字，例如下面的代码：
strictfp interface A {}
很简单一个模式,就是在内存中保留原来数据的拷贝.
strictfp void f() {}
}
答案: 错。final int i 是个final的 instant variable (实例变量，或叫成员变量)。final的instant variable没有default value，必需在constructor (构造器)结束之前被赋予一个明确的值。可以修改为"final int i = 0;"。
2. 错误的使用方法
interface A {
strictfp void f();
}
public class FpDemo2 {
strictfp FpDemo2() {}
方法一：继承 Thread 类，覆盖方法 run()，我们在创建的 Thread 类的子类中重写 run() ,加进线程所要执行的代码即可。下面是一个例子：
public class MyThread extends Thread
{
int count= 1, number;
public MyThread(int num)
{
number = num;
System.out.println
("创建线程 " + number);
}
public void run() {
while(true) {
System.out.println
("线程 " + number + ":计数 " + count);
if(++count== 6) return;
}
}
public static void main(String args[])
{
for(int i = 0;i 〈 5; i++) new MyThread(i+1).start();
}
}
这类方法简单明了，符合大家的习惯，但是，它也有一个很大的缺面，那就是若是我们的类已经从一个类继承（如小程序必需继承自 Applet 类），则无法再继承 Thread 类，这时若是我们又不想创设一个新的类，该当怎么办呢？
我们不妨来探索一种新的方法：我们不创建Thread类的子类，而是直接使用它，那么我们只能将我们的方法作为参数传递给 Thread 类的实例，有面类似回调函数。但是 Java 没有指针，我们只能传递一个包含这个方法的类的实例。
那么如何限制这个类必需包含这一方法呢？当然是使用接口！（固然抽象类也可满足，但是需要继承，而我们之所以要采用这类新方法，不就是为了避免继承带来的限制吗？）
Java 提供了接口 java.lang.Runnable 来支持这类方法。
方法二：实现 Runnable 接口
Runnable接口只有一个方法run()，我们声明自己的类实现Runnable接口并提供这一方法，将我们的线程代码写进其中，就完成了这一部分的任务。但是Runnable接口并没有任何对线程的支持，我们还必需创建Thread类的实例，这一面通过Thread类的构造函数 public Thread(Runnable target);来实现。下面是一个例子：
public class MyThread implements Runnable
{
int count= 1, number;
public MyThread(int num)
{
number = num;
System.out.println("创建线程 " + number);
}
public void run()
{
while(true)
{
System.out.println
("线程 " + number + ":计数 " + count);
if(++count== 6) return;
}
}
public static void main(String args[])
{
for(int i = 0; i 〈 5;i++) new Thread(new MyThread(i+1)).start();
}
}
严格地说，创建Thread子类的实例也是可行的，但是必需注意的是，该子类必需没有覆盖 Thread 类的 run 方法，否则该线程执行的将是子类的 run 方法，而不是我们用以实现Runnable 接口的类的 run 方法，对此大家不妨试验一下。
使用 Runnable 接口来实现多线程使得我们能够在一个类中包容一切的代码，有利于封拆，它的缺面在于，我们只能使用一套代码，若想创建多个线程并使各个线程执行不同的代码，则仍必需额外创建类，若是这样的话，在大多半情况下也许还不如直接用多个类分别继承 Thread 来得紧凑。
综上所述，两种方法各有千秋，大家可以灵活运用。
下面让我们一同来研究一下多线程使用中的一些问题。
三、线程的四种状态
1. 新状态：线程已被创建但尚未执行（start() 尚未被调用）。
2. 可执行状态：线程可以执行，固然不一定正在执行。CPU 时间随时可能被分配给该线程，从而使得它执行。
3. 死亡状态：一般情况下 run() 返回使得线程死亡。调用 stop()或 destroy() 亦有同样效果，但是不被推荐，前者会产生异常，后者是强制终止，不会释放锁。
4. 阻塞状态：线程不会被分配 CPU 时间，无法执行。
4、线程的优先级
线程的优先级代表该线程的重要程度，当有多个线程同时处于可执行状态并等待获得 CPU 时间时，线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间，优先级高的线程有更大的机会获得 CPU 时间，优先级低的线程也不是没有机会，只是机会要小一些罢了。
您可以调用 Thread 类的方法 getPriority() 和 setPriority()来存取线程的优先级，线程的优先级界于1(MIN_PRIORITY)和10(MAX_PRIORITY)之间，缺省是5(NORM_PRIORITY)。
一旦使用了关键字strictfp来声明某个类、接口或者方法时，那么在这个关键字所声明的范围内一切浮面运算都是粗确的，符合IEEE-754规范
的。例如一个类被声明为strictfp，那么该类中一切的方法都是strictfp的。
C.行为模式
2）抽象类和接口有什么区分？（瞬联）
各司其职的类串成一串,好象伐鼓传花,当然若是自己能完成,就不要推委给下一个.
class Other
3.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。
public static void main(String[] args)
}
5.接口中定义的变量默认是public static final 型，且必需给其初值，所以实现类中不能重新定义，也不能改变其值。
{
int x = 0;
}
class B
7.接口中的方法默认都是 public,abstract 类型的。
{
3）能说一下java的反射(reflection)机制吗？（瞬联）
开放性和原因衔接(causally-connected)是反射系统的两大基本要素
|
4）在java中如何实现多线程？（瞬联） 什么是将行为封拆,Command是最好的说明. implement Runnable
} |
}
设计:design
设计模式之Observer
设计模式之Adapter
创建模式，结构模式和行为模式
GoF设计模式
abstract class Something
设计模式之Factory(工厂模式)
使用工厂模式就象使用new一样频仍.2002/10/9更新
状态是编程中经常碰到的实例,将状态对象化,设立状态变换器,便可在状态中轻松切换.
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
设计模式之Builder
汽车由车轮 标的目的盘 发动机很多部件组成，同时，将这些部件组拆成汽车也是一件复杂的工作，Builder模式就是将这两种情况分隔隔离分散举行。
设计模式之Singleton(单态模式)
保证一个类只有一个实例,并提供一个访问它的全局访问面 2002/10/9更新
{
会
设计模式之Facade
可扩展的使用JDBC针对不同的数据库编程,Facade提供了一种灵活的实现.
设计模式之Proxy
{
this.name = name;
}
public void play()
框架:framework
8.
设计模式之Composite
就是将类用树形结构组合成一个单位.您向别人介绍您是某单位，您是单位中的一个元素，别人和您做买卖，相当于和单位做买卖。文章中还对Jive再举行了剖析。
设计模式之Decorator
Decorator是个油漆工,给您的东东的外表刷上秀丽的颜色.
设计模式之Bridge
将"牛郎织女"分隔隔离分散(本应在一同,分隔隔离分散他们,形成两个接口),在他们之间搭建一个桥(动态的结合)
设计模式之Flyweight
提供Java运行性能,降低小而大量重复的类的开销.
}
实际上向您介绍了为什么要使用Java 抽象类,该模式原理简单,使用很普遍.
设计模式之Memento
public strictfp class FpDemo1 {
11）java中存在内存泄漏问题吗？请举例说明？（IBM）
MVC (Modal View Controler)正本是存在于Desktop程序中的，M是指数据模型，V是指用户界面，C则是控制器。使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。比如一批统计数据您可以分别用柱状图、饼图来表示。C存在的目的则是确保M和V的同步，一旦M改变，V该当同步更新。
模型－视图－控制器（MVC）是Xerox PARC在八十年代为编程言语Smalltalk－80发明的一种软件设计模式，至今已被广泛使用。最近几年被推荐为Sun公司J2EE平台的设计模式，并且遭到越来越多的使用 ColdFusion 和 PHP 的开发者的欢迎。模型－视图－控制器模式是一个有效的工具箱，它有很多好处，但也有一些缺面。
MVC如何工作
MVC是一个设计模式，它强制性的使应用程序的输进、处理和输出分隔隔离分散。使用MVC应用程序被分成三个核心部件：模型、视图、控制器。它们各自处理自己的任务。
视图
视图是用户看到并与之交互的界面。对老式的Web应用程序来讲，视图就是由HTML元素组成的界面，在新式的Web应用程序中，HTML依旧在视图中扮演着重要的角色，但一些新的技术已层出不穷，它们包括Macromedia Flash和象XHTML，XML/XSL，WML等一些标识言语和Web services.
如何处理应用程序的界面变得越来越有挑战性。MVC一个大的好处是它能为您的应用程序处理很多不同的视图。在视图中其实没有真正的处理发生，不管这些数据是联机存储的仍是一个雇员列表，作为视图来讲，它只是作为一种输出数据并答应用户操纵的方式。
模型
模型表示企业数据和业务规则。在MVC的三个部件中，模型拥有最多的处理任务。例如它可能用象EJBs和ColdFusion Components这样的构件对象来处理数据库。被模型返回的数据是中立的，就是说模型与数据格式无关，这样一个模型能为多个视图提供数据。由于应用于模型的代码只需写一次就可以被多个视图重用，所以减少了代码的重复性。
控制器
控制器接管用户的输进并调用模型和视图去完成用户的需求。所以当单击Web页面中的超链接和发送HTML表单时，控制器本身不输出任何东西和做任何处理。它只是接收请求并决定调用哪个模型构件去处理请求，然后用确定用哪个视图来显示模型处理返回的数据。
而今我们总结MVC的处理过程，首先控制器接收用户的请求，并决定该当调用哪个模型来举行处理，然后模型用业务逻辑来处理用户的请求并返回数据，最后控制器用相应的视图格式化模型返回的数据，并通过表示层呈现给用户。
为什么要使用 MVC
大部分Web应用程序都是用像ASP，PHP，或者CFML这样的过程化言语来创建的。它们将像数据库查询语句这样的数据层代码和像HTML这样的表示层代码混在一同。经验比较雄厚的开发者会将数据从表示层分离开来，但这平常不是很简单做到的，它需要粗心的计划和不竭的尝试。MVC从根本上强制性的将它们分隔隔离分散。尽管构造MVC应用程序需要一些额外的工作，但是它给我们带来的好处是无庸质疑的。
首先，最重要的一面是多个视图能共享一个模型，正如我所提及的，而今需要用越来越多的方式来访问您的应用程序。对此，其中一个解决之道是使用MVC，无论您的用户想要Flash界面或是 WAP 界面；用一个模型就能处理它们。由于您已经将数据和业务规则从表示层分隔隔离分散，所以您可以最大化的重用您的代码了。
由于模型返回的数据没有举行格式化，所以同样的构件能被不同界面使用。例如，很多半据可能用HTML来表示，但是它们也有可能要用Macromedia Flash和WAP来表示。模型也有状态管理和数据持久性处理的功能，例如，基于会话的购物车和电子商务过程也能被Flash网站或者无线联网的应用程序所重用。
因为模型是自包含的，并且与控制器和视图相分离，所以很简单改变您的应用程序的数据层和业务规则。若是您想把您的数据库从MySQL移植到Oracle，或者改变您的基于RDBMS数据源到LDAP，只需改变您的模型即可。一旦您正确的实现了模型，不管您的数据来自数据库或是LDAP服务器，视图将会正确的显示它们。由于运用MVC的应用程序的三个部件是相互对立，改变其中一个不会影响其它两个，所以依据这类设计思惟您能构造良好的松偶合的构件。
对我来讲，控制器的也提供了一个好处，就是可以使用控制器来联接不同的模型和视图去完成用户的需求，这样控制器可以为构造应用程序提供强有力的手段。给定一些可重用的模型和视图，控制器可以根据用户的需求选择模型举行处理，然后选择视图将处理了局显示给用户。
MVC的缺面
MVC的缺面是由于它没有明确的定义，所以完全理解MVC并不是很简单。使用MVC需要粗心的计划，由于它的内部原理比较复杂，所以需要花费一些时间去思考。
您将不得不花费相当可观的时间去考虑如何将MVC运用到您的应用程序，同时由于模型和视图要严格的分离，这样也给调试应用程序到来了一定的艰巨。每个构件在使用之前都需要经过彻底的测试。一旦您的构件经过了测试，您就可以毫无顾忌的重用它们了。
根据我个人经验，由于我们将一个应用程序分成了三个部件，所以使用MVC同时也意味着您将要管理比以前更多的文件，这一面是显而易见的。这样好像我们的工作量增加了，但是请记住这比起它所能带给我们的好处是不值一提。
MVC并不适合小型甚至中等规模的应用程序，花费大量时间将MVC应用到规模并不是很大的应用程序平常会得不偿失。
MVC是一条创建软件的好路子
MVC设计模式是一个很好创建软件的路子，它所首倡的一些原则，像内容和显示互相分离可能比较好理解。但是若是您要隔离模型、视图和控制器的构件，您可能需要重新思考您的应用程序，尤其是应用程序的构架方面。若是您肯接管MVC，并且有能力应付它所带来的额外的工作和复杂性，MVC将会使您的软件在健壮性，代码重用和结构方面上一个新的台阶。
设计模式之Chain of Responsibility
{
设计模式之Command
extends Thread
设计模式之State
System.out.println("i = " + i);
13）请说一下System.gc()函数的作用。什么时候可以调用垃圾回收器？（瞬联）
{
不同算法各自封拆,用户端可随意挑选需要的算法.
5）您用过哪种设计模式？（瞬联，IBM，aspenTech）
1.abstract class 在 Java 言语中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。
transient int a; //不需要维持
主要用来对言语的分析,应用机会不多.
设计模式之Visitor
访问者在举行访问时,完成一系列实质性操作,而且还可以扩展.
}
这个模式已经被整合进Java的Collection.在大多半场合下无需自己制造一个Iterator,只要将对象拆进Collection中，直接使用Iterator举行对象遍历。
6）请说一下MVC架构（瞬联，IBM，aspenTech）
Model:模型层
View:视图层
Controller:控制层
介绍如何使用Java API提供的现成Observer
}
interface A
6.抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。
{
int x =1;
}
class C extends B implements A
{
public void pX()
{
System.out.println(x);
}
public static void main(String[] args) {
new C().pX();
}
}
答案：错误。在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用，两个x都匹配（就象在同时import java.util和java.sql两个包时直接声明Date一样）。对于父类的变量,可以用super.x来明确(输出的是1)，而接口的属性默认隐含为 public static final.所以可以通过A.x来明确(输出的是0)。
下面的代码运行时会不会报错
interface Playable
{
void play();
}
interface Bounceable
{
void play();
}
interface Rollable extends Playable, Bounceable
{
Ball ball = new Ball("PingPang");
}
class Ball implements Rollable
{
private String name;
public String getName()
2.在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必需是static final的，不过在 interface中一般不定义数据成员），一切的成员方法都是abstract的。
以Jive为例,剖析代理模式在用户级别授权机制上的应用
private String name;
8）请说一下java中为什么要引进内部类？还有匿名内部类？（瞬联，IBM）
9）请说一下final，finally和finalize的区分？（瞬联）
final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。
10）请说一下HTTP请求的基本过程（IBM）
18.JAVA代码查错
模式:pattern
B.结构模式
void doSomething ()
12）请说一下java中的内存回收机制所采用的算法（IBM，瞬联）
固然垃圾回收关心着大部分的问题，包括内存管理，使得程序员的任务显得更加轻松，但是程序员仍是可能犯些错误导致内存泄漏问题。GC(垃圾回收)通过递归对一切从“根”对象(堆栈中的对象，静态数据成员，JNI句柄等等)继承下来的引用举行工作，然后标记一切可以访问的举动着的对象。而这些对象变成了程序唯一能够操纵的对象，其他的对象都被释放了。因为GC使得程序不能够访问那些被释放的对象，所以这样做是平安的。
4.实现抽象类和接口的类必需实现其中的一切方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。
垃圾回收函数,手动调用的.
当一个对象终止被举动声明所引用，它就变成了垃圾（garbage）可以被回收重新使用
15）Math.round()什么作用？
Math.Round(3.44, 1) = 3.4
Math.Round(3.45, 1) = 3.4
Math.Round(3.46, 1) = 3.5
-----------------------------------------------
Math.Round(3.54, 1) = 3.5
Math.Round(3.55, 1) = 3.6
Math.Round(3.56, 1) = 3.6
-----------------------------------------------
Math.Round(3.64, 1) = 3.6
Math.Round(3.65, 1) = 3.6
Math.Round(3.66, 1) = 3.7
-----------------------------------------------
Math.Round(3.74, 1) = 3.7
Math.Round(3.75, 1) = 3.8
Math.Round(3.76, 1) = 3.8
这类舍进方法叫做银行家舍进（Banker'sRound），这就是已经规定下来的标准、Round的标准、世界的标准。
Round <> 四舍五进
16、设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。
以下程序使用内部类实现线程，对j增减的时候没有考虑顺序问题。
package java_example150;
答案: 正确。输出的是"i = 0"。int i属於instant variable (实例变量，或叫成员变量)。instant variable有default value。int的default value是0。
for(int i=0;i<2;i++){
Thread ts = new Thread(inc);
ts.start();
ts= new Thread(dec);
ts.start();
}
}
private synchronized void inc(){
j++;
System.out.println(Thread.currentThread().getName()+"-inc:"+j);
}
private synchronized void dec(){
j--;
System.out.println(Thread.currentThread().getName()+"-dec:"+j);
}
class Inc implements Runnable{
public void run(){
for(int i=0;i<10;i++){
inc();
}
}
}
class Dec implements Runnable{
public void run(){
for(int i=0;i<10;i++){
dec();
}
}
}
}
(成员变量)，而o的reference并没有改变。
设计模式之Prototype(原型模式)
17.CORBA是什么?用途是什么?
答：CORBA 标准是公共对象请求代理结构(Common Object Request Broker Architecture)，由对象管理组织 (Object Management Group，缩写为 OMG)标准化。它的组成是接口定义言语(IDL), 言语绑定(binding:也译为联编)和答应应用程序间互操作的和谈。 其目的为：
1. 用不同的程序设计言语书写
2. 在不同的进程中运行
3. 为不同的操作系统开发
1.
abstract class Name
{
ball = new Ball("Football");
System.out.println(ball.getName());
}
}
答案: 错。"interface Rollable extends Playable, Bounceable"没有问题。interface可继承多个interfaces，所以这里没错。问题出在interface Rollable里的"Ball ball = new Ball("PingPang");"。任何在interface里声明的interface variable (接口变量，也可称成员变量)，默认为public static final。也就是说"Ball ball = new Ball("PingPang");"实际上是"public static final Ball ball = new Ball("PingPang");"。在Ball类的Play()方法中，"ball = new Ball("Football");"改变了ball的reference，而这里的ball来自Rollable interface，Rollable interface里的ball是public static final的，final的object是不能被改变reference的。因此编译器将在"ball = new Ball("Football");"这里显示有错。
public abstract boolean isStupidName(String name) {}
public void addOne(final Other o)
答案: 错。abstract method必需以分号结尾，且不带花括号。
14）您做过的项目中采用了什么平安认证机制？（IBM）
2.
public class Something
{
int i,i2; return (i-i2); //when i为足够大的正数,i2为足够大的负数。了局会造成溢位，导致错误。
{
int l = s.length();
}
}
Mediator很象十字路口的红绿灯,每个车辆只需和红绿灯交互就可以.
答案: 错。局部变量前不能放置任何访问润饰符 (private，public，和protected)。final可以用来润饰局部变量
(final如同abstract和strictfp，都是非访问润饰符，strictfp只能润饰class和method而非variable)。
3.
A.创建模式
{
private abstract String doSomething ();
答案: 错。int x被润饰成final，意味着x不能在addOne method中被修改。
答案: 错。abstract的methods不能以private润饰。abstract的methods就是让子类implement(实现)具体细节的，怎么可以用private把abstractmethod封闭起来呢? (同理，abstract method前不能加final)。
4.
public class Something
{
p360ublic int addOne(final int x)
return ++x;
}
public int i;
}
private String s = "";
使用类再生的两个方式:组合(new)和继承(extends),这个已经在"thinking in java"中提到过.
public class Something
{
{
Other o = new Other();
new Something().addOne(o);
}
设计模式之Mediator
{
o.i++;
}
设计模式之Iterator
{
return name;
}
public Ball(String name)
{
|
7）若是类a继承类b，实现接口c，而类b和接口c中定义了同名变量，请问会出现什么问题？（瞬联） } public String doSomething() (比如: o = new Other();)，那么如同上例这题也是错的。但这里修改的是o的member vairable 设计模式之Strategy 6. class Something int i; public void doSomething() { System.out.println("i = " + i); } 设计模式之Template public class TestThread3{ public static void main(String[] args) 7. class Something { final int i; public void doSomething() { } 这里，若是T类的一个对象写进一个持久的存储区域，a的内容不被保存，但b的将被保存。 public class Something { Something s = new Something(); System.out.println("s.doSomething() returns " + doSomething()); } 答案: 正确。在addOne method中，参数o被润饰成final。若是在addOne method里我们修改了o的reference { return "Do something ..."; } } 答案: 错。看上去在main里call doSomething没有什么问题，毕竟两个methods都在同一个class里。但仔细看，main是static的。static method不能直接call non-static methods。可改成"System.out.println("s.doSomething() returns " + s.doSomething());"。同理，static method不能访问non-static instant variable。 太原婚车装饰鲜花选择_太原婚礼装车 |
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
