精华内容
下载资源
问答
  • 静态(工具类a定义一个静态的工具类a的实例b,因为实例b是静态的是每个工具类a的公共部分,所以使用工具类a时让使用者转去使用实例b) 不能随意去实例化–>私有构造方法(构造方法私有化后,使用者就无法new...

    工具类是需要被反复使用的,而工具类的内容又是相同的,如果每个调用者都实例化工具类就会在内存中存储大量重复数据。

    工具类成为共有部分–>静态(在工具类a里定义一个静态的工具类a的实例b,因为实例b是静态的是每个工具类a的公共部分,所以使用工具类a时让使用者转去使用实例b)
    不能随意去实例化–>私有构造方法(构造方法私有化后,使用者就无法new出对象,使用工具类a的实际是给实例b进行初始化,在通过实例b调用方法)

    这样一来使用者使用的其实是一个静态的实例b,存储于方法区的静态区间里。

    单线程时

    public class MyUtil {
    
        private static MyUtil myutil;
        private String str;
        
        private  MyUtil(){
            
        }
        
        public static MyUtil setUtil(){
            if(myutil==null){
                myutil = new MyUtil();
            }
            return myutil;
        }
    }
    

    多线程时

    public class MyUtil {
    
        private static MyUtil myutil;
        private String str;
    
        private  MyUtil(){
    
        }
        //a
        public MyUtil setUtil(){
            if(myutil==null){
            //b
                synchronized (MyUtil.class){
                    if(myutil==null){
                        myutil = new MyUtil();
                    }
                }
            }
            return myutil;
        }
    }
    

    多个线程时如果线程1执行的比较深执行到了b,但还未初始化mytil时,线程2也执行到了b,此时线程1和2都有权去执行mytil的初始化,myutil初始化两次后状态就被覆盖了,所以者一段带码要加锁。

    展开全文
  • 本篇将简单探讨一下,JVM是如何一步一步创建一个对象的。 1. Class Loading 一个特定的类能被实例化之前,JVM要做的第一步是需要将描述这个类的文件也就是.class文件给加载到内存。 一般的做法是根据指定的...

    本篇将简单探讨一下,JVM是如何一步一步创建一个对象的。

    1. Class Loading

    在一个特定的类能被实例化之前,JVM要做的第一步是需要将描述这个类的文件也就是.class文件给加载到内存里。
    一般的做法是根据指定的classpath在文件系统里搜索.class文件。这个处理过程被称为class loading。
    熟知的朋友们知道这里还有别的class loading方法,比如通过URL走网络加载。这里不细谈。总之第一步就是需要将对于特定类的class byte code给加载到内存。通过class loading这一过程,JVM会为这个类创建java.lang.Class实例,并进行静态初始化

    2. 创建类实例

    JVM创建一个类的实例的第二步,是为这个类的实例分配内存。

    JVM所占用的系统内存,简单划分成了两块。

    1. 堆内存(Heap Memory):用于JVM虚拟机分配内存给类实例。
    2. 栈内存(Stack Memory):通常用于保存线程执行栈(thread stacks)信息和Java methods等。比较典型的例子是当我们递归调用一个方法过多层,就会导致java.lang.StackOverflowError了,每一次方法的调用(进入)都会占用一点堆内存,如果方法不退出堆内存讲得不到释放就会StackOverflow。

    这下我们知道了大致的JVM的内存构成(堆内存还会继续分,详情见 Understanding Memory Management)。
    也知道了类实例是分配在堆内存上。接下来我们来详细看一下JVM如何实例化一个对象的。也就是当我们写下 new myClass()的时候,究竟发生了什么?

    根据JVM Specification Java SE8的例子

    Creating a new class instance is a multistep process. The statement:

    new myClass(i, j, k);

    can be implemented by the following:

    new #1 // Allocate uninitialized space for myClass
    dup // Duplicate object on the operand stack
    iload_1 // Push i
    iload_2 // Push j
    iload_3 // Push k
    invokespecial #5 // Invoke myClass.

    简单理解的话,是实例化一个对象需要经过几个步骤。大致区分的化分别是内存分配初始化

    • 对于初始化,java类的每一个Constructor都是一个特殊方法,需要被invokespecial命令所调用。所以理解起来呢和调用普通的方法一样即可。也一样可以抛出异常。

    At the level of the Java Virtual Machine, every constructor written in the Java
    programming language (JLS §8.8) appears as an instance initialization method
    that has the special name <init>.

    Instance initialization methods may
    be invoked only within the Java Virtual Machine by the invokespecial instruction
    (§invokespecial), and they may be invoked only on uninitialized class instances

    • 对于内存分配,则是会在堆内存上分配类实例所有变量加起来大小的内存。其中类实例变量(instance variables)可以是原生类型(Primitive Types)也可以是引用类型(Reference Types)

    Memory for a new instance of that class is allocated from the
    garbage-collected heap, and the instance variables of the new
    object are initialized to their default initial values (§2.3, §2.4)

    3. Java中各个类型所占内存的大小

    老生常谈的问题,各个类型需要占多大的内存大小。这里笔者列举一下。

    Data Type Size 备注
    byte 8-bit
    short 16-bit
    int 32-bit
    long 64-bit
    char 16-bit
    float 32-bit
    double 64-bit
    boolean ≤8-bit In Oracle’s Java Virtual Machine implementation, boolean arrays in the Java programming language are encoded as Java Virtual Machine byte arrays, using 8 bits per boolean element.
    reference 32/64 bit 和c系语言的指针一样,根据JVM架构来定,如果JVM是32位的那么reference占用32bit大小,如果JVM是64位的那么占用64位大小。
    java.lang.Object 8/16 byte 作为java的基底类,每一个实例都32位下占用8byte,64位下占用16byte大小。
    • 在JVM Specification里,除了boolean的定义比较暧昧,没看到特定大小除了指明Oracle JVM 实现的时候呢,boolean数组使用byte数组来表现的之外其他类型大小都是能知道的。计算一个类实例大小的时候可以认为boolean占用8-bit内存。
    • 当大量创建Java对象的时候,一定记得计算Object的大小,32位系统下1MB内存只够创建125万个Object实例。

    结语

    在高级语言里,内存管理被隐藏起来,但了解这些基本知识,正确认识内存是如何运作的是写出可靠程序的基础。
    也愿各位不会在以后的项目里看到从数据库Select 1000万条数据,用数组来处理的代码。

    参考文献
    1. Understanding Memory Management
    2. The Java® Virtual Machine Specification Java SE 8 Edition

    展开全文
  • java007如何java创建一个

    万次阅读 2019-04-16 20:22:37
    一,编程的一般思路 1,ooa:面向对象分析 ...定义属性,方法,以及实例化一个对象并调用类里面的内容? 方法:1:无进无出:没有返回值,没有参数传 2:无进有出:没有返回值,有参数 3:有进无出:有返...

    一,编程的一般思路
    1,ooa:面向对象分析
    2,ood:面向对象设计
    3,oop:面向对象编程
    4,测试
    5,项目交接,给客户演示,演示完了项目就上线运行,运行期间有bug就项目升级(后期维护)----是收钱的哦
    二,如何在java中创建一个类?定义属性,方法,以及实例化一个对象并调用类里面的内容?
    方法:1:无进无出:没有返回值,没有参数传
    2:无进有出:没有返回值,有参数
    3:有进无出:有返回值,没有参数
    4:有进有出 :有返回值,有参数

    在这里插入图片描述

    三,方法重载:就是方法名相同,方法参数的个数和类型不同,通过个数和类型的不同来区分不同的函数。Java的重载是发生在本类中的,重载的条件实在本类中有多个方法名相同,但参数列表不同
    ###同一个类中,方法名相同,参数列表不同(1:参数个数不同2:参数类型不同3:参数顺序不同),切记:跟返回值类型无关,跟修饰符无关(public就是一个修饰符)
    他们两个就构成了方法重载::::
    在这里插入图片描述
    思考:一个类中为什么要定义那么多的同名方法呢(方法重载)?
    原因是每个方法的具体实现有差异,我们不能以偏概全
    四,全局变量和局部变量
    全局变量都是有默认值,而且在类的任何地方都可以使用,说白了就是定义在方法之外的变量
    ###8种基本数据类型的默认值
    在这里插入图片描述
    局部变量:定义在方法中,形参上,或者是一个块中,局部变量的作用域是从它的括号({})开始到结束.
    ###形参: 在方法被调用时用于接受外界输入的数据;(方法中的参数)
    ###实参:   调用方法时外界传给方法的数据;

    注意:局部变量是没有默认值的,在你使用之前必须给它赋值

    五,this关键字

    在这里插入图片描述

    在这里插入图片描述
    1:代表当前类对象
    2:区分同名属性和局部变量
    ####当全局变量和局部变量重名时,在方法中使用this时,表示的是该方法所在类中的全局变量
    在这里插入图片描述
    3:调用本类中重载的构造器,谁调用它,它就是谁这个this必须写在构造器的第一句

    在这里插入图片描述
    六,构造器:构造方法,构造函数.
    类在构建对象的时候系统会默认的去那个构造器,如果类中你自己没有定义构造器,系统会自动帮你生成一个无参构造器 。
    构造器的作用是:1,初始化对象(给属性赋值)构造器也能重载
    2.构造代码块,代码块 { }
    构造代码块是在实例化对象的时候优先于构造器先执行的
    构造代码块的作用:是给对象的共性赋值,比如张三爱吃米饭,李四爱吃米饭,王五也爱吃,所有人都爱吃米饭,所以用构造代码块给共性赋值
    ###我在百度上搜了一点:
    在这里插入图片描述
    七,引起类的加载方式
    注意:实例变量(普通属性)隶属于构造代码块—就是谁在前面谁先执行
    ###实例变量(全局变量):独立于方法之外的变量,不过没有 static 修饰。

    String str="hello world"; // 实例变量
    

    1:实例化对象,new的时候

    int s=new ...
    

    2:调用类里面的静态属性或静态方法
    3:Class.forName(); 加载驱动(反射机制)
    八,Static关键字
    1:修饰属性
    属性就是静态属性(类属性,类属性就是该属性是属于类的,不属于对象的),可以直接通过类名访问,所以实际共享该类属性

    2:修饰方法
    该方法可以直接被类名调用注意:静态方法中不能使用非静态属性静态方法中不能使用this和 super关键字
    在这里插入图片描述
    3:修饰代码块
    {}静态代码块是最先执行的,在整个程序运行期间只执行一次,用于数据库连接

    static{} 
    

    4:静态导入

     import static java.lang.System.out;
    

    就是输出时不再输System.;直接out.println();
    九,8种基本数据类型对应的封装类

    在这里插入图片描述
    学习这8个封装类主要学习它里面的api
    8种基本数据类型和8种对应的封装类可以自动转换,这8种封装类里面用的最多的一个api就是将字符串转成数字
    注意:char不能进行字符串转数字
    boolean只有字符串是ture的时候才转ture,其他都是false
    在这里插入图片描述
    十,内存分配
    Java中内存分为5个
    1:栈:存放基本类型的变量数据和对象的引用,但对象本身不存放在栈中,而是存放在堆(new 出来的对象)或者常量池中(字符串常量对象存放在常量池中)
    2:堆:存放所有new出来的对象。
    3:常量存储区:存放常量
    4:静态存储区:存放静态成员(static定义的)
    5:方法区
    ==是用来判断地址
    栈和堆的区别:栈中的数据大小和生命周期是可以确定的,当没有引用指向数据时,这个数据就会消失。堆中的对象的由垃圾回收器负责回收
    栈的优势是,存取速度比堆要快

    展开全文
  • java源码包---java 源码 大量 实例

    千次下载 热门讨论 2013-04-18 23:15:26
    ejbCreate函数用于初始化一个EJB实例 5个目标文件,演示Address EJB的实现,创建一个EJB测试客户端,得到名字上下文,查询jndi名,通过强制转型得到Home接口,getInitialContext()函数返回一个经过初始化的上下文,...
  • 例如:下面类初始是需要查询数据库,并对查到的数据做大量的计算,所以次构造的时候,花了很多时间来初始个对象; 但是假设我们数据库的数据是不变的,并且把这个对象保存了内存中,那么以...

    单例模式定义:

    一个类只有一个实例,提供全局的唯一入口。比如分身术,但是每一个分身都对应同一个真身。

    单例模式优点:

    • 写法简单
    • 线程安全
    • 防止破坏单例

    为什么需要单例模式

    • 理由一:节省内存、节省计算
      • 例如:下面类初始化是需要查询数据库,并对查到的数据做大量的计算,所以在第一次构造的时候,花了很多时间来初始化这个对象;
        但是假设我们数据库里的数据是不变的,并且把这个对象保存在了内存中,那么以后就可以用同一个实例了。
        如果每次都重新生成新的实例,实在是没有必要。
      public class ExpensiveResource {
          public ExpensiveResource(){
              field1 = // 查询数据库
              field2 = // 然后对查询的数据库做大量计算
              field3 = // 加密、压缩等耗时操作
          }
      }
      
    • 理由二:保证结果的正确
      • 例如:一个全局计数器,用来统计人数,那么有多个实例的话反而会造成混乱。
    • 理由三:方便管理
      • 例如:很多工具类,我们只需要一个实例,那么我们通过一个统一的入口,比如通过getInstance 方法,获取到单例,很方便。

    单例模式适用场景

    • 无状态工具类
      • 日志工具类
        只是用于记录日志信息,不需要在操作类实例对象上存储任何状态
      • 字符串工具
    • 全局信息类
      • 全局计数
      • 环境变量

    单例模式写法

    • 饿汉式
    public class Singleton {
        private static Singleton singleton = new Singleton();
        
        private Singleton(){}
        
        public static Singleton getInstance(){
            return singleton;
        }
    }
    
    类装载的时候就完成了实例化,避免了线程同步的问题;==缺点在于类装载的时候就完成了实例化,没有达到懒加载的效果==;如果一直未使用该实例,就造成了内存浪费。
    
    静态代码块式写法:
    
    public class Singleton {
        private static Singleton singleton;
        
        static {
            singleton = new Singleton();
        }
        
        private Singleton(){}
        
        public static Singleton getInstance(){
            return singleton;
        }
    }
    
    • 懒汉式
    线程不安全式写法:
    
    public class Singleton {
        private static Singleton singleton;
        
        private Singleton(){}
        
        public static Singleton getInstance(){
            if(singleton == null){  //多线程进入会产生多实例
                singleton = new Singleton();
            }
            return singleton;
        }
    }
    
    public class Singleton {
        private static Singleton singleton;
        
        private Singleton(){}
        
        public static  Singleton getInstance(){
            if(singleton == null){  //多线程进入会产生多实例
                synchronized (Singleton.class){
                    singleton = new Singleton();
                }
            }
            return singleton;
        }
    }
    
    调用时进行实例化,起到懒加载效果,只能在单线程下使用,避免多线程环境下使用该写法 
    
    线程安全式写法:
    
    public class Singleton {
        private static Singleton singleton;
        
        private Singleton(){}
        
        public static synchronized Singleton getInstance(){
            if(singleton == null){
                singleton = new Singleton();
            }
            return singleton;
        }
    }
    
    效率太低
    
    • 双重检查式
    public class Singleton {
        private static volatile Singleton singleton;
        
        private Singleton(){}
        
        public static  Singleton getInstance(){
            if(singleton == null){
                synchronized (Singleton.class){
                    if(singleton == null){  //多线程进入会产生多实例
                        singleton = new Singleton();
                    }
                }
            }
            return singleton;
        }
    }
    
    两个if判断,第二次if判断会跳过if代码块,直接return 实例化对象;优点不仅线程安全,而且延迟加载,效率更高。缺点不能防止被反序列化,生成多个实例。
    
    扩展思考1:为什么要double-check? 去掉第二次的check行不行呢?
    
    思考:两个线程同时调用getInstance方法,并且由于singleton是空的,所以两个线程都可以通过第一重的if判断,然后由于锁机制的存在,会有一个线程先进入同步语句,并进入第二重的if判断,而另一个线程就会在外面等待,不过当第一个线程执行完 new Singleton() 语句后,就会退出 synchronized 保护的区域,如果没有第二重singleton == null的话,那么第二个线程也会创建一个实例,这就破坏了单例;如果第一check去掉,那么所有线程都会串行执行,效率低下,所以两个check都需要保留的。
    
    扩展思考2:为什么要加volatile关键字?
    
    思考:主要在于singleton = new Singleton() 不是原子操作。防止了JVM中重排序的发生,避免了1->3->2顺序执行过程中拿到未完成初始化的对象。
    
    在JVM中代码执行步骤:
    1)给singleton分配初始空间;
    2)调用Singleton的构造函数等来初始化singleton;
    3)将singleton对象指向分配的内存空间(执行完这步singleton就不是 null 了)。
    
    由于JVM中存在==重排序现象==,执行熟悉存在 1->3->2 或者 1->2->3
    
    • 静态内部类式
    public class Singleton {
        
        private Singleton(){}
        
        private static class SingletonInstance{
            private static final Singleton singleton = new Singleton();
        }
        
        public static  Singleton getInstance(){
            return SingletonInstance.singleton;
        }
    }
    
    饿汉式机制类似,采用类装载机制,来保证我们初始化实例时只有一个线程,所以JVM保证了线程的安全性;
    不会在类装载时实例化,而是在需要调用时实例化。优点不仅线程安全,而且延迟加载,效率更高。
    缺点不能防止被反序列化,生成多个实例。
    
    • 枚举式(最佳方式)
    public class EnumSingleton {
        
        INSTANCE;
        
        public EnumSingleton getInstance(){
           return INSTANCE;  
        }
    }
    
    1.写法简单,代码短小精悍,代码更简洁更优雅;
    2.线程安全有保证,枚举中的各个枚举项都是通过static代码来定义和初始化的,他们会在类被加载时完成初始化,而Java类的加载由JVM保证线程安全,所以创建一个Enum 类型的枚举是线程安全的。
    3.防止单例破坏,java专门对枚举序列化做了规定,在序列化是仅仅是将枚举对象的name属性输出到结果中,在反序列化时,就是通过java.lang.Enum的valueOf来根据名字查找对象,而不是新建一个新的对象,所以防止了反序列化。
    

    如何选择:

    Joshua Bloch 在《Effective Java》书中明确表达过一个观点:使用枚举实现单例的方法,虽然还没有被广泛采用,但是单元素的枚举类型已经成为了实现 Singleton 的最佳方法。

    Ref:卫星君

    展开全文
  • 我的教程少一个工具类的方法: ... //传入一个对象,方法名,形参 通过反射为对象属性赋值 } 我写的时候发现无法实例化Object就无法为属性赋值。 请帮助我完成此方法或提供功能相同的工具类,Thanks♪(・ω・)ノ
  • 通常,我们在java中通过实例化一个类来调用该类的方法,但是,如果有多个类都要调用这个类地方法,是不是要在每个主调类里面都创建一个被调用类的对象呢? 如果这样做,会不会因为多次实例化而影响程序的执行效果呢...
  • 例如:有一个对象叫user,里面有name,age,两个属性,想在实例化对象,new user("a","1"); 我想用一个方法,只要传入参数的名字,就能修改参数的值,例如:传入age和"1岁",把原来的对象修改为user("a","1岁"); ...
  • 保证一个类只有一个实例,且类里面提供一个全局可以访问的入口。如图 Singleton 类,提供了一个 getInstance() 入口获取这个实例。 为什么需要单例? 节省内存 节省计算 保证结果的正确(需要一个全局的计数器)...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
    ejbCreate函数用于初始化一个EJB实例 5个目标文件,演示Address EJB的实现,创建一个EJB测试客户端,得到名字上下文,查询jndi名,通过强制转型得到Home接口,getInitialContext()函数返回一个经过初始化的上下文,...
  • EJB对象是用完毕,从内存中清除,从账户中取出amt,如果amt>账户余额抛出异常,一个实体Bean可以表示不同的数据实例,我们应该通过主键来判断删除哪个数据实例…… ejbCreate函数用于初始化一个EJB实例 5个目标文件...
  • 导包 首先,想要使用这类里面的方法就要先对该类导包。...实例化该类之后,才可以对类中的方法进行访问 //数据类型 变量名=new 数据类型(参数列表) Scanner scanner=new Scanner(System.in); 调
  • Java语言的每个语法都提供了一个或多个例程讲解 大量使用流程图表示程序的执行过程,使用结构图表示程序的内部状态 每章最后都给出了典型的练习题,让读者及时练习,巩固提高,并提供了参考答案 目录 第1篇 ...
  • 一个对象被创建后,包含三个方面的特性:对象句柄,属性,方法,句柄用于区分不同的对象,对象的属性和方法与类中的成员变量和成员函数对应。 类里面的属性和方法叫做成员变量和成员函数,在实例化后,调用这些...
  • JAVA对象的this引用

    2017-08-04 16:01:59
    Java提供了一个this关键字,this关键字总是指向调用该方法的对象。根据this出现的位置不同,this作为对象的默认引用有两种情形。 构造器中引用该构造器正在初始对象方法中引用调用该方法的对象。 this...
  • GiantDragon 提供了一个public static的getInstance方法,外部调用者通过该方法获取12行定义的对象,而且每一次都是获取同一个对象。 从而达到单例的目的。 这种单例模式又叫做饿汉式单例模式,无论如何都会创建一个...
  • Java语言的每个语法都提供了一个或多个例程讲解 大量使用流程图表示程序的执行过程,使用结构图表示程序的内部状态 每章最后都给出了典型的练习题,让读者及时练习,巩固提高,并提供了参考答案 目录 第1篇 ...
  • Java语言的每个语法都提供了一个或多个例程讲解 大量使用流程图表示程序的执行过程,使用结构图表示程序的内部状态 每章最后都给出了典型的练习题,让读者及时练习,巩固提高,并提供了参考答案 目录 第1篇 ...
  • 面向对象 概念:面向对象它区别于面向过程,强调的是通过调用对象的行为来实现功能,而不是自己一步步的去操作实现。 特点:面向对象思想是一种更...优点:比面向对象性能高,因为它省去了对象实例化一个过程,有些
  • 如何实现 java 接口中的部分方法

    千次阅读 2016-07-29 14:09:42
    接口和抽象类的区别?为什么需要接口?...相同点:接口和抽象类都不能实例化一个对象,如果一个类要继承一个抽象类或者实现一个接口,则必须实现抽象类(否则必须声明为一个抽象类)或者接口里面的所有方法
  • [java] 关键字new是如何实现的

    万次阅读 多人点赞 2018-07-24 23:53:37
    4.new一个对象时的内存空间担保? 5. 关于局部变量 6. 静态变量是在何时初始化的?与对象实例化有什么关系? 7.使用Class类提供的newInstance和使用关键字new有哪些不同? 概述 在java里面创建一...
  • javacv-ffmpeg播放视频的音频

    千次阅读 2017-10-29 19:18:44
    在javacv封装的ffmpeg包中,可以通过...(1) 首先实例化一个FFMpegFrameGrabber对象,然后调用grabSamples对象就可以得到一个包含音频数据的帧对象Frame,其Buffer[] samples域就是存放的就是解码后...
  • EJB对象是用完毕,从内存中清除,从账户中取出amt,如果amt>账户余额抛出异常,一个实体Bean可以表示不同的数据实例,我们应该通过主键来判断删除哪个数据实例…… ejbCreate函数用于初始化一个EJB实例 5个目标文件...
  • EJB对象是用完毕,从内存中清除,从账户中取出amt,如果amt>账户余额抛出异常,一个实体Bean可以表示不同的数据实例,我们应该通过主键来判断删除哪个数据实例…… ejbCreate函数用于初始化一个EJB实例 5个目标文件...
  • 用法1:实例化对象通过对象直接使用里面的方法即可 public static void main(String[] args) { try { long begin = System.currentTimeMillis(); Class forName = Class.forName
  • java源码包2

    千次下载 热门讨论 2013-04-20 11:28:17
    ejbCreate函数用于初始化一个EJB实例 5个目标文件,演示Address EJB的实现,创建一个EJB测试客户端,得到名字上下文,查询jndi名,通过强制转型得到Home接口,getInitialContext()函数返回一个经过初始化的上下文,...
  • 开始正文之前,请你先思考几问题: 你项目中有使用哪些 GOF 设计模式 说说 GOF 23 种设计模式的设计理念 说说 Spring 框架中如何实现设计模式 假设我是面试官问起了你这些面试题,你该如何回答呢,请...
  • java源码包3

    千次下载 热门讨论 2013-04-20 11:30:13
    ejbCreate函数用于初始化一个EJB实例 5个目标文件,演示Address EJB的实现,创建一个EJB测试客户端,得到名字上下文,查询jndi名,通过强制转型得到Home接口,getInitialContext()函数返回一个经过初始化的上下文,...
  • java源码包4

    千次下载 热门讨论 2013-04-20 11:31:44
    ejbCreate函数用于初始化一个EJB实例 5个目标文件,演示Address EJB的实现,创建一个EJB测试客户端,得到名字上下文,查询jndi名,通过强制转型得到Home接口,getInitialContext()函数返回一个经过初始化的上下文,...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 223
精华内容 89
关键字:

如何在java里实例化一个对象

java 订阅