精华内容
下载资源
问答
  • 创建对象的三种方式

    2021-04-23 18:17:47
    创建对象的三种方式 // 创建对象的三种方式 //1.利用字面量创建对象{} /* 2.使用对象: 调用对象的属性 (1)对象名.属性名 console.log(obj.name); (2)对象名['属性名'] console.log(obj['name']); */ //3....

    创建对象的三种方式

     // 创建对象的三种方式
    
            //1.利用字面量创建对象{}
           /* 2.使用对象:
            调用对象的属性 (1)对象名.属性名 console.log(obj.name);
                          (2)对象名['属性名'] console.log(obj['name']); */
             //3.调用对象的方法 对象名.方法名 obj.sayHi();
            var obj={
                name:'仙女',
                age:21,
                sex:'女',
                sayHi:function(){
                    console.log('hi');
                }
    
            }
            var dog={
                name:'可可',
                type:'阿拉斯加犬',
                age:5,
                color:'pink',
                skill:function(){
                    console.log('唱歌'+'跳舞');
                   
                }
               
    
    
            }
            console.log(dog.name);
            console.log(dog.type);
            console.log(dog.age);
            console.log(dog.color);
            dog.skill(); 
    
            //2.利用new Object创建对象
            var obj=new Object();
            obj.name='仙女';
            obj.age=3;
            obj.sex='女';
            obj.skill=function(){
                console.log('吃喝玩乐');
            }
            console.log(obj.name);
            obj.skill();
    
            var obj=new Object();
            obj.name='鸣人';
            obj.sex='男';
            obj.age=19;
            obj.skill=function(){
                console.log('影分身术');
            }
            console.log(obj.name);
            console.log(obj.sex);
            console.log(obj.age);
            obj.skill();
            //3.利用构造函数创建对象 可以创建多个对象 里面封装的是对象
           /*  构造函数的语法格式
            function 构造函数名(){
                this.属性=值;
                this.方法=function(){}
            }
            new 构造函数名(); */
    
    
            //构造函数名字首字母要大写 构造函数不需要return 就可以返回结果
            function Person(name,age,sex){
                this.name=name;
                this.age=age;
                this.sex=sex;
                this.skill=function(skilling){
                    console.log(skilling);
                }
                
            }
            //调用构造函数 必须使用new 调用函数就创建一个对象xn
            var xn=new Person('仙女儿',3,'女');
            console.log(xn.name);
            xn.skill('吃喝玩乐');
            
            var mql=new Person('庆林儿',2,'男');
            console.log(mql.name);
            mql.skill('打游戏');
    
    
    
    
    
    
     //Math数学对象 不是一个构造函数 不需要new来调用,直接使用里面的属性和方法
            //Math.max() 函数返回一组数中的最大值 Math.max(value1[,value2, ...]) value1, value2, ... 一组数值 返回给定的一组数字中的最大值
           // Math.max([]) 带[]时 里面的值可以不用写
            console.log(Math.PI);
            console.log(Math.max(1,6,8,99));
            console.log(Math.max(1,66,'庆林儿'));//输出NaN;
            console.log(Math.max());//里面没有value时,输出-Infinity
    
    展开全文
  • 5.2 创建对象的三种方式 利用字面量创建对象 使用对象字面量创建对象: 就是花括号 { } 里面包含了表达这个具体事物(对象)的属性和方法;{ } 里面采取键值对的形式表示 键:相当于属性名 值:相当于属性...

    5.2 创建对象的三种方式

    • 利用字面量创建对象

      使用对象字面量创建对象
        就是花括号 { } 里面包含了表达这个具体事物(对象)的属性和方法;{ } 里面采取键值对的形式表示 
      
      • 键:相当于属性名

      • 值:相当于属性值,可以是任意类型的值(数字类型、字符串类型、布尔类型,函数类型等)

        代码如下:

        var star = {
            name : 'pink',
            age : 18,
            sex : '男',
            sayHi : function(){
                alert('大家好啊~');
            }
        };
        

        上述代码中 star即是创建的对象。

    • 对象的使用

      • 对象的属性

        • 对象中存储具体数据的 "键值对"中的 "键"称为对象的属性,即对象中存储具体数据的项
      • 对象的方法

        • 对象中存储函数的 "键值对"中的 "键"称为对象的方法,即对象中存储函数的项
      • 访问对象的属性

        • 对象里面的属性调用 : 对象.属性名 ,这个小点 . 就理解为“ 的 ”

        • 对象里面属性的另一种调用方式 : 对象[‘属性名’],注意方括号里面的属性必须加引号

          示例代码如下:

          console.log(star.name)     // 调用名字属性
          console.log(star['name'])  // 调用名字属性
          
      • 调用对象的方法

        • 对象里面的方法调用:对象.方法名() ,注意这个方法名字后面一定加括号

          示例代码如下:

          star.sayHi();              // 调用 sayHi 方法,注意,一定不要忘记带后面的括号
          
      • 变量、属性、函数、方法总结

        属性是对象的一部分,而变量不是对象的一部分,变量是单独存储数据的容器

        • 变量:单独声明赋值,单独存在

        • 属性:对象里面的变量称为属性,不需要声明,用来描述该对象的特征

          方法是对象的一部分,函数不是对象的一部分,函数是单独封装操作的容器

        • 函数:单独存在的,通过“函数名()”的方式就可以调用

        • 方法:对象里面的函数称为方法,方法不需要声明,使用“对象.方法名()”的方式就可以调用,方法用来描述该对象的行为和功能。

    • 利用 new Object 创建对象

      • 创建空对象

        var andy = new Obect();
        

        通过内置构造函数Object创建对象,此时andy变量已经保存了创建出来的空对象

      • 给空对象添加属性和方法

        • 通过对象操作属性和方法的方式,来为对象增加属性和方法

          示例代码如下:

        andy.name = 'pink';
        andy.age = 18;
        andy.sex = '男';
        andy.sayHi = function(){
            alert('大家好啊~');
        }
        

        注意:

        • Object() :第一个字母大写
        • new Object() :需要 new 关键字
        • 使用的格式:对象.属性 = 值;
    • 利用构造函数创建对象

      • 构造函数

        • 构造函数:是一种特殊的函数,主要用来初始化对象,即为对象成员变量赋初始值,它总与 new 运算符一起使用。我们可以把对象中一些公共的属性和方法抽取出来,然后封装到这个函数里面。

        • 构造函数的封装格式:

          function 构造函数名(形参1,形参2,形参3) {
               this.属性名1 = 参数1;
               this.属性名2 = 参数2;
               this.属性名3 = 参数3;
               this.方法名 = 函数体;
          }
          
        • 构造函数的调用格式

          var obj = new 构造函数名(实参1,实参2,实参3)
          

          以上代码中,obj即接收到构造函数创建出来的对象。

        • 注意事项

          1. 构造函数约定首字母大写
          2. 函数内的属性和方法前面需要添加 this ,表示当前对象的属性和方法。
          3. 构造函数中不需要 return 返回结果
          4. 当我们创建对象的时候,必须用 new 来调用构造函数
        • 其他

          构造函数,如 Stars(),抽象了对象的公共部分,封装到了函数里面,它泛指某一大类(class)
          创建对象,如 new Stars(),特指某一个,通过 new 关键字创建对象的过程我们也称为对象实例化

    • new关键字的作用

      1. 在构造函数代码开始执行之前,创建一个空对象;
      2. 修改this的指向,把this指向创建出来的空对象;
      3. 执行函数的代码
      4. 在函数完成之后,返回this—即创建出来的对象
    展开全文
  • spring创建对象的三种方式详解

    万次阅读 2018-01-18 17:29:37
    本文主要讲解IOC容器创建对象的三种方式创建对象的三种方式1) 调用无参数构造器 2) 带参数构造器 3) 工厂创建对象 包括:3.1 工厂类,静态方法创建对象 3.2 工厂类,非静态方法创建对象1.调用无参数的...

    前言

    我们知道spring框架的核心就是IOC容器了,那么IOC容器主要的作用就是创建对象和处理对象之间的依赖关系。本文主要讲解IOC容器创建对象的三种方式。

    创建对象的三种方式

    1) 调用无参数构造器
    2) 带参数构造器
    3) 工厂创建对象
    包括:3.1 工厂类,静态方法创建对象
    3.2 工厂类,非静态方法创建对象

    1.调用无参数的构造器

    具体如下:
    User.java

    public class User {
    
        private int id;
        private String name;
    
    
    
        public User() {
            super();
            System.out.println("------User对象创建【无参数构造器】------");
        }
    
    
        public User(int id, String name) {
            System.out.println("-----User对象创建【带参数构造器】--------");
            this.id = id;
            this.name = name;
        }
    
    
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    
    
        @Override
        public String toString() {
            return "User [id=" + id + ", name=" + name + "]";
        }
    }

    Bean.xml配置如下:

    <!-- 1. 默认无参数构造器 -->
        <bean id="user1" class="com.nwpu.geeker.User"></bean>

    测试:

    // 测试:对象创建
        @Test
        public void testIOC() throws Exception {
            // 创建IOC容器对象
            ApplicationContext ac = new ClassPathXmlApplicationContext("com/nwpu/geeker/bean.xml");
            // 获取容器中的对象
            User user = (User) ac.getBean("user");
    
            System.out.println(user);
        }

    2.带参数构造器创建对象

    例如:上面的user.java 有带参的构造器,参数列表为(int,string).一般依赖注入对象的时候用的比较多。
    配置如下:

    <!-- 2. 带参数构造器 -->
        <bean id="user2" class="com.nwpu.geeker..User">
            <constructor-arg index="0" type="int" value="100"></constructor-arg>
            <constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>
        </bean>

    其中index属性表示参数的位置。Type表示类型,value表示赋值,还有一个ref属性下面将会介绍,表示可以引用IOC容器创建好的(已存在的)对象。
    配置如下:

    <!-- 定义一个字符串,值是"Jack" ;  String s = new String("jack")-->
        <bean id="str" class="java.lang.String">
            <constructor-arg value="Jacks"></constructor-arg>
        </bean>
        <bean id="user3" class="com.nwpu.geeker.User">
            <constructor-arg index="0" type="int" value="100"></constructor-arg>
            <constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg>
        </bean>

    ref属性引用的就是IOC容器创建对象的id属性值。

    3.通过工厂类创建对象

    3.1 通过实例化工厂,非静态方法创建对象
    先创建工厂javaBean

    // 工厂,创建对象
    public class ObjectFactory {
    
        // 实例方法创建对象
        public User getInstance() {
            return new User(100,"工厂:调用实例方法");
        }
    
        // 静态方法创建对象
        public static User getStaticInstance() {
            return new User(101,"工厂:调用静态方法");
        }
    }

    配置文件:

    <!-- # 3.1 工厂类,实例方法 -->
        <!-- 先创建工厂 -->
        <bean id="factory" class="com.nwpu.geeker.ObjectFactory"></bean>
        <!-- 在创建user对象,用factory方的实例方法 -->
        <bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>

    其中: factory-bean=”factory”指定工厂。factory-method=”getInstance”指定工厂的哪个方法。

    3.2 工厂类: 静态方法创建对象

    <bean id="user" class="com.nwpu.geeker.ObjectFactory" factory-method="getStaticInstance"></bean>

    class 指定的就是工厂类型,这里是和上面配置不同的地方。
    factory-method 一定是工厂里面的“静态方法”

    创建对象的细节问题

    1) 对象创建: 单例/多例
    在bean.xml配置文件中,配置scope=”singleton”,为单例创建对象,如果不配置,默认也是单例方式。主要应用于service/dao层还有一些utils工具类等只需要在服务器启动时初始化一次即可。
    scope=”prototype”,表示多例方式创建对象,也就是当用户需要使用这个对象时即创建对象,在ssh项目整合中主要应用于Action对象。这种方式一般在服务器启动时不会创建对象,在每次使用才创建。

    2) 什么时候创建?上面其实已经说了
    scope=”prototype” 在用到对象的时候,才创建对象。(在ioc容器初始化之后)
    scope=”singleton” 在服务器启动时候(容器初始化之前), 就已经创建了bean,且整个应用只有一个。

    3)是否延迟创建
    lazy-init=”false” 默认为false, 不延迟创建,即在启动时候就创建对象
    lazy-init=”true” 延迟初始化, 在用到对象的时候才创建对象
    (只对单例有效)因为多例本来就是访问对象时才创建。

    4) 创建对象之后,初始化/销毁
    init-method=”init_user” 【对应对象的init_user方法,在对象创建好之后执行 】
    destroy-method=”destroy_user” 【在调用容器对象的destroy方法时候执行,(容器用实现类)】

    public class User {
    
        private int id;
        private String name;
    
    
    
        public User() {
            super();
            System.out.println("------User对象创建------");
        }
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    
        public void init_user() {
            System.out.println("创建对象之后,初始化");
        }
        public void destroy_user() {
            System.out.println("IOC容器销毁,user对象回收!");
        }
    
    }

    测试:

    @Test
        public void testIOC() throws Exception {
            // 得到IOC容器对象  【用实现类,因为要调用销毁的方法】
            ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("com/nwpu/geeker/applicationContext.xml");
            System.out.println("-----容器创建-----");
    
            // 从容器中获取bean
            User user1 = (User) ac.getBean("user");
            User user2 = (User) ac.getBean("user");
    
            System.out.println(user1);
            System.out.println(user2);
    
            // 销毁容器对象 
            ac.destroy();
        }
    
        @Test
        public void test() throws Exception {
            // 容器对象
            ApplicationContext ac = new ClassPathXmlApplicationContext("com/nwpu/geeker/applicationContext.xml");
            System.out.println("-----容器创建完成-----");
            User user1 = (User) ac.getBean("user1");
        }
    展开全文
  • 创建对象的三种方式: 1. 使用构造函数创建对象 var obj =new Object(); obj.name='小明'; obj.eat=function(){ console.log('吃饭'); } 1.2 通过工厂函数批量创建对象 function createObjs(name){ var obj=...

    创建对象的三种方式:
    1. 使用构造函数创建对象

       var obj =new Object();
       obj.name='小明';
       obj.eat=function(){
              console.log('吃饭');
       }
    

    1.2 通过工厂函数批量创建对象

     function createObjs(name){
            var obj=new Object();
            obj.name=name;
            obj.eat=function(){
                   console.log('吃饭');
             }
            return obj;
      }
      var obj=createObjs('小明');
    
    1. 使用自定义构造函数创建对象
    //1. 创建自定义构造函数
     function Person(name){
    	this.name=name;
    	this.eat=function(){
    		console.log('吃饭');
    	}
     }
     //2. 实例化对象 -----new
    var  obj =new Person('小明');
    
     // 自定义构造函数创建对象时做了4件事:
    		    1. 在内存中申请一片空间,用于存储对象
    		    2. 将this指向当前对象
    		     3. 设置当前对象的属性和方法
    		     4. 将this对象返回
    
    1. 使用字面量方式创建对象
      ------通过字面量方式创建对象的缺陷: 一次性对象,如果需要创建多个对象,还要重新创建
         //键值对的方式
         var obj={
             name:'小白',
              age:12,
              eat:function(){
               console.log('吃饭');
            }
        };
    
    展开全文
  • 二、创建对象的三种方式 1.使用字面量创建对象 即{ } <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>创建对象</title> <script> // 创建一个狗...
  • 创建对象的三种方式 1.调用系统的构造函数创建对象 2.自定义构造函数创建对象(结合第一种和需求通过工厂模式创建对象) 3.字面量的方式创建对象 第一种方式: 实例化对象 var obj=new Object(); 对象有特征——属性...
  • spring创建对象的三种方式 1,通过构造方法创建(有参构造创建:需要明确配置,无参构造创建:默认情况) 有参构造的情况下,需要在类中提供有参构造方法,然后在applicationContext.xml中设置调用哪个构造方法创建...
  • 创建对象的三种方式 构造函数 ,是一种特殊的方法。主要用来在创建对象时初始化对象 1. 调用系统的构造函数创建对象(又称为实例化一个对象)  var obj = new Object(); // 添加属性,方法 obj.name =...
  • 【JavaScript】创建对象的三种方式

    热门讨论 2019-01-19 11:45:35
    JavaScript创建对象的三种方式 1、调用系统的构造函数创建对象 2、自定义构造函数创建对象(结合第一种和需求铜鼓工厂模式创建对象) 3、字面量的方式创建对象 一、调用系统的构造函数创建对象 举个...
  • 1.创建对象的三种方式和bean的生命周期的验证: Animal接口代码: package cn.pb.dao; /** * 动物接口 */ public interface Animal { //吃饭 String eat(); //睡觉 void sleep(); }   Animal接口的实现...
  • c++创建对象的三种方式如下: A a(1); //栈中分配 A b = A(1); //栈中分配 A* c = new A(1); //堆中分配 第一种和第二种没什么区别,一个隐式调用,一个显式调用,两者都是在进程虚拟地址空间中的栈中分配内存...
  • spring容器创建对象的三种方式 1. 通过构造器的方式【无参构造器、有参构造器】,需要掌握 2.通过静态工厂:指的是通过类的静态方法得到的对象!【了解】 3.通过实例工厂:指的是通过类对象的普通方法得到的对象!【了解...
  • SpringIOC创建对象的三种方式 第一种: 无参构造方法:参考上一篇文章 第二种 有参构造方法 1>.根据参数下标去创建 User.java public class User { private String name; private String age; public ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,450
精华内容 3,380
关键字:

创建对象的三种方式