精华内容
下载资源
问答
  • java对象创建实例化和初始化的区别 实例化:在堆中申请内存空间,属性都是默认值 初始化:给对象的属性进行赋值操作或者初始化方法的调用

    java对象创建实例化和初始化的区别

    实例化:在堆中申请内存空间,属性都是默认值
    初始化:给对象的属性进行赋值操作或者初始化方法的调用

    展开全文
  • Spring中四种实例化bean的方式本文主要介绍四种实例化bean的方式(注入方式) 或者叫依赖对象实例化的四种方式。上面的程序,创建bean 对象,用的是什么方法 ,用的是构造函数的方式 (Spring 可以在构造函数私有化的情况...

    Spring中四种实例化bean的方式

    本文主要介绍四种实例化bean的方式(注入方式) 或者叫依赖对象实例化的四种方式。上面的程序,创建bean 对象,用的是什么方法 ,用的是构造函数的方式 (Spring 可以在构造函数私有化的情况下把类对象创建出来)

    常用的创建方式有以下四种:

    1) setter 方法

    2) 构造函数

    3) 静态工厂

    4) 实例工厂

    一、用 setter 方式

    复制代码
    public interface IUserDao {
                    void addUser();
                    void delUser();
                    void updateUser();
                }
                
                public class UserDaoImpl implements IUserDao {
                    public void addUser() {
                        System.out.println("addUser方法被调用了");
                    }        
                    public void delUser() {
                        System.out.println("delUser方法被调用了");
                    }        
                    public void updateUser() {
                        System.out.println("updateUser方法被调用了");
                    }
                }
                
                public class UserAction {
                        private IUserDao dao; //dao是一个依赖对象,要由springg进行管理,要生成 get set 方法
                                public void execute(){
                                dao.addUser();
                                dao.updateUser();
                                dao.delUser();
                        }
                    }
    复制代码
    //配置文件
    <bean name="userAction_name" class="cat.action.UserAction" >
    <property name="dao" ref="userDao_name" />  //引用的是下面的名称
    </bean>    
    <bean name="userDao_name" class="cat.dao.UserDaoImpl" />
     //测试
    ClassPathXmlApplicationContext ctx=new ClassPathXmlApplicationContext("beans.xml");
    UserAction action=(UserAction)ctx.getBean("userAction_name");
    action.execute(); 

    二、构造函数

    复制代码
    public class UserAction {
           //public UserAction(){} 可以保保留一个无参的构造函数
                    
           //这是几个依赖对象,不用生成get set方法了
           private UserInfo user;
           private String school;
           private IUserDao dao;     
                
           //希望Spring 由构造函数注入依赖对象
           public UserAction(IUserDao dao,UserInfo user,String school){
                  this.dao=dao;
                  this.school=school;
                  this.user=user;
                  }
                    
                
           public void execute(){
                  dao.addUser();
                  dao.updateUser();
                  dao.delUser();
                        
                  System.out.println(user);
                  System.out.println(school);
    }
    复制代码
    复制代码
    //配置文件
    <bean name="userInfo_name" class="cat.beans.UserInfo" >
          <property name="id" value="1" />
          <property name="userName" value="周周" />
          <property name="password" value="123" />
          <property name="note" value="这是备注" />
    </bean>
                        
    <bean name="userAction_name" class="cat.action.UserAction" >
          <constructor-arg ref="userDao_name" />
          <constructor-arg ref="userInfo_name" />
          <constructor-arg value="哈尔滨师范大学" />
    </bean>
                
    /*
    也可以指定 索引和 type 属性 , 索引和type 都可以不指定
    <bean name="userAction_name" class="cat.action.UserAction" >
    <constructor-arg index="0" ref="userDao_name" type="cat.dao.IUserDao" />  如果是接口,就不能指定是实现类的类型
    <constructor-arg index="1" ref="userInfo_name" type="cat.beans.UserInfo" />
    <constructor-arg index="2" value="哈尔滨师范大学"  />
    </bean>
    */
                    
    <bean name="userDao_name" class="cat.dao.UserDaoImpl" />
    复制代码
    //测试
    ClassPathXmlApplicationContext ctx=new ClassPathXmlApplicationContext("beans.xml");
    UserAction action=(UserAction)ctx.getBean("userAction_name");
    action.execute(); 

    三、静态工厂方式

    复制代码
    //工厂,用来生成dao的实现类
    public class UserDaoFactory {
    public static IUserDao createUserDaoInstance(){
           return new UserDaoOracleImpl();
           }
    }
    
               
    public class UserAction {
           private IUserDao dao;//使用工厂方式注值,也要生成set方法
           public void execute(){
                  dao.addUser();
                  dao.updateUser();
                  dao.delUser();
    }
                    
    
    public void setDao(IUserDao dao) {
                  this.dao = dao;
                  }    
    }
    复制代码
    复制代码
    //配置文件 
    <bean name="userAction_name" class="cat.action.UserAction" >
    <property name="dao"  ref="userDao_name" />
    </bean>
                  
    <bean name="userDao_name" class="cat.dao.UserDaoFactory" factory-method="createUserDaoInstance" />
    复制代码
    //测试
    ClassPathXmlApplicationContext ctx=new ClassPathXmlApplicationContext("beans.xml");
    UserAction action=(UserAction)ctx.getBean("userAction_name");
    action.execute(); 

    四、实例工厂

    复制代码
    //工厂 =>
    public class UserDaoFactory {
    //这个方法不是静态的
    public  IUserDao createUserDaoInstance(){
            return new UserDaoOracleImpl();
            }
    }
    复制代码
    复制代码
    //配置文件 
    <bean name="userAction_name" class="cat.action.UserAction" >
    <property name="dao"  ref="userDao_name" />
    </bean>
                  
    <bean  name="userDaoFactory_name" class="cat.dao.UserDaoFactory" />
    <bean name="userDao_name" factory-bean="userDaoFactory_name" factory-method="createUserDaoInstance" />

    1. spring容器创建对象的3种方式(bean的实例化)  
    2.   
    3.     1,调用默认的构造函数(默认)  
    4.         1)指定bean的class属性  
    5.         2)class需要一个默认的空构造器  
    6.           
    7.         <bean id="helloWorld" class="com.jxn.HelloWorld" />  
    8.           
    9.         得到实例对象:HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");  
    10.           
    11.     2,使用静态工厂方法  
    12.         1)指定class属性外  
    13.         2)通过factory-method属性来指定创建bean实例的静态工厂方法  
    14.           
    15.         <bean id="helloWorld" class="com.jxn.HelloWorldFactory" factory-method="createInstance"></bean>  
    16.         注:相当于调用了 HelloWorldFactory.createInstance();  
    17.           
    18.         public class HelloWorldFactory {  
    19.             public static HelloWorld createInstance(){  
    20.                 return new HelloWorld();  
    21.             }  
    22.         }  
    23.           
    24.         得到实例对象:HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");  
    25.   
    26.     3,使用实例工厂方法  
    27.         1)定义一个工厂类  
    28.         2)通过factory-bean属性指定工厂类,通过factory-method属性指定该工厂类的非静态工厂方法  
    29.   
    30.         <bean id="helloWorldFactory" class="com.jxn.HelloWorldFactory" />  
    31.         <bean id="HelloWorld" factory-bean="helloWorldFactory" factory-method="createInstance" />  
    32.         注:相当于调用了 new HelloWorldFactory.createInstance();  
    33.           
    34.         public class HelloWorldFactory {  
    35.             public HelloWorld createInstance(){  
    36.                 return new HelloWorld();  
    37.             }  
    38.         }  
    39.           
    40.         得到实例对象:HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");  
    41.   
    42.     注:spring调用工厂方法,在该工厂方法中,由程序员来创建对象。 
    展开全文
  • /**  * 利用反射机制创建实例化对象 实现不同类的实例化创建  * 该工厂类根据不同的类路径创建生产不同类的... * 根据完整的类路径名称创建该类的实例化对象  * @param className 完整的类路径及名称  * @re
    /**
     * 利用反射机制创建实例化对象 实现不同类的实例化创建
     * 该工厂类根据不同的类路径创建生产不同类的实例化对象
     * @author erik
     *
     */
    public class Factory {
        /**
         * 根据完整的类路径和名称创建该类的实例化对象
         * @param className  完整的类路径及名称
         * @return T  
         * @throws Exception
         */
       public static <T> T getInstance(String className) throws Exception {
           @SuppressWarnings("unchecked")
        T t = (T) Class.forName(className).newInstance();
           return t;
       }
       /**
        * 根据不同的类文件创建该类的示例化对象
        * @param class  
        * @return  T
        * @throws Exception
        */
     
    public static <T> T getInstance(Class<?> cls) throws Exception {
           T t = (T) cls.newInstance();
           return t;
       }
       private Factory () {}

    }


    public class TestDemo {
        public static void main(String[] args) {
            try {
                //根据完整类路径创建实例化对象
                ICar car = Factory.getInstance("com.product.car.Benci");
                car.driveCae();
                
                IFruit iFruit = Factory.getInstance("com.product.fruit.Apple");
                iFruit.ect();
                
                
                
                //根据类文件创建实例化对象
                Bmw bmw = Factory.getInstance(Bmw.class);
                bmw.driveCae();
                
                Orange orange = Factory.getInstance(Orange.class);
                orange.ect();


            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }


    }

    展开全文
  • 1. 声明对象 对象的声明基本类型的数据声明在形式上是一样的: 类名 对象名; 对象名也是用户标识符,基本类型的变量遵循同样的命名规则...2. 实例化对象 用new关键字创建一个新对象,即进行实例化。格式如下:

    1. 声明对象
    对象的声明和基本类型的数据声明在形式上是一样的:
    类名 对象名;
    对象名也是用户标识符,和基本类型的变量遵循同样的命名规则和使用规则。
    声明一个变量,并不会分配一个完整的对象所需要的内存空间,只是将对象名所代表的变量看成是一个引用变量,并为它分配所需内存空间,它所占用的空间远远小于一个类的对象所需要的空间。
    如此处理,使得Java中声明一个对象的消耗很小,但也有一个副作用,就是对象不能马上使用,还需要对它进行实例化。

    2. 实例化对象
    用new关键字创建一个新对象,即进行实例化。格式如下:
    new 构造方法([参数列表])
    实例化的过程就是为对象分配内存空间的过程,此时,对象才成为类的实例。new所执行的具体操作是调用相应类中的构造方法(包括祖先类的构造方法),来完成内存分配以及变量的初始化工作,然后将分配的内存地址返回给所定义的变量。

    实质:实例化了就有自己内存空间。而没有实例化就和引用的对象内存空间地址相同,指向同一个空间。
    声明对象只是单纯的说明有这个对象,但他还没真正实例化-内存分配空间

    希望能够帮助到你们。

    展开全文
  • 创建子类对象,将包含一个父类子对象,即父类创建对象; 实例化子对象,父类对象也会实例化(但不会实例出对象),即自动调用父类的无参构造方法,有参构造方法只能依赖于super关键字的显式调用。 super关键字:在...
  • 深入理解Java对象创建过程:类的初始化与实例化

    万次阅读 多人点赞 2017-05-18 14:17:45
    在Java中,一个对象在可以被使用之前必须要被正确地初始化,这一点是Java规范规定的。...本文试图对JVM执行类初始化和实例化的过程做一个详细深入地介绍,以便从Java虚拟机的角度清晰解剖一个Java对象创建过程。
  • Object实例化、访问对象属性使用对象字面量表示法,JavaScript定义类的五种方式
  • 类的实例化 #建立一个Python类 class Python : # 下面定义了2个类变量 name = "安阳师范学院" add = "http://www.aynu.edu.cn/" # 定义一个类方法 该方法为类的构造方法 def __init__(self,name = "安阳师范...
  • 类实例及成员引用 当我们创建完一个类,如果要使用这个类,必须在程序里创建类的实例对象,通过这个实例来引用类中所定义的方法成员,完成所需的工作。...实例化对象的基本语法为: ClassNam...
  • public void leaveTheBuilding(){...} } 第4条 通过私有构造器强化不可实例化的能力 其实就像一些工具类,我们不想让其他用户创建该类对象,也不想被其他类继承,我们只要把这个类的构造器私有化,他就不能被实例化...
  • JAVA创建子类对象不会实例化父类对象 学习java之初大家难免会遇到很多抽象的理论,在此分享下自己的微薄浅见,希望能给予读者略有帮助. 我们都知道,在java中子类会继承父类的一切属性(成员变量)方法(构造方法除外)....
  • 有三个与此主题相关的术语:声明,初始化和实例化.从后到前工作.实例化这是为对象分配内存的时候.这就是新关键字正在做的事情.从new关键字返回对创建对象的引用.初始化这是将值放入已分配的内存中的时间.这是使用...
  • 在学习Java反射的过程中,遇到了一点疑惑的地方 //1.获取Class对象 Class clazz = Class.forName("...); //2. 利用Class对象的newInstance方法创建一个类的...平常理解的对象和实例都是一个东西,将一个对象实...
  • 摘要: 在Java中,一个对象在可以被使用之前必须要被正确地初始化,这一点是Java规范规定的。...本文试图对JVM执行类初始化和实例化的过程做一个详细深入地介绍,以便从Java虚拟机的角度清晰解剖一个Java对
  • 面向对象的语言有一个标志,那就是类的概念,而通过类可以创建任意多个具有相同属性方法的对象。但是,ECMAScript 没有类的概念,因此它的对象也与基于类的语言中的对象有所不同。 js本身是没有class类型的,但是...
  • 抽象类可以被new实例化,直接创建抽象类对象吗? 抽象类可以拥有构造方法,那么它可以被实例化吗?为什么在代码中可以直接用“new”一个抽象类? 首先我的结论是:抽象不能实例化。通常用“new + 抽象类型”的形式...
  • 比如我们常见的声明数组就是标准的构造函数:var array =...实例化对象就是创建对象的过程 举例: function Person(){} //Person构造函数 var p=new Person(); //Person构造函数创建对象,也可叫做实例化 ...
  • 和对象 实例化

    2019-10-27 21:43:52
    通过一个类创建一个对象,这个过程叫做实例化 实例化是通过调用构造方法(又叫做构造器)实现的 /** * 方法名类名一样(包括大小写)没有返回类型 * 实例化一个对象的时候,必然调用构造方法 */ public class ...
  • 创建对象需要以下三步:声明:声明一个对象,包括对象名称对象类型。实例化:使用关键字new来创建一个对象。始化:使用new创建对象时,会调用构造方法初始化对象创建对象的例子1:public classPuppy{publicPuppy...
  • 对象的声明与实例化过程类名 对象名 = new 类名() ;Person p ; // 先声明一个 Person 类的对象 p p = new Person() ; // 用 new 关键字实例化 Person 的对象 p** 这里分别做了两件事: 1、 声明指向”由类所创建的...
  • PHP除了简单的为了实现特定功能外,也可以实现面向对象的编程方式,而且也可以很优雅! 下面利用具体的代码实例,讲述类的创建和对象实例化。“`
  • 用spring管理和实例化对象的四种方式 方式一:无参构造函数(最常用) 对象是spring创建,创建的对象还要交给spring容器管理 bean:豆子 id:在spring容器中Hello对象的名,在容器中id的值必须唯一 class:要对哪个类实例化...
  • 在PHP中实现类对象 1.创建类 语法: class 类名{ //属性 //方法 //常量 } 类是由属性、方法、常量组成的,也可以说 类成员有:属性、方法、...通过new关键字来实例化对象 <?php /** * Created by PhpStorm.
  • 封装过程中的疑难杂症(三,实例化对象和方法重载) 一,实例化对象 1,实例化对象其实就是创建对象过程; Student st1 = new Student(); 2,为什么要实例化对象? 因为只有实例化之后,才能将这个对象放到内存中,然后才能...
  • 书中说对象和类的实例的含义相同。 那么怎么完成实例化呢。我们创建一个对象需要对它初始化数据。能够有这一作用的是什么呢?——构造函数。所以就有了 Car mycar= new Car(); 当我们自己定义了与类同名的有参构造...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,719
精华内容 7,487
关键字:

实例化对象和创建对象