精华内容
下载资源
问答
  • 2017-02-01 21:44:30

    1.action的创建交给Spring

    Action中的userService已经在applicationContext.xml配置,只需要把这个Action在applicationContext.xml中重新配置下

    <bean id="userAction" class="com.domain.UserAction>

    <property name="userService" ref="userService"/>

    </bean>

    在struts配置Action时,class属性不是原来Action类的位置(不然无法获取userService),  因此class应该写bean中的别名。 

    若是使用别名,则默认从spring容器中获得内容,getBean("userAction");

    默认是获得单例,若是没有获得内容,将自己创建。

    Spring中scope默认为singleton,  就是每次共用一个Action,但Action不是线程安全的,故applicationContext.xml中配置Action 有一属性scope 设其值为prototype,要求每一个线程创建一个独立的Action。

    2.action的创建交给Struts

    实际上只要保持Action中属性的属性名与applicationContext.xml中的bean名字相同,便会自动注入。不需要配置applicationContext.xml

    比如说:直接在struts.xml中配置  <action name="userAction" class="com.domain.UserAction">....</action>

    然后这个Action类中Field有一属性UserService userService, 恰好有一bean name="userService"在applicationContext.xml中配置,则只需要给userService加上set方法,便可实现自动注入。


    更多相关内容
  • Action类的三种创建方式

    千次阅读 2017-04-12 22:04:13
    1、创建一个pojo类 这个可以参考第一篇博客,创建的简单登录校验 pojo其实就是一个简单的java类 它没有实现任何接口,也没有继承任何类。 优点:无耦合 适用于逻辑相对简单的action 2、实现Action接口 ...

    1、创建一个pojo类

    这个可以参考第一篇博客,创建的简单登录校验

    pojo其实就是一个简单的java类

    它没有实现任何接口,也没有继承任何类。

    优点:无耦合

    适用于逻辑相对简单的action


    2、实现Action接口

    com.opensymphony.xwork2.Action

    这个接口里有五个常量属性和一个方法



    属性:

    success:成功视图

    none:代表返回null,不做任何操作(跳转操作也不会做)

    error:错误视图

    input:这是struts2框架中interceptor中发现问题后会访问的一个视图

    login:一个登录视图,可用于权限操作


    方法:

    execute:将要执行的方法,需要重写此方法,


    3、继承ActionSupport类

    com.opensymphony.xwork2.ActionSupport


    此类也实现了Action接口

    因为它具有丰富的功能,如表单校验 错误信息 设置国际化等,所以常在开发中使用,但也同样有高耦合的问题


    请多多关照:qq183428067


    展开全文
  • 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");
        }
    展开全文
  • java中创建线程的4种方式

    千次阅读 2019-04-25 16:00:23
    java线程创建方式有几?这种问题在面试中经常被问到,你可能心里马上反映出两种方式(实现Runnable、继承Thread),当你把这两叙述给面试官听后,面试官会觉得你该掌握的知识已经有了,但是仅仅而已。如果你还说...

    写在前面的话

    java线程创建方式有几种?这种问题在面试中经常被问到,你可能心里马上反映出两种方式(实现Runnable、继承Thread),当你把这两种叙述给面试官听后,面试官会觉得你该掌握的知识已经有了,但是仅仅而已。如果你还说了callable与future、线程池,那么面试官就会认为你 知识覆盖面广,对你好感加一!下面首先叙述为什么会出现线程,以及线程在实际生活中的例子,紧接着给出四种创建线程的方式,加以代码进行演示。喜欢博主文章的你,动动你们的小爪子,点赞收藏呗(#^.^#)

    1、线程的知识

    1.1、什么是多线程

    百度百科这样说:多线程(英语:multithreading),是指从软件或者硬件上实现多个线程并发执行的技术。好像和没说一样,概念还是不怎么理解。那就举个例子:早上小明起床后,需要完成刷牙、洗脸、烧水、听广播,为了节约时间、提高效率,小明边烧水、边听广播、边刷牙洗脸,这三个任务并行进行,就类似于三个线程。多线程就是同时多个线程同时工作,并发执行任务。

    1.2、为什么会有多线程

    这个问题可以转换为:多线程带来了什么好处与优势。结合《JAVA并发编程实践》总结如下:

    1、发挥多处理器的强大能力

    现在的处理器在频率上的提升空间越来越小,为了增加设备整体的性能,出现了多核多处理器设备。由于线程是cpu调度的基本单位, 当一个程序中只有一个线程时,最多只能在一个CPU上进行运行,其他CPU将处于空闲状态,严重影响多核CPU的性能。因此,如果涉及合理正确的多线程程序,将会充分利用多核CPU性能优势,提高整体设备性能。

    2、建模的简单性

    通过使用线程,可以将复杂并且异步的工作流进一步分解为一组简单并且同步的工作流,每个工作流在一个单独的线程中运行,并在特定的同步位置进行交互。我们可以通过一些现有框架来实现上述目标,例如Servlet和RMI,框架负责解决一些细节问题,例如请求管理、线程创建、负载平衡,并在正确的时候将请求分发给正确的应用程序组件。编写Servlet的开发人员不需要了解多少请求在同一时刻要被处理,也不需要了解套接字的输入流或输出流是否被阻塞,当调用Servlet的service方法来响应Web请求时,可以以同步的方式来处理这个请求,就好像它是一个单线程程序。

    3、异步事件的简化处理

    服务器应用程序在接受多个来自远程客户端的套接字连接请求时,如果为每个连接都分配其各自的线程并且使用同步I/O,那么就会降低这类程序的开发难度。如果某个应用程序对套接字执行读操作而此时还没有数据到来,那么这个读操作将一直阻塞,直到有数据到达。在单线程应用程序中,这不仅意味着在处理请求的过程中将停顿,而且还意味着在这个线程被阻塞期间,对所有请求的处理都将停顿。为了避免这个问题,单线程服务器应用程序必须使用非阻塞I/O,但是这种I/O的复杂性要远远高于同步I/O,并且很容易出错。然而,如果每个请求都拥有自己的处理线程,那么在处理某个请求时发生的阻塞将不会影响其他请求的处理。

    4、响应更灵敏的用户界面

    GUI界面采用多线程,可以同时响应多个按钮,比如在IDEA中,在程序运行时,还可以继续进行程序编写。

    1.3、线程与进程的区别

    进程是操作系统进行资源分配的单元,线程是CPU调度运行的单位;一个进程中可以包含很多线程,线程共享进程的内存等资源;每个进程拥有各自独立的一套变量,相互不影响,而线程则共享数据,会存在线程安全问题。

    1.4、举例说明线程与进程

    为了能够看到本地计算机上的线程信息,下载Process Explorer,解压运行进行查看。

     从上图可以形象的验证,进程与 线程之间的关系。关于Process Explorer的用法,感兴趣的可以自行研究。

    2、java创建线程的四种方式

    2.1、实现Runnable

    通过实现Runnable接口,重写run()方法。然后借助Thread的start()方法开启线程,调用run()方法是不会开启新线程的,只是一次方法调用而已。

    看一下Runnable接口的java代码,发现它只有一个run()方法。

    public interface Runnable {
        /**
         * When an object implementing interface <code>Runnable</code> is used
         * to create a thread, starting the thread causes the object's
         * <code>run</code> method to be called in that separately executing
         * thread.
         * <p>
         * The general contract of the method <code>run</code> is that it may
         * take any action whatsoever.
         *
         * @see     java.lang.Thread#run()
         */
        public abstract void run();
    }

    进行线程编写, 

    public class CreateThreads implements Runnable{
    
        @Override
        public void run() {
            System.out.println("通过实现Runnable接口开启线程~");
        }
    
        public static void main(String[] args) {
            CreateThreads createThreads = new CreateThreads();
            Thread thread = new Thread(createThreads);
            thread.start();
        }
    }

    2.2、继承Thread

    继承Thread类,重写run()方法。

    public class CreateThreads extends Thread{
    
        @Override
        public void run() {
            System.out.println("通过继承Thread开启线程~");
        }
    
        public static void main(String[] args) {
            CreateThreads createThreads = new CreateThreads();
            Thread thread = new Thread(createThreads);
            thread.start();
        }
    }

    注意:继承Thread类,重写run()方法,其本质上与实现Runnable接口的方式一致,因为Thread类本身就实现了Runnable接口

    public class Thread implements Runnable 。再加上java中多实现,单继承的特点,在选用上述两种方式创建线程时,应该首先考虑第一种(通过实现Runnable接口的方式)。

    2.3、通过Callable、Future

    通过Runnable与Thread的方式创建的线程,是没有返回值的。然而在有些情况下,往往需要其它线程计算得到的结果供给另外线程使用( 例如:计算1+100的值,开启三个线程,一个主线程,两个计算线程,主线程需要获取两个计算线程的结算结果(一个计算线程计算1+2+...+50,另外一个线程计算51+52+..+100),进行相加,从而得到累加结果),这个时候可以采用Runnable与Thread的方式创建的线程,并通过自行编写代码实现结果返回,但是不可避免的会出现黑多错误和性能上的问题。基于此,JUC(java.util.concurrent)提供了解决方案,实现Callable的call()方法(这个类似Runnable接口),使用Future的get()方法进行获取。

    下面首先看一下Callable接口:

    public interface Callable<V> {
        /**
         * Computes a result, or throws an exception if unable to do so.
         *
         * @return computed result
         * @throws Exception if unable to compute a result
         */
        V call() throws Exception;
    }

    下面开始使用Callable、与Future创建多线程。创建过程为:1、自定义一个类实现Callable接口,重写call()方法;2、使用JUC包下的ExecutorService生成一个对象,主要使用submit()方法,返回得到Future对象(关于JUC包下的诸如ExecutorService解析使用,请关注博主的后序文章);3、采用Future的get()获取返回值。

    import java.util.concurrent.*;
    
    /**
     * @author wolf
     * @create 2019-04-25    14:53
     * 计算1+...+100的结果,开启三个线程,主线程获取两个子线程计算的结果,一个子线程计算1+...+50,一个子线程计算51+...+100。
     */
    public class CreateThreads implements Callable {
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            //生成具有两个线程的线程池
            ExecutorService executorService = Executors.newFixedThreadPool(2);
            //调用executorService.submit()方法获取Future
            Future<Integer> result1 = executorService.submit(new CreateThreads());
            Future<Integer> result2 = executorService.submit(new SubThread());
            //使用Future的get()方法等待子线程计算完成返回的结果
            int result = result1.get() + result2.get();
            //关闭线程池
            executorService.shutdown();
            //打印结果
            System.out.println(result);
    
        }
    
        //子线程1,用来计算1+...+50
        @Override
        public Object call() throws Exception {
            int count = 0;
            for (int i = 1; i <= 50; i++)
                count = count + i;
            return count;
        }
    }
    
    class SubThread implements Callable {
        //子线程2,用来计算51+...+100
        @Override
        public Object call() throws Exception {
            int count = 0;
            for (int i = 51; i <= 100; i++)
                count = count + i;
            return count;
        }
    }
    

    2.4、通过JUC里面的线程池

    JUC并发包里的 Executors工具类,提供了创建线程池的工厂方法,具体可以参看JDK的API。

    下面就Executors.newFixedThreadPool()说明,这里请移步2.3节的程序,会发现其实2.3节已经使用了Executors.newFixedThreadPool(2)构建线程池。

     

    3、总结

    通过上述叙述,希望对你知识掌握和面试有所帮助。多线程是java中的进阶,这一块还有很多知识点,本文后会继续发布关于多线程博客,旨在介绍java中多线程的框架,介绍JUC包,一起学习共勉。文中有错误的地方,还请留言给予指正,不胜感激~最后,喜欢博主的文章不妨关注点赞收藏哦,方便下次不走错门。

    展开全文
  • 创建struts action三种方式

    千次阅读 2016-08-07 20:27:26
    第一: 创建一个普通的Java类,但是类中必须得有execute()方法,如下 public class FirstAction { public String execute() throws Exception{ System.out.println("in FirstAction method execute()"); ...
  • Action 中获取表单数据的三种方式

    万次阅读 2016-11-12 12:01:52
    Action 中获取表单提交数据的三种方式:(1)使用ActionContext类来获取。(2)使用ServletActionContext类获取。(3)使用接口注入的方式获取。
  • k8s-(七)暴露服务的三种方式

    万次阅读 多人点赞 2021-01-11 21:05:01
    上一篇博客总结的项目怎么部署到k8s上运行,但是运行pod ip是docker网桥的IP地址段进行分配的,通常是一个虚拟的二层网络,外部网络并没有办法访问,并且,pod ip是随时会变...k8s有三种方式暴露Service给外部网络访问
  • App 快捷方式——创建快捷方式

    千次阅读 2019-01-15 18:53:07
    虽然静态快捷方式的上下文不会更改,并且动态快捷方式的上下文会不断更改,但两情况下的上下文都是由您的应用程序驱动的。 如果用户选择他们希望您的应用向他们提供内容的方式,例如使用固定的快捷方式,则上下文...
  • 创建快捷方式app是专为安卓手机用户制作的快捷方式创建工具,软件可以帮助用户轻松一键创建快捷方式,更便捷智慧使用手机,需要的朋友可以前来下载使用。创建快捷方式app使用说明:先选择一个应用,再选择应用里的...
  • 现在都很流行在桌面上为自己的应用创建快捷方式,网上也很多例子,但是基本都是同一个,创建快捷方式的手法是对的,但是通过快捷方式开启自己的应用的时候会发现程序菜单里头打开的应用和桌面快捷方式打开的应用竟然...
  • struts2通配符及Action开发的三种方式

    千次阅读 2017-04-16 12:20:56
    1)准备一个UserAction.java,这个Action中有两个方法login()和register() package com.bighuan.a_config; import com.opensymphony.xwork2.ActionSupport; /** * @author bighuan */ public class UserAction ex
  • 第十九篇 zabbix创建Action

    万次阅读 2016-11-22 16:30:12
    Zabbix的功能就是用用来进行监控的,当监控的对象出现问题时我们就需要告知维修人员及时过来维修,那么从监控,到出现监控异常,将监控异常报告给维修人员这一系列动作需要zabbix的Action来关联完成。 点击配置-》...
  • RDD:创建的几种方式(scala和java)

    万次阅读 2018-09-19 11:58:56
    Spark编程 每一个spark应用程序都...spark提供的最主要的抽象概念有两: 弹性分布式数据集(resilient distributed dataset)简称RDD ,他是一个元素集合,被分区地分布到集群的不同节点上,可以被并行操作,RD...
  • 一、spring ioc注入有哪三种方式:a setter 原理 : 在目标对象中,定义需要注入的依赖对象对应的属性和setter方法;“让ioc容器调用该setter方法”,将ioc容器实例化的依赖对象通过setter注入给目标对象,封装在...
  • spark创建DF的两种方式

    千次阅读 2018-11-20 23:52:10
    方式一:反射:(使用这种方式创建DF是在你知道字段具体有哪些) 1.创建一个SparkContext,然后再创建SQLContext 2.先创建RDD,对数据进行整理,然后关联case class,将非结构化的数据转换成结构化数据 3.显示的调用...
  • 使用 struts2获取表单数据:只需表单域名称和 Action处理类的属性名称一致,并且提供属性的set方法,那么在 Action处理类中即可获得表单数据。 登录页面login.jsp &lt;%@ page language="ja...
  • Android创建桌面快捷方式

    千次阅读 2018-03-26 16:36:01
      背景 ... 添加桌面图标快捷方式代码非常简单,在API 26(Android O)以下的版本,并没有提供API进行创建桌面快捷方式,但是用户可以通过广播的方式创建桌面快捷方式。在API 26(Android O...
  • 说明:创建Servlet的方式,在上篇博客中,已经用了方式1(实现Servlet接口),接下来本节讲的是另外2种方式。 上篇博客地址:http://blog.csdn.net/qq_26525215/article/details/51942252简单的用户注册功能(我们设置...
  • struts2中的Action三种方式接收前台的数据: 1.基本数据类型的属性对应 2.域对象的对应 3.模型对应 前两是属于属性驱动FieldDriven,后面一是模型驱动ModelDriven 第一: 前台代码: 账号 密码 ...
  • 用Navicat for mysql创建表,在设置外键的时候,删除时和更新时两列有四个值可以选择:CASCADE、NO ACTION、RESTRICT、SET NULL CASCADE、NO ACTION、RESTRICT、SET NULL区别如下: CASCADE:父表delete、update...
  • 浅谈ActionForward的三种重定向

    万次阅读 2014-06-11 08:53:52
    ActionForward是 Struts的核心...在基于Struts的Web应用程序开发过程中,Action操作完毕后程序会通过Struts的配置文件struts- config.xml链接到指定的ActionForward,传到Struts的核心类ActionServlet,ActionServlet使
  • Odoo中的五种Action详解

    千次阅读 2019-06-24 18:17:26
    Odoo中的五种Action详解 Odoo中的五种action都是继承自ir.actions.actions模型实现的子类,共有五。分别对应五类型、五用途。 odoo中还有其他含有action命名的模型,诸如:action.todo等,都不是actions的...
  • 1,创建Action类  并在类上加注解@Controller 和 @Scope("prototype") 2,写其中的方法  CRUD的6个方法(方法名、返回值、注释) 3,创建JSP页面 4,配置struts.xml
  • Struts2获取Session的三种方式

    千次阅读 2018-05-09 23:08:04
    1、Map&lt;String,Object&gt; map = ActionContext.getContext().getSession();2、HttpSession session = ServletActionContext.get...3、让Action实现SessionAware接口,并实现public void setSession(Map...
  • Go语言httpServer创建路由的几种方式

    千次阅读 2017-09-19 15:31:33
    Go语言创建一个HTTP服务器时,三种创建路由的方法
  • 1.创建桌面快捷方式 /** * 创建快捷方式 */ private void createShortcut () { try { boolean isExit = ShortcutUtils.isShortCutExist(getApplicationContext(), "APPNAME" ); if (!isExit)...
  • Java接入Spark之创建RDD的两种方式和操作RDD

    万次阅读 多人点赞 2016-06-02 21:49:20
    Java接入Spark之创建RDD的两种方式和操作RDD
  • 创建对象的几种方式 //字面量创建 var obj4 = { name : 'XT' , age : '28' , action : function ( ) { } } ; //工厂方式的形式 function createObj ( name , age ) { var obj = new ...
  • C# 将程序添加开机启动的三种方式

    万次阅读 多人点赞 2017-04-09 13:57:19
    查资料过程中主要发现有三种方式可以添加到启动,分别是: 1. 开始菜单启动; 2. 注册表启动项; 3. Windows 计划任务。一、开始菜单启动在很久以前,刚开始捯饬电脑的时候,就知道的一个开机启动的方法,那时候...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 714,720
精华内容 285,888
关键字:

创建action的三种方式