精华内容
下载资源
问答
  • 1)transient和volatile是java关键字吗?(瞬联) 如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如: class T {   transient int a; //不需要维持  int b; //需要维持 }  这里...

    1transientvolatilejava关键字吗?(瞬联)

    如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如:

    class T

    {   

          transient int a;  //不需要维持

          int b;  //需要维持

    }  

    这里,如果T类的一个对象写入一个持久的存储区域,a的内容不被保存,但b的将被保存。

    volatile修饰符告诉编译器被volatile修饰的变量可以被程序的其他部分改变。在多线程程序中,有时两个或更多的线程共享一个相同的实例变量。考虑效率问题,每个线程可以自己保存该共享变量的私有拷贝。实际的变量副本在不同的时候更新,如当进入synchronized方法时。 strictfp修饰类或方法,可以确保浮点运算(以及所有切断)正如早期的Java版本那样准确。切断只影响某些操作的指数。当一个类被strictfp修饰,所有的方法自动被strictfp修饰。

    strictfp的意思是FP-strict,也就是说精确浮点的意思。在Java虚拟机进行浮点运算时,如果没有指定strictfp关键字时,Java的编译器以及运行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作,以致于得到的结果往往无法令你满意。而一旦使用了strictfp来声明一个类、接口或者方法时,那么所声明的范围内Java的编译器以及运行环境会完全依照浮点规范IEEE-754来执行。因此如果你想让你的浮点运算更加精确,而且不会因为不同的硬件平台所执行的结果不一致的话,那就请用关键字strictfp

    你可以将一个类、接口以及方法声明为strictfp,但是不允许对接口中的方法以及构造函数声明strictfp关键字,例如下面的代码:

    strictfp interface A {}

    public strictfp class FpDemo1 {   

          strictfp void f() {}   

    }  

    2. 错误的使用方法

    interface A {   

        strictfp void f();   

    }   

    public class FpDemo2 {   

        strictfp FpDemo2() {}   

    }

    一旦使用了关键字strictfp来声明某个类、接口或者方法时,那么在这个关键字所声明的范围内所有浮点运算都是精确的,符合IEEE-754规范

    的。例如一个类被声明为strictfp,那么该类中所有的方法都是strictfp的。

    展开全文
  • java 关键字 transient

    2021-03-11 22:27:51
    我们知道一个对象实现Serializable接口,就可以实现序列化。实现了Serializable接口的类,其所有属性和方法都会自动序列化,而transient...我们知道在Java中,对象的序列化可以通过实现两种接口来实现,若实现的Seri.
    我们知道一个对象实现Serializable接口,就可以实现序列化。实现了Serializable接口的类,其所有属性和方法都会自动序列化,而transient修饰的属性可以不被序列化。
    transient 关键字只能修饰变量,不能修饰方法和类。
    被transient关键字修饰的变量不能再被序列化,静态变量不管是否被transient修饰,都不能被序列化。
     
    被transient关键字修饰的变量真的不能被序列化吗?
    我们知道在Java中,对象的序列化可以通过实现两种接口来实现,若实现的是Serializable接口,则所有的序列化将会自动进行,
    若实现的是Externalizable接口,则没有任何东西可以自动序列化, 需要重写writeExternal和readExternal方法,它的效率比Serializable高一些,并且可以决定哪些属性需要序列化(即使是transient修饰的),但是对大量对象,或者重复对象,则效率低。
     
    transient底层实现原理:
    java的serializable接口提供了一个存储对象状态的机制,即把对象的状态存储到硬盘上去,等需要的时候再读出来使用。但有些时候银行卡号、密码这些信息不希望
    在网络上传输的,transient的作用就是把这个信息的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。
    展开全文
  • 我们的对象并不只是存在内存中,还需要传输网络,或者保存起来下次再加载出来用,所以需要Java序列化技术。 Java序列化技术正是将对象转变成一串由二进制字节组成的数组,可以通过将二进制数据保存到磁盘或者传输...

    先解释下什么是序列化

    我们的对象并不只是存在内存中,还需要传输网络,或者保存起来下次再加载出来用,所以需要Java序列化技术。

    Java序列化技术正是将对象转变成一串由二进制字节组成的数组,可以通过将二进制数据保存到磁盘或者传输网络,磁盘或者网络接收者可以在对象的属类的模板上来反序列化类的对象,达到对象持久化的目的。

    更多序列化请参考:《关于Java序列化你应该知道的一切》这篇文章。

    什么是 transient?

    简单来说就是,被 transient 修饰的变量不能被序列化。

    具体来看下面的示例1

    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    /**
     * @author 微信公众号:Java技术栈
     */
    public class TransientTest {
    
    	public static void main(String[] args) throws Exception {
    
    		User user = new User();
    		user.setUsername("Java技术栈");
    		user.setId("javastack");
    
    		System.out.println("\n序列化之前");
    		System.out.println("username: " + user.getUsername());
    		System.out.println("id: " + user.getId());
    
    		ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("d:/user.txt"));
    		os.writeObject(user);
    		os.flush();
    		os.close();
    
    		ObjectInputStream is = new ObjectInputStream(new FileInputStream("d:/user.txt"));
    		user = (User) is.readObject();
    		is.close();
    
    		System.out.println("\n序列化之后");
    		System.out.println("username: " + user.getUsername());
    		System.out.println("id: " + user.getId());
    
    	}
    }
    
    /**
     * @author 微信公众号:Java技术栈
     */
    class User implements Serializable {
    
    	private static final long serialVersionUID = 1L;
    
    	private String username;
    	private transient String id;
    
    	public String getUsername() {
    		return username;
    	}
    
    	public void setUsername(String username) {
    		this.username = username;
    	}
    
    	public String getId() {
    		return id;
    	}
    
    	public void setId(String id) {
    		this.id = id;
    	}
    
    }
    

    输出结果:

    序列化之前
    username: Java技术栈
    id: javastack
    
    序列化之后
    username: Java技术栈
    id: null
    

    示例1在 id 字段上加了 transient 关键字修饰,反序列化出来之后值为 null,说明了被 transient 修饰的变量不能被序列化。

    静态变量能被序列化吗?

    这个话题也是最近栈长的Java技术栈vip群里面讨论的,大家对这个知识点比较模糊,我就写了这篇文章测试总结一下。

    如果你也想加入我们的Java技术栈vip群和各位大牛一起讨论技术,那点击这个链接了解加入吧。

    那么,到底静态变量能被序列化吗?废话少说,先动手测试下吧!

    示例2:

    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    /**
     * @author 微信公众号:Java技术栈
     */
    public class TransientStaticTest {
    
    	public static void main(String[] args) throws Exception {
    
    		User2 user = new User2();
    		User2.username = "Java技术栈1";
    		user.setId("javastack");
    
    		System.out.println("\n序列化之前");
    		System.out.println("username: " + user.getUsername());
    		System.out.println("id: " + user.getId());
    
    		ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("d:/user.txt"));
    		os.writeObject(user);
    		os.flush();
    		os.close();
    		
    		// 在反序列化出来之前,改变静态变量的值
    		User2.username = "Java技术栈2";
    
    		ObjectInputStream is = new ObjectInputStream(new FileInputStream("d:/user.txt"));
    		user = (User2) is.readObject();
    		is.close();
    
    		System.out.println("\n序列化之后");
    		System.out.println("username: " + user.getUsername());
    		System.out.println("id: " + user.getId());
    
    	}
    }
    
    /**
     * @author 微信公众号:Java技术栈
     */
    class User2 implements Serializable {
    
    	private static final long serialVersionUID = 1L;
    
    	public static String username;
    	private transient String id;
    
    	public String getUsername() {
    		return username;
    	}
    
    	public String getId() {
    		return id;
    	}
    
    	public void setId(String id) {
    		this.id = id;
    	}
    
    }
    

    输出结果:

    序列化之前
    username: Java技术栈1
    id: javastack
    
    序列化之后
    username: Java技术栈2
    id: null
    

    示例2把 username 改为了 public static, 并在反序列化出来之前改变了静态变量的值,结果可以看出序列化之后的值并非序列化进去时的值。

    由以上结果分析可知,静态变量不能被序列化,示例2读取出来的是 username 在 JVM 内存中存储的值。

    transient 真不能被序列化吗?

    继续来看示例3:

    import java.io.Externalizable;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInput;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutput;
    import java.io.ObjectOutputStream;
    
    /**
     * @author 微信公众号:Java技术栈
     */
    public class ExternalizableTest {
    
    	public static void main(String[] args) throws Exception {
    
    		User3 user = new User3();
    		user.setUsername("Java技术栈");
    		user.setId("javastack");
    		ObjectOutput objectOutput = new ObjectOutputStream(new FileOutputStream(new File("javastack")));
    		objectOutput.writeObject(user);
    
    		ObjectInput objectInput = new ObjectInputStream(new FileInputStream(new File("javastack")));
    		user = (User3) objectInput.readObject();
    
    		System.out.println(user.getUsername());
    		System.out.println(user.getId());
    
    		objectOutput.close();
    		objectInput.close();
    	}
    
    }
    
    /**
     * @author 微信公众号:Java技术栈
     */
    class User3 implements Externalizable {
    
    	private static final long serialVersionUID = 1L;
    
    	public User3() {
    
    	}
    
    	private String username;
    	private transient String id;
    
    	public String getUsername() {
    		return username;
    	}
    
    	public void setUsername(String username) {
    		this.username = username;
    	}
    
    	public String getId() {
    		return id;
    	}
    
    	public void setId(String id) {
    		this.id = id;
    	}
    
    	@Override
    	public void writeExternal(ObjectOutput objectOutput) throws IOException {
    		objectOutput.writeObject(id);
    	}
    
    	@Override
    	public void readExternal(ObjectInput objectInput) throws IOException, ClassNotFoundException {
    		id = (String) objectInput.readObject();
    	}
    
    }
    

    输出结果:

    null
    javastack
    

    示例3的 id 被 transient 修改了,为什么还能序列化出来?那是因为 User3 实现了接口 Externalizable,而不是 Serializable。

    在 Java 中有两种实现序列化的方式,Serializable 和 Externalizable,可能大部分人只知道 Serializable 而不知道 Externalizable。

    这两种序列化方式的区别是:实现了 Serializable 接口是自动序列化的,实现 Externalizable 则需要手动序列化,通过 writeExternal 和 readExternal 方法手动进行,这也是为什么上面的 username 为 null 的原因了。

    transient 关键字总结

    1)transient修饰的变量不能被序列化;

    2)transient只作用于实现 Serializable 接口;

    3)transient只能用来修饰普通成员变量字段;

    4)不管有没有 transient 修饰,静态变量都不能被序列化;

    好了,栈长花了半天时间,终于整理完了。如果对你有帮助,那就转发分享一下吧!如果你也想加入我们的Java技术栈vip群和各位大牛一起讨论技术,那点击这个链接了解加入吧

    另外,栈长已经整理了大量 Java 系列核心技术知识点文章,关注Java技术栈微信公众号,在后台回复关键字:java,即可获取最新版。

    本文原创首发于微信公众号:Java技术栈(id:javastack),关注公众号在后台回复 “java” 可获取更多,转载请原样保留本信息。

    展开全文
  • 1)transient和volatile是java关键字吗?(瞬联)如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如:class T{ ...
        

    1transientvolatilejava关键字吗?(瞬联)

    如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如:

    class T

    {

    transient int a; //不需要维持

    int b; //需要维持

    }

    这里,如果T类的一个对象写入一个持久的存储区域,a的内容不被保存,但b的将被保存。

    volatile修饰符告诉编译器被volatile修饰的变量可以被程序的其他部分改变。在多线程程序中,有时两个或更多的线程共享一个相同的实例变量。考虑效率问题,每个线程可以自己保存该共享变量的私有拷贝。实际的变量副本在不同的时候更新,如当进入synchronized方法时。 strictfp修饰类或方法,可以确保浮点运算(以及所有切断)正如早期的Java版本那样准确。切断只影响某些操作的指数。当一个类被strictfp修饰,所有的方法自动被strictfp修饰。

    strictfp的意思是FP-strict,也就是说精确浮点的意思。在Java虚拟机进行浮点运算时,如果没有指定strictfp关键字时,Java的编译器以及运行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作,以致于得到的结果往往无法令你满意。而一旦使用了strictfp来声明一个类、接口或者方法时,那么所声明的范围内Java的编译器以及运行环境会完全依照浮点规范IEEE-754来执行。因此如果你想让你的浮点运算更加精确,而且不会因为不同的硬件平台所执行的结果不一致的话,那就请用关键字strictfp

    你可以将一个类、接口以及方法声明为strictfp,但是不允许对接口中的方法以及构造函数声明strictfp关键字,例如下面的代码:

    strictfp interface A {}

    public strictfp class FpDemo1 {

    strictfp void f() {}

    }

    2. 错误的使用方法

    interface A {

    strictfp void f();

    }

    public class FpDemo2 {

    strictfp FpDemo2() {}

    }

    一旦使用了关键字strictfp来声明某个类、接口或者方法时,那么在这个关键字所声明的范围内所有浮点运算都是精确的,符合IEEE-754规范

    的。例如一个类被声明为strictfp,那么该类中所有的方法都是strictfp的。

    2)抽象类和接口有什么区别?(瞬联)

    1.abstract class Java 语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface

    2.abstract class 中可以有自己的数据成员,也可以有非abstarct的成员方法,而在interface中,只能够有静态的不能被修改的数据成员(也就是必须是static final的,不过在 interface中一般不定义数据成员),所有的成员方法都是abstract的。

    3.abstract classinterface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系,interface表示的是"like-a"关系。

    4.实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。

    5.接口中定义的变量默认是public static final 型,且必须给其初值,所以实现类中不能重新定义,也不能改变其值。

    6.抽象类中的变量默认是 friendly 型,其值可以在子类中重新定义,也可以重新赋值。

    7.接口中的方法默认都是 public,abstract 类型的。

    3)能说一下java的反射(reflection)机制吗?(瞬联)

    开放性和原因连接(causally-connected)是反射系统的两大基本要素

    4)在java中怎样实现多线程?(瞬联)

    extends Thread

    implement Runnable

    方法一:继承 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 时间,无法执行。  四、线程的优先级  线程的优先级代表该线程的重要程度,当有多个线程同时处于可执行状态并等待获得 CPU 时间时,线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间,优先级高的线程有更大的机会获得 CPU 时间,优先级低的线程也不是没有机会,只是机会要小一些罢了。  你可以调用 Thread 类的方法 getPriority() setPriority()来存取线程的优先级,线程的优先级界于1(MIN_PRIORITY)10(MAX_PRIORITY)之间,缺省是5(NORM_PRIORITY)

    5)你用过哪种设计模式?(瞬联,IBMaspenTech

    设计:design

    模式:pattern

    框架:framework

    创建模式,结构模式和行为模式

    GoF设计模式

    A.创建模式

    设计模式之Factory(工厂模式)

    使用工厂模式就象使用new一样频繁.2002/10/9更新

    设计模式之Prototype(原型模式)

    用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。

    设计模式之Builder

    汽车由车轮 方向盘 发动机很多部件组成,同时,将这些部件组装成汽车也是一件复杂的工作,Builder模式就是将这两种情况分开进行。

    设计模式之Singleton(单态模式)

    保证一个类只有一个实例,并提供一个访问它的全局访问点 2002/10/9更新

    B.结构模式

    设计模式之Facade

    可扩展的使用JDBC针对不同的数据库编程,Facade提供了一种灵活的实现.

    设计模式之Proxy

    Jive为例,剖析代理模式在用户级别授权机制上的应用

    设计模式之Adapter

    使用类再生的两个方式:组合(new)和继承(extends),这个已经在"thinking in java"中提到过.

    设计模式之Composite

    就是将类用树形结构组合成一个单位.你向别人介绍你是某单位,你是单位中的一个元素,别人和你做买卖,相当于和单位做买卖。文章中还对Jive再进行了剖析。

    设计模式之Decorator

    Decorator是个油漆工,给你的东东的外表刷上美丽的颜色.

    设计模式之Bridge

    "牛郎织女"分开(本应在一起,分开他们,形成两个接口),在他们之间搭建一个桥(动态的结合)

    设计模式之Flyweight

    提供Java运行性能,降低小而大量重复的类的开销.

    C.行为模式

    设计模式之Template

    实际上向你介绍了为什么要使用Java 抽象类,该模式原理简单,使用很普遍.

    设计模式之Memento

    很简单一个模式,就是在内存中保留原来数据的拷贝.

    设计模式之Observer

    介绍如何使用Java API提供的现成Observer

    设计模式之Chain of Responsibility

    各司其职的类串成一串,好象击鼓传花,当然如果自己能完成,就不要推委给下一个.

    设计模式之Command

    什么是将行为封装,Command是最好的说明.

    设计模式之State

    状态是编程中经常碰到的实例,将状态对象化,设立状态变换器,便可在状态中轻松切换.

    设计模式之Strategy

    不同算法各自封装,用户端可随意挑选需要的算法.

    设计模式之Mediator

    Mediator很象十字路口的红绿灯,每个车辆只需和红绿灯交互就可以.

    设计模式之Interpreter

    主要用来对语言的分析,应用机会不多.

    设计模式之Visitor

    访问者在进行访问时,完成一系列实质性操作,而且还可以扩展.

    设计模式之Iterator

    这个模式已经被整合入JavaCollection.在大多数场合下无需自己制造一个Iterator,只要将对象装入Collection中,直接使用Iterator进行对象遍历。

    6)请说一下MVC架构(瞬联,IBMaspenTech

    Model:模型层

    View:视图层

    Controller:控制层

    MVC (Modal View Controler)本来是存在于Desktop程序中的,M是指数据模型,V是指用户界面,C则是控制器。使用MVC的目的是将MV的实现代码分离,从而使同一个程序可以使用不同的表现形式。比如一批统计数据你可以分别用柱状图、饼图来表示。C存在的目的则是确保MV的同步,一旦M改变,V应该同步更新。 模型-视图-控制器(MVC)是Xerox PARC在八十年代为编程语言Smalltalk80发明的一种软件设计模式,至今已被广泛使用。最近几年被推荐为Sun公司J2EE平台的设计模式,并且受到越来越多的使用ColdFusion PHP 的开发者的欢迎。模型-视图-控制器模式是一个有用的工具箱,它有很多好处,但也有一些缺点。 如何工作 是一个设计模式,它强制性的使应用程序的输入、处理和输出分开。使用MVC应用程序被分成三个核心部件:模型、视图、控制器。它们各自处理自己的任务。 视图 视图是用户看到并与之交互的界面。对老式的Web应用程序来说,视图就是由HTML元素组成的界面,在新式的Web应用程序中,HTML依旧在视图中扮演着重要的角色,但一些新的技术已层出不穷,它们包括Macromedia Flash和象XHTMLXML/XSLWML等一些标识语言和Web services. 如何处理应用程序的界面变得越来越有挑战性。MVC一个大的好处是它能为你的应用程序处理很多不同的视图。在视图中其实没有真正的处理发生,不管这些数据是联机存储的还是一个雇员列表,作为视图来讲,它只是作为一种输出数据并允许用户操纵的方式。 模型 模型表示企业数据和业务规则。在MVC的三个部件中,模型拥有最多的处理任务。例如它可能用象EJBsColdFusion Components这样的构件对象来处理数据库。被模型返回的数据是中立的,就是说模型与数据格式无关,这样一个模型能为多个视图提供数据。由于应用于模型的代码只需写一次就可以被多个视图重用,所以减少了代码的重复性。 控制器 控制器接受用户的输入并调用模型和视图去完成用户的需求。所以当单击Web页面中的超链接和发送HTML表单时,控制器本身不输出任何东西和做任何处理。它只是接收请求并决定调用哪个模型构件去处理请求,然后用确定用哪个视图来显示模型处理返回的数据。 现在我们总结MVC的处理过程,首先控制器接收用户的请求,并决定应该调用哪个模型来进行处理,然后模型用业务逻辑来处理用户的请求并返回数据,最后控制器用相应的视图格式化模型返回的数据,并通过表示层呈现给用户。 为什么要使用 MVC 大部分Web应用程序都是用像ASPPHP,或者CFML这样的过程化语言来创建的。它们将像数据库查询语句这样的数据层代码和像HTML这样的表示层代码混在一起。经验比较丰富的开发者会将数据从表示层分离开来,但这通常不是很容易做到的,它需要精心的计划和不断的尝试。MVC从根本上强制性的将它们分开。尽管构造MVC应用程序需要一些额外的工作,但是它给我们带来的好处是无庸质疑的。 首先,最重要的一点是多个视图能共享一个模型,正如我所提及的,现在需要用越来越多的方式来访问你的应用程序。对此,其中一个解决之道是使用MVC,无论你的用户想要Flash界面或是 WAP 界面;用一个模型就能处理它们。由于你已经将数据和业务规则从表示层分开,所以你可以最大化的重用你的代码了。 由于模型返回的数据没有进行格式化,所以同样的构件能被不同界面使用。例如,很多数据可能用HTML来表示,但是它们也有可能要用Macromedia FlashWAP来表示。模型也有状态管理和数据持久性处理的功能,例如,基于会话的购物车和电子商务过程也能被Flash网站或者无线联网的应用程序所重用。 因为模型是自包含的,并且与控制器和视图相分离,所以很容易改变你的应用程序的数据层和业务规则。如果你想把你的数据库从MySQL移植到Oracle,或者改变你的基于RDBMS数据源到LDAP,只需改变你的模型即可。一旦你正确的实现了模型,不管你的数据来自数据库或是LDAP服务器,视图将会正确的显示它们。由于运用MVC的应用程序的三个部件是相互对立,改变其中一个不会影响其它两个,所以依据这种设计思想你能构造良好的松偶合的构件。 对我来说,控制器的也提供了一个好处,就是可以使用控制器来联接不同的模型和视图去完成用户的需求,这样控制器可以为构造应用程序提供强有力的手段。给定一些可重用的模型和视图,控制器可以根据用户的需求选择模型进行处理,然后选择视图将处理结果显示给用户。 的缺点 的缺点是由于它没有明确的定义,所以完全理解MVC并不是很容易。使用MVC需要精心的计划,由于它的内部原理比较复杂,所以需要花费一些时间去思考。 你将不得不花费相当可观的时间去考虑如何将MVC运用到你的应用程序,同时由于模型和视图要严格的分离,这样也给调试应用程序到来了一定的困难。每个构件在使用之前都需要经过彻底的测试。一旦你的构件经过了测试,你就可以毫无顾忌的重用它们了。 根据我个人经验,由于我们将一个应用程序分成了三个部件,所以使用MVC同时也意味着你将要管理比以前更多的文件,这一点是显而易见的。这样好像我们的工作量增加了,但是请记住这比起它所能带给我们的好处是不值一提。 并不适合小型甚至中等规模的应用程序,花费大量时间将MVC应用到规模并不是很大的应用程序通常会得不偿失。 是一条创建软件的好途径 设计模式是一个很好创建软件的途径,它所提倡的一些原则,像内容和显示互相分离可能比较好理解。但是如果你要隔离模型、视图和控制器的构件,你可能需要重新思考你的应用程序,尤其是应用程序的构架方面。如果你肯接受MVC,并且有能力应付它所带来的额外的工作和复杂性,MVC将会使你的软件在健壮性,代码重用和结构方面上一个新的台阶。

    7)如果类a继承类b,实现接口c,而类b和接口c中定义了同名变量,请问会出现什么问题?(瞬联)

    {

    {

    {

    {

    下面的代码运行时会不会报错

    {

    {

    {

    {

    {

    {

    {

    8)请说一下java中为什么要引入内部类?还有匿名内部类?(瞬联,IBM

    9)请说一下finalfinallyfinalize的区别?(瞬联)

    final 用于声明属性,方法和类,分别表示属性不可变,方法不可覆盖,类不可继承。

    finally是异常处理语句结构的一部分,表示总是执行。

    finalizeObject类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,可以覆盖此方法提供垃圾收集时的其他资源回收,例如关闭文件等。

    10)请说一下HTTP请求的基本过程(IBM

    11java中存在内存泄漏问题吗?请举例说明?(IBM

    int i,i2; return (i-i2); //when i为足够大的正数,i2为足够大的负数。结果会造成溢位,导致错误。

    12)请说一下java中的内存回收机制所采用的算法(IBM,瞬联)

    虽然垃圾回收关心着大部分的问题,包括内存管理,使得程序员的任务显得更加轻松,但是程序员还是可能犯些错误导致内存泄漏问题。GC(垃圾回收)通过递归对所有从对象(堆栈中的对象,静态数据成员,JNI句柄等等)继承下来的引用进行工作,然后标记所有可以访问的活动着的对象。而这些对象变成了程序唯一能够操纵的对象,其他的对象都被释放了。因为GC使得程序不能够访问那些被释放的对象,所以这样做是安全的。

    13)请说一下System.gc()函数的作用。什么时候可以调用垃圾回收器?(瞬联)

    垃圾回收函数,手动调用的.

    当一个对象停止被活动声明所引用,它就变成了垃圾(garbage)可以被回收重新使用

    14)你做过的项目中采用了什么安全认证机制?(IBM

    15Math.round()什么作用?

    Math.Round(3.44, 1) = 3.4

    这种舍入方法叫做银行家舍入(Banker'sRound),这就是已经规定下来的标准、Round的标准、世界的标准。

    Round <> 四舍五入

    16、设计4个线程,其中两个线程每次对j增加1,另外两个线程对j每次减少1。写出程序。以下程序使用内部类实现线程,对j增减的时候没有考虑顺序问题。package java_example150;

    public class TestThread3{

    for(int i=0;i<2;i++){

    class Dec implements Runnable{

    17.CORBA是什么?用途是什么? 答:CORBA 标准是公共对象请求代理结构(Common Object Request Broker Architecture),由对象管理组织 (Object Management Group,缩写为 OMG)标准化。它的组成是接口定义语言(IDL), 语言绑定(binding:也译为联编)和允许应用程序间互操作的协议。 其目的为:1. 用不同的程序设计语言书写 2. 在不同的进程中运行 3. 为不同的操作系统开发

    18.JAVA代码查错

    1.

    abstract class Name

    {

    private String name;

    public abstract boolean isStupidName(String name) {}

    }

    答案: 错。abstract method必须以分号结尾,且不带花括号。

    2.

    public class Something

    {

    void doSomething ()

    {

    private String s = "";

    int l = s.length();

    }

    }

    答案: 错。局部变量前不能放置任何访问修饰符 (privatepublic,和protected)final可以用来修饰局部变量

    (final如同abstractstrictfp,都是非访问修饰符,strictfp只能修饰classmethod而非variable)

    3.

    abstract class Something

    {

    private abstract String doSomething ();

    }

    答案: 错。abstractmethods不能以private修饰。abstractmethods就是让子类implement(实现)具体细节的,怎么可以用privateabstractmethod封锁起来呢? (同理,abstract method前不能加final)

    4.

    public class Something

    {

    public int addOne(final int x)

    {

    return ++x;

    }

    }

    答案: 错。int x被修饰成final,意味着x不能在addOne method中被修改。

    5.

    public class Something

    {

    public static void main(String[] args)

    {

    Other o = new Other();

    new Something().addOne(o);

    }

    public void addOne(final Other o)

    {

    o.i++;

    }

    }

    class Other

    {

    public int i;

    }

    答案: 正确。在addOne method中,参数o被修饰成final。如果在addOne method里我们修改了oreference

    (比如: o = new Other();),那么如同上例这题也是错的。但这里修改的是omember vairable

    (成员变量),而oreference并没有改变。

    6.

    class Something

    {

    int i;

    public void doSomething()

    {

    System.out.println("i = " + i);

    }

    }

    答案: 正确。输出的是"i = 0"int i属於instant variable (实例变量,或叫成员变量)instant variabledefault valueintdefault value0

    7.

    class Something

    {

    final int i;

    public void doSomething()

    {

    System.out.println("i = " + i);

    }

    }

    答案: 错。final int i 是个finalinstant variable (实例变量,或叫成员变量)finalinstant variable没有default value,必须在constructor (构造器)结束之前被赋予一个明确的值。可以修改为"final int i = 0;"

    8.

    public class Something

    {

    public static void main(String[] args)

    {

    Something s = new Something();

    System.out.println("s.doSomething() returns " + doSomething());

    }

    public String doSomething()

    {

    return "Do something ...";

    }

    }

    答案: 错。看上去在maincall doSomething没有什么问题,毕竟两个methods都在同一个class里。但仔细看,mainstatic的。static method不能直接call non-static methods可改成"System.out.println("s.doSomething() returns " + s.doSomething());"。同理,static method不能访问non-static instant variable

    展开全文
  • java基础

    2015-09-29 20:29:47
    1)transient和volatile是java关键字吗? 如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如: class T {   transient int a; //不需要维持  int b; //需要维持 }...
  • java常见

    2015-03-20 09:30:54
    1)transient和volatile是java关键字吗?(瞬联) 如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如: class T {   transient int a; //不需要维持  int b; //需要...
  • java常见面试问题

    2015-03-04 17:18:00
    转自:... 1)transient和volatile是java关键字吗?(瞬联) 如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如: class T { transient int a;...
  • 为了实现属性不被序列化,只需要在属性前加上transient关键字就能达到目的。 但是,使用transient的属性就一定不会被序列化吗?带着这个疑问,我们开始进行一下测试,看看真相到底什么样的。 被序列化的类首先...
  • 一些经常被忽略的Java知识

    千次阅读 2011-09-28 17:18:01
    1)transient和volatile是java关键字吗transient:  java有个特点就是序列化,简单地来说就是可以将这个类存储在物理空间(当然还是以文件的形式存在),那么当你从本地还原这个文件时,你可以将它转换为它本身...
  • java面试总结

    2016-03-02 22:28:47
    1)transient和volatile是java关键字吗?(瞬联) 如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如: class T { transient int a; //不需要维持 int b; //需要维持 } 这里,如果T...
  • JAVA常见面试题及解答

    2019-06-12 09:50:54
    1)transient和volatile是java关键字吗?(瞬联) 如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如: class T { transient int a;//不需要维持 int b;//需要维持 } 这里,如果T类的...
  • JAVA面试宝典2

    2016-08-23 19:48:32
    1)transient和volatile是java关键字吗?(瞬联) 如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如: class T {   transient int a; //不需要维持  int b; //需要维持 }  ...
  • 1)transient和volatile是java关键字吗?(瞬联) 如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如: class T { transient int a;//不需要维持 int b;//需要维持 } 这里,如....
  • java 精华(一)

    2014-04-16 10:15:35
    1)transient和volatile是java关键字吗?(瞬联) 如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如: class T {  transient int a; //不需要维持  int b; //...
  • java编程2

    2014-08-13 11:32:33
    1)transient和volatile是java关键字吗?(瞬联) 如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如: class T {   transient int a; //不需要维持  int b; //需要维持 ...
  • JAVA面试题

    2015-09-22 11:26:55
    1)transient和volatile是java关键字吗?(瞬联) 如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如: class T {   transient int a; //不需要维持  int b; //需要维持 }  ...
  • Java常见面试题

    2015-09-23 11:06:11
    1)transient和volatile是java关键字吗?(瞬联) 如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如: class T {   transient int a; //不需要维持  int b; //需要维持 }...
  • java面试题

    2012-01-10 04:47:51
    1)transient和volatile是java关键字吗?(瞬联) 2)抽象类和接口有什么区别?(瞬联) 3)能说一下java的反射机制吗?(瞬联) 4)在java中怎样实现多线程?(瞬联) 5)你用过哪种设计模式?(瞬联,ibm,aspentech) 6)请说一下...
  • Java基础面试题

    千次阅读 2008-04-24 13:21:00
    今天整理了一些Java基础面试题,答案是我自己从网上找到的,不一定正确.1)transient和volatile是java关键字吗?(瞬联)如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如: class T { ...
  • 1)transient和volatile是java关键字吗?(瞬联 ) 如果用transient声明一个实例变量,当对象存储 时,它的值不需要维持。例如: class T {  transient int a; //不需要维持  int b; //需要维持 ...
  • 1)transient和volatile是java关键字吗?(瞬联) 若是用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如: class T {  设计模式之Interpreter  int b; //需要维持 }  5. ...
  • 精华java面试题(转)

    2013-03-07 22:59:43
    1)transient和volatile是java关键字吗?(瞬联)   如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如: class T {   transient int a; //不需要维持  int b; //需要维持 }  ...
  • java的经典实例【2】

    2008-04-24 16:54:00
    1)transient和volatile是java关键字吗?(瞬联)如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。例如: class T { transient int a; //不需要维持 int b; //需要维持} 这里,如果T类的一个...
  • java8集合源码-Java:Java

    2021-06-04 17:34:35
    Java中的transient和volatile变量有什么区别? 提及同步块的用途 基于散列的集合中加载因子的默认大小多少? 编写代码使集合只读? 区分谓词和函数? Java8中的Nashorn什么? JVM 分配了多少种内存区域? 定义为...
  • 本文主要了解Java的对象序列化的使用,序列化与反序列化源码追踪,Serializable接口、Externalizable接口、transient关键字、ObjectOutputStream、ObjectInputStream的运用,简单扩展该知识点在 Hessian、webservice...
  • Java 基础面试题

    2018-10-04 20:09:04
    25. transient 这个关键字是干啥的 26. 什么一致性hash算法 27. 构造方法链 28. 谈谈你对线程调度的理解 29. JDK动态代理和CGLIB动态代理 30. 反射机制以及反射的方式 31. 类加载有几种方式 32. Class.for...
  • 面试题

    2013-02-21 18:26:34
    1、java  因为我投的职位主要是java相关的,所以这方面积累的经验比较多一下。这部分考查的 ...1)transient和volatile是java关键字吗?(瞬联) 2)抽象类和接口有什么区别?(瞬联) 3)能说一下ja

空空如也

空空如也

1 2
收藏数 39
精华内容 15
关键字:

transient是java关键字吗

java 订阅