精华内容
下载资源
问答
  • Laravel基础-种方式引入公共文件

    千次阅读 2017-07-04 00:56:21
    详细页面–公共部分 即传递成功 2、使用子视图的方式来引入,并且拥有相互传递数据的功能: 一、在views下建立layouts目录,其下放主视图。views下的则为子视图。 二、在layouts下建立home.blade.php主...

    (1)、首先在app\Http\routes.php中定义路由;

    Route::get('view','ViewController@view');
    Route::get('article','ViewController@article');
    Route::get('layout','ViewController@layout');

    (2)、然后在Http\Controllers\ViewController.php中写入方法;

        public function view(){
            return view('index');
        }
        public function article(){
            return view('article');
        }
        public function layout(){
            return view('layout');
        }

    (3)、然后在新建不同的视图文件,路径为:resources\views

    index.blade.php
    article.blade.php
    layout.blade.php

    重点:
    1、使用include的方式:
    一、在views下建立common目录文件,用于存放公共文件;
    二、将公共内容放入common下,如在common建立了一个header.blade.php;
    三、在视图中引入公共文件:

    @include('common.header')
    //这样的书写方式来引入:目录名称.公共文件名

    另外,如果在header公共区域中有不同的数据,那么可以使用以下方式来传递数据:

    //视图中的代码
    @include('common.header',['page' => '详细页面'])
    
    //header.blade.php公共文件中的代码
    {{$page}}--公共部分

    那么,以上会输出:详细页面–公共部分
    即传递成功

    2、使用子视图的方式来引入,并且拥有相互传递数据的功能:
    一、在views下建立layouts目录,其下放主视图。views下的则为子视图。
    二、在layouts下建立home.blade.php主视图文件。可以供子视图调用。
    三、在views目录下的layout.blade.php中引入主视图文件:采用继承的方式:

    home主视图里:

            <div class="container">
    
            <!-- @yield('content') -->
            yield是一个标识,标识是不一样的变量数据
    
            @section('content')
                <b>我是主模板里的内容</b>
            @show
            //在主视图想获取子视图变量数据的情况下,必须使用show关键字而不是endsection



    子视图里:

    //继承使用主视图
    @extends('layouts.home')
    
    //section可以获取主模板的内容
    @section('content')
    <!--@parent-->  //parent意为:子模板可以获取主模板里的内容
    我是layout的替换内容123
    @endsection
    展开全文
  • 1 Java引用介绍 Java从1.2版本开始引入了4种引用,这4种引用的级别由高到低依次为: 强引用 > 软引用 > 弱引用 > 虚引用 ...⑴强引用(StrongReference) 强引用是使用最普遍的引用。如果一对象具...

    本文章转载自 https://www.cnblogs.com/skywang12345/p/3154474.html

    1 Java引用介绍

       Java从1.2版本开始引入了4种引用,这4种引用的级别由高到低依次为:

       强引用  >  软引用  >  弱引用  >  虚引用

    ⑴强引用(StrongReference)
        强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾回收器绝不会回收它。当内存空间不足,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足的问题。

    ⑵软引用(SoftReference)

        如果一个对象只具有软引用,则内存空间足够,垃圾回收器就不会回收它;如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。

        软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收器回收,Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

    ⑶弱引用(WeakReference)

        弱引用与软引用的区别在于:只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。不过,由于垃圾回收器是一个优先级很低的线程,因此不一定会很快发现那些只具有弱引用的对象。

        弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被垃圾回收,Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

    ⑷虚引用(PhantomReference)

        “虚引用”顾名思义,就是形同虚设,与其他几种引用都不同,虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收。

        虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于:虚引用必须和引用队列 (ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与之 关联的引用队列中。

     

    由于引用和内存回收关系紧密。下面,先通过实例对内存回收有个认识;然后,进一步通过引用实例加深对引用的了解。

     

     

     


    2 内存回收

    创建公共类MyDate,它的作用是覆盖finalize()函数:在finalize()中输出打印信息,方便追踪。

    说明:finalize()函数是在JVM回收内存时执行的,但JVM并不保证在回收内存时一定会调用finalize()。

    MyDate代码如下:

    复制代码

    package com.skywang.java;
    
    import java.util.Date;
    
    public class MyDate extends Date { 
    
        /** Creates a new instance of MyDate */
        public MyDate() {
        }
        // 覆盖finalize()方法
        protected void finalize() throws Throwable {
            super.finalize();
            System.out.println("obj [Date: " + this.getTime() + "] is gc");
        }   
    
        public String toString() {
            return "Date: " + this.getTime();
        }
    }

    复制代码

    在这个类中,对java.util.Date类进行了扩展,并重写了finalize()和toString()方法。

     

    创建公共类ReferenceTest,它的作用是定义一个方法drainMemory():消耗大量内存,以此来引发JVM回收内存。

    ReferenceTest代码如下:

    复制代码

    package com.skywang.java;
    
    public class ReferenceTest {   
        /** Creates a new instance of ReferenceTest */
        public ReferenceTest() {
        }   
        
        // 消耗大量内存
        public static void drainMemory() {
            String[] array = new String[1024 * 10];
            for(int i = 0; i < 1024 * 10; i++) {
                for(int j = 'a'; j <= 'z'; j++) {
                    array[i] += (char)j;
                }           
            }
        }
    } 

    复制代码

    在这个类中定义了一个静态方法drainMemory(),此方法旨在消耗大量的内存,促使JVM运行垃圾回收。

     

    有了上面两个公共类之后,我们即可测试JVM什么时候进行垃圾回收。下面分3种情况进行测试:

    情况1:清除对象

    实现代码

    复制代码

    package com.skywang.java;
    
    public class NoGarbageRetrieve {
    
        public static void main(String[] args) {
            MyDate date = new MyDate();
            date = null;
        }
    }

    复制代码

    运行结果

    <无任何输出>

    结果分析:date虽然设为null,但由于JVM没有执行垃圾回收操作,MyDate的finalize()方法没有被运行。

     

    情况2:显式调用垃圾回收

    实现代码: 

    复制代码

    package com.skywang.java;
    
    public class ExplicitGarbageRetrieve {
    
        /**
         * @param args
         */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            MyDate date = new MyDate();
            date = null;
            System.gc();
        }
    
    }

    复制代码

    运行结果

    obj [Date: 1372137067328] is gc

    结果分析:调用了System.gc(),使JVM运行垃圾回收,MyDate的finalize()方法被运行。

     

    情况3:隐式调用垃圾回收

    实现代码: 

    复制代码

    package com.skywang.java;
    
    public class ImplicitGarbageRetrieve {
    
        /**
         * @param args
         */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            MyDate date = new MyDate();
            date = null;
            ReferenceTest.drainMemory();
        }
    
    } 

    复制代码

    运行结果

    obj [Date: 1372137171965] is gc

    结果分析:虽然没有显式调用垃圾回收方法System.gc(),但是由于运行了耗费大量内存的方法,触发JVM进行垃圾回收。

     

    总结:JVM的垃圾回收机制,在内存充足的情况下,除非你显式调用System.gc(),否则它不会进行垃圾回收;在内存不足的情况下,垃圾回收将自动运行

     

     

     


    3、Java对引用的分类

    3.1 强引用

    实例代码

    复制代码

    package com.skywang.java;
    
    public class StrongReferenceTest {
    
        public static void main(String[] args) {
            MyDate date = new MyDate();
            System.gc();
        }
    }

    复制代码

    运行结果

    <无任何输出>

    结果说明:即使显式调用了垃圾回收,但是用于date是强引用,date没有被回收。

     

    3.2 软引用

    实例代码

    复制代码

    package com.skywang.java;
    
    import java.lang.ref.SoftReference;
    
    public class SoftReferenceTest {
    
        public static void main(String[] args) {
            SoftReference ref = new SoftReference(new MyDate());
            ReferenceTest.drainMemory();
        }
    }

    复制代码

    运行结果

    <无任何输出>

    结果说明:在内存不足时,软引用被终止。软引用被禁止时,

    SoftReference ref = new SoftReference(new MyDate());
    ReferenceTest.drainMemory();

    等价于

    MyDate date = new MyDate();

    // 由JVM决定运行
    If(JVM.内存不足()) {
    date = null;
    System.gc();
    }

     

    3.3 弱引用

    示例代码: 

    复制代码

    package com.skywang.java;
    
    import java.lang.ref.WeakReference;
    
    public class WeakReferenceTest {
    
        public static void main(String[] args) {
            WeakReference ref = new WeakReference(new MyDate());
            System.gc(); 
        }
    }

    复制代码

    运行结果

    obj [Date: 1372142034360] is gc

    结果说明:在JVM垃圾回收运行时,弱引用被终止.

    WeakReference ref = new WeakReference(new MyDate());
    System.gc();

    等同于:

    MyDate date = new MyDate();

    // 垃圾回收
    If(JVM.内存不足()) {
    date = null;
    System.gc();
    }

     

    3. 4 假象引用

    示例代码: 

    复制代码

    package com.skywang.java;
    
    import java.lang.ref.ReferenceQueue;
    import java.lang.ref.PhantomReference;
    
    public class PhantomReferenceTest {
    
        public static void main(String[] args) {
            ReferenceQueue queue = new ReferenceQueue();
            PhantomReference ref = new PhantomReference(new MyDate(), queue);
            System.gc();
        }
    }

    复制代码

    运行结果

    obj [Date: 1372142282558] is gc

    结果说明:假象引用,在实例化后,就被终止了。

    ReferenceQueue queue = new ReferenceQueue();
    PhantomReference ref = new PhantomReference(new MyDate(), queue);
    System.gc();

    等同于:

    MyDate date = new MyDate();
    date = null;

     

     

    可以用以下表格总结上面的内容: 

    级别

    什么时候被垃圾回收

    用途

    生存时间

    强引用

    从来不会

    对象的一般状态

    JVM停止运行时终止

    软引用

    在内存不足时

    对象简单?缓存

    内存不足时终止

    弱引用

    在垃圾回收时

    对象缓存

    gc运行后终止

    虚引用

    Unknown

    Unknown

    Unknown

     

     

     

    展开全文
  • 判断一点是否在某个区域内(多边形) 比如滴滴会根据乘客所在的不同区域,给出不同的价格。市区堵一点,那么价格也高点。获取服务范围只规定在某个范围内

    判断一个点是否在某个区域内(多边形)

    背景:

        比如滴滴会根据乘客所在的不同区域,给出不同的价格。市区堵一点,那么价格也高点。获取服务范围只规定在某个范围内

    原理:

        求解从该点向右发出的水平线射线与多边形各边的交点,当交点数为奇数,则在内部。

        不过要注意几种特殊情况:1、点在边或者顶点上;2、点在边的延长线上;3、点出发的水平射线与多边形相交在顶点上

        

    源代码:

        Point类-多边形顶点的封装类如坐标(166.3,18.4)
        Line类-多边形对应的各个边的封装类,如{(166.3,18.4), (166.9,19)}
        MapUtil类-地图公共处理类

        

    package com.qj.book.util;
    
    
        /**
         * Created by xsm48563 on 2017/10/31.
         * 点
         */
        public class Point {
    
    
            /**
             * 水平方向值/经度
             */
            public Double X;
            /**
             * 垂直方向值/纬度
             */
            public Double Y;
    
    
            Point(Double x, Double y) {
    
    
                x = x == null ? 0:x;
                y = y == null ? 0:y;
                this.X = x;
                this.Y = y;
            }
    
    
            public boolean equals(Object obj) {
    
    
                // 如果为同一对象的不同引用,则相同
                if (this == obj) {
                    return true;
                }
                // 如果传入的对象为空,则返回false
                if (obj == null) {
                    return false;
                }
                if (obj instanceof Point) {
                    Point point = (Point) obj;
                    if (point.X.equals(this.X) && point.Y.equals(this.Y)) {
                        return true;
                    } else {
                        return false;
                    }
                } else {
                    return false;
                }
            }
    
    
            public static void main(String[] args) {
    
    
                Point A = new Point(1d, null);
                Point B = new Point(null, 3d);
                System.out.println(A.equals(B));
            }
        }
    
    
        package com.qj.book.util;
    
    
        import java.math.BigDecimal;
    
    
        /**
         * Created by xsm48563 on 2017/10/31.
         * 线
         */
        public class Line {
    
    
            /**
             * 端点1
             */
            public Point POINTA;
    
    
            /**
             * 端点2
             */
            public Point POINTB;
    
    
            Line(Point pointA, Point pointB) {
    
    
                this.POINTA = pointA;
                this.POINTB = pointB;
            }
    
    
            /**
             * 判断当前线段是否包含给定的点</br>
             * 即给定的点是否在当前边上
             * @param point
             * @return
             */
            public boolean isContainsPoint(Point point) {
    
    
                boolean result = false;
                //判断给定点point与端点1构成线段的斜率是否和当前线段的斜率相同
                //给定点point与端点1构成线段的斜率k1
                Double k1 = null;
                if (point.X.equals(this.POINTA.X)) {
                    k1 = Double.NEGATIVE_INFINITY;
                } else {
                    k1 = div(sub(point.Y, this.POINTA.Y), sub(point.X, this.POINTA.X));
                }
                //当前线段的斜率k2
                Double k2 = null;
                if (this.POINTB.X.equals(this.POINTA.X)) {
                    k2 = Double.NEGATIVE_INFINITY;
                } else {
                    k2 = div(sub(this.POINTB.Y, this.POINTA.Y), sub(this.POINTB.X, this.POINTA.X));
                }
                if (k1 != null && k2 != null) {
                    if (k1.equals(k2)) {
                        //若斜率相同,继续判断给定点point的x是否在pointA.x和pointB.x之间,若在 则说明该点在当前边上
                        if (sub(point.X, this.POINTA.X) * sub(point.X, this.POINTB.X) < 0) {
                            result = true;
                        }
                    }
                }
                return result;
            }
    
    
            //叉积
            double mult(Point a, Point b, Point c) {
                return (a.X-c.X)*(b.Y-c.Y)-(b.X-c.X)*(a.Y-c.Y);
            }
    
    
            /**
             * 给定线段是否与当前线段相交</br>
             * 相交返回true, 不相交返回false
             * @param line
             * @return
             */
            public boolean
            isIntersect(Line line) {
    
    
                Point aa = this.POINTA;
                Point bb = this.POINTB;
                Point cc = line.POINTA;
                Point dd = line.POINTB;
                if (Math.max(aa.X, bb.X) < Math.min(cc.X, dd.X)) {
                    return false;
                }
                if (Math.max(aa.Y, bb.Y) < Math.min(cc.Y, dd.Y)) {
                    return false;
                }
                if (Math.max(cc.X, dd.X) < Math.min(aa.X, bb.X)) {
                    return false;
                }
                if (Math.max(cc.Y, dd.Y) < Math.min(aa.Y, bb.Y)) {
                    return false;
                }
                if (mult(cc, bb, aa) * mult(bb, dd, aa) < 0 ) {
                    return false;
                }
                if ( mult(aa, dd, cc) * mult(dd, bb, cc) < 0 ) {
                    return false;
                }
                return true;
            }
    
    
            /**
             * 提供精确的加法运算。
             * @param v1 被加数
             * @param v2 加数
             * @return 两个参数的和
             */
            public static double add(double v1,double v2){
                BigDecimal b1 = new BigDecimal(Double.toString(v1));
                BigDecimal b2 = new BigDecimal(Double.toString(v2));
                return b1.add(b2).doubleValue();
            }
    
    
            /**
             * 提供精确的减法运算。
             * @param v1 被减数
             * @param v2 减数
             * @return 两个参数的差
             */
            public static double sub(double v1,double v2){
                BigDecimal b1 = new BigDecimal(Double.toString(v1));
                BigDecimal b2 = new BigDecimal(Double.toString(v2));
                return b1.subtract(b2).doubleValue();
            }
    
    
            /**
             * 提供精确的乘法运算。
             * @param v1 被乘数
             * @param v2 乘数
             * @return 两个参数的积
             */
            public static double mul(double v1,double v2){
                BigDecimal b1 = new BigDecimal(Double.toString(v1));
                BigDecimal b2 = new BigDecimal(Double.toString(v2));
                return b1.multiply(b2).doubleValue();
            }
    
    
            private static final int DEF_DIV_SCALE = 10;
    
    
            /**
             * 提供(相对)精确的除法运算,当发生除不尽的情况时,精确到
             * 小数点以后10位,以后的数字四舍五入。
             * @param v1 被除数
             * @param v2 除数
             * @return 两个参数的商
             */
            public static double div(double v1,double v2){
                return div(v1,v2,DEF_DIV_SCALE);
            }
    
    
            /**
             * 提供(相对)精确的除法运算。当发生除不尽的情况时,由scale参数指
             * 定精度,以后的数字四舍五入。
             * @param v1 被除数
             * @param v2 除数
             * @param scale 表示表示需要精确到小数点以后几位。
             * @return 两个参数的商
             */
            public static double div(double v1,double v2,int scale){
                if(scale<0){
                    throw new IllegalArgumentException(
                            "The scale must be a positive integer or zero");
                }
                BigDecimal b1 = new BigDecimal(Double.toString(v1));
                BigDecimal b2 = new BigDecimal(Double.toString(v2));
                return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
            }
        }
    
    
        package com.qj.book.util;
    
    
        import com.alibaba.fastjson.JSONArray;
        import com.alibaba.fastjson.JSONObject;
        import java.math.BigDecimal;
        import java.util.ArrayList;
        import java.util.List;
    
    
        /**
         * Created by xsm48563 on 2017/10/31.
         * 图形专用类
         */
        public class MapUtil {
    
    
    
    
            /**
             * 给定点和多边形,判断给定的点是否在多边形内
             * @param point
             * @param points
             * @return
             */
            public static boolean isPointInPolygon(Point point, List<Point> points) {
    
    
                boolean result = false;
                int intersectCount = 0;
                // 判断依据:求解从该点向右发出的水平线射线与多边形各边的交点,当交点数为奇数,则在内部
                //不过要注意几种特殊情况:1、点在边或者顶点上;2、点在边的延长线上;3、点出发的水平射线与多边形相交在顶点上
                /**
                 * 具体步骤如下:
                 * 循环遍历各个线段:
                 *  1、判断点是否在当前边上(斜率相同,且该点的x值在两个端口的x值之间),若是则返回true
                 *  2、否则判断由该点发出的水平射线是否与当前边相交,若不相交则continue
                 *  3、若相交,则判断是否相交在顶点上(边的端点是否在给定点的水平右侧).若不在,则认为此次相交为穿越,交点数+1 并continue
                 *  4、若交在顶点上,则判断上一条边的另外一个端点与当前边的另外一个端点是否分布在水平射线的两侧.若是则认为此次相交为穿越,交点数+1.
                 */
                for (int i = 0; i < points.size(); i++) {
                    Point pointA = points.get(i);
                    Point pointB = null;
                    Point pointPre = null;
                    //若当前是第一个点,则上一点则是list里面的最后一个点
                    if (i == 0) {
                        pointPre = points.get(points.size() - 1);
                    } else {
                        pointPre = points.get(i - 1);
                    }
                    //若已经循环到最后一个点,则与之连接的是第一个点
                    if (i == (points.size() - 1)) {
                        pointB = points.get(0);
                    } else {
                        pointB = points.get(i + 1);
                    }
                    Line line = new Line(pointA, pointB);
                    //1、判断点是否在当前边上(斜率相同,且该点的x值在两个端口的x值之间),若是则返回true
                    boolean isAtLine = line.isContainsPoint(point);
                    if (isAtLine) {
                        return true;
                    } else {
                        //2、若不在边上,判断由该点发出的水平射线是否与当前边相交,若不相交则continue
                        //设置该射线的另外一个端点的x值=999,保证边的x永远不超过
                        Point  radialPoint = new Point(999d, point.Y);
                        Line radial = new Line(point, radialPoint);
                        boolean isIntersect = radial.isIntersect(line);
                        if (!isIntersect) {
                            continue;
                        } else {
                            //3、若相交,则判断是否相交在顶点上(边的端点是否在给定点的水平右侧).若不在,则认为此次相交为穿越,交点数+1 并continue
                            if (!( (pointA.X > point.X) && (pointA.Y.equals(point.Y))
                                    || (pointB.X > point.X) && (pointB.Y.equals(point.Y)) )) {
                                intersectCount++;
                                continue;
                            } else {
                                //4、若交在顶点上,则判断上一条边的另外一个端点与当前边的另外一个端点是否分布在水平射线的两侧.若是则认为此次相交为穿越,交点数+1
                                if ((pointPre.Y - point.Y) * (pointB.Y - point.Y) < 0) {
                                    intersectCount++;
                                }
                            }
                        }
                    }
                }
                result = intersectCount % 2 == 1;
                return result;
            }
    
    
            public static void main(String[] args) {
    
    
                Point point11 = new Point(1d, 2d);
                Point point22 = new Point(2d, 4d);
                Point point33 = new Point(3d, 4d);
                Point point44 = new Point(5d, 2d);
                Point point55 = new Point(5d, 1d);
                Point point66 = new Point(3d, 0d);
                List<Point> points = new ArrayList<>();
                points.add(point11);
                points.add(point22);
                points.add(point33);
                points.add(point44);
                points.add(point55);
                points.add(point66);
                Point test = new Point(2d, 3d);
                System.out.println(isPointInPolygon(test, points));
            }
        }

    转载至:http://www.qunjianinfo.com/com/qj/front/content.html?fmId=28&catalogNo=2


    展开全文
  • 类定义中的成员变量有种形式:实例变量和类变量 ...类变量属于类而不属于任何一具体的对象,它被保存在该类内在区的公共存储单元中。因此不管建立了多少类对象都只存在一副本,即使类中没有建立任何对象,

    类定义中的成员变量有两种形式:实例变量和类变量

    实例变量:这种形式的变量与具体对象相关联,不同的对像这个变量的值就不一样,举例来说明圆这个类,其不同实例对象也就是不同的圆其半径也是不一样的。

    类变量:这种形式的变量与类相关,并且由类中所有的对象共享。类变量属于类而不属于任何一个具体的对象,它被保存在该类内在区的公共存储单元中。因此不管建立了多少类对象都只存在一个副本,即使类中没有建立任何对象,它们也存在。类变量通过关键字static声明,所以也可称为静态变量。


    与类定义中变量类似,成员方法有两种形式:实例方法和类方法。实例方法只能被关联的特定对象所执行,即只能通过对象调用。因此如果没有对象存在,就不能执行实例方法。类方法则不同,即使在类中不存在任何对象时,也可以执行类方法。

    提示:对于静态方法与实例方法的使用,有两点需要特别注意。

    1 类方法中不能引用实例变量。由于static方法是发球

    展开全文
  • 我们都知道,c#的大数据类型分别为值类型(int,float,double,char,DataTime)和引用类型(类、托管、数组和接口)。很多人或许闭着眼睛都能说出值类型包括简单类型、结构体类型和枚举类型,引用类型包括自定义类、数组...
  • 翻译 tellmenowWindows CE的基本目标定位--小型个人生产力工具--在驱动着公共控件的需求。日程和任务管理应用程序中频繁用到时间和日期的需求导致在控件中包括了日期和时间选择控件以及日历控件。个人生产力工具的小...
  • 判断一点是否在某个区域内(多边形)背景:比如滴滴会根据乘客所在的不同区域,给出不同的价格。市区堵一点,那么价格也高点。获取服务范围只规定在某个范围内原理:求解从该点向右发出的水平线射线与多边形各边的...
  • &lt;script&gt; layui.config({ ...这样引入的是多文件     //iframe替换区域内容   &lt;div class="layui-tab-content" style="min-height: 150px; padd...
  • 引用计数法的循环引用问题

    千次阅读 2018-10-15 17:13:20
    关于引用计数法,我们可以先看一段wiki上的描述:   As a collection algorithm, reference counting tracks, for each object, a count of the number of references to it held by other objects. If an object...
  • JAVA对象引用和值引用

    千次阅读 2009-12-02 22:45:00
    以前就知道JAVA对象分对象引用和值引用,并且还知道8种基础数据类型,即引用时是值引用的数据类型,比如int,short,long,byte,float,double,char,boolean,其它都是对象引用。可是其它的对象引用我一直都以为跟c里面...
  • Python中对象的引用和共享引用

    千次阅读 2016-10-01 19:14:13
    在Python中先创建一对象,然后再将变量指向所创建的对象。...另外,在python中,每对象都保有一计数器,计数器中记录了这对象被引用的次数,当这计数器被置为0时,对象所占用的内存空间就会被释放,
  • Java内存区域与Java内存模型

    千次阅读 2018-02-25 15:09:43
    Java虚拟机在运行程序时会把其自动管理的内存划分为以上几个区域,每个区域都有其用途以及创建销毁的时机,其中蓝色部分代表的是所有线程共享的数据区域,而绿色部分代表的是每个线程的私有数据区域。 方法区...
  • 公共语言运行时

    千次阅读 2009-11-21 20:51:00
    公共语言运行时是 .NET Framework 的基础。它负责在运行时管理代码的执行,并提供一些核心服务,如编译、内存管理、线程管理、代码执行、强制实施类型安全以及代码安全性验证。编译器以定义应用程序开发人员可用的...
  • 公共语言运行库(CLR)

    千次阅读 2013-12-17 14:48:19
    公共语言运行库(CLR) 概述 .NET Framework的核心是其运行库的执行环境,称为公共语言运行库(CLR)或.NET运行库....在.NET中,编译分为两个阶段: 1、把源代码编译为Microsoft中间语言(IL)。 2、CLR把I
  • 周末的时候在看common.js规范时候遇到一问题: function require () { let Modules = {exports:{}}; (function (Modules, exports) { let someFn = function () {}; ***//exports和modules.exports断开了...
  • vue项目中全局引用jquery : 1、“ npm install jquery --save ” 命令安装jquery 2、在项目根目录下的 build 目录下找到webpack.base.conf.js 文件,在开头使用以下代码引入webpack,如下 var webpack = ...
  • C语言程序的存储区域和编译过程

    千次阅读 2014-07-02 22:58:13
    由C语言代码(文本文件)形成可执行程序(二进制文件),需要经过预处理-编译-优化-汇编-链接五阶段。 编译,编译程序读取源程序(字符流),对之进行词法和语法的分析,将高级语言指令转换为功能等效的汇编...
  • 两个View:view1和view2,view2在view1上面且比view1小,如何判断点击view1之内的屏幕是应该由view1处理事件还是由view2处理(腾讯-微信-一面) NDK是否可以加载任意目录下的so文件,so文件有几种加载方式(腾讯-...
  • 等号、运算符、单元格引用、值或常量、括号、工作表函数及其参数 (1)算术运算符 加(+)、减(-)、乘(*)、除(/)、负号(-)、百分号(%)、幂乘(^) (2)比较运算符 等号(=)、大于(>)、小于()、...
  • java中的经典问题:传值与传引用

    万次阅读 多人点赞 2014-04-04 16:30:53
    编译程序不可能知道每次调用的实际参数都是什么,于是写编译器的高手就出办法,让实际参数按照一定顺序放到一大家都可以找得到的地方,以此作为方法调用的一种约定。所谓“没有规矩,不成方圆”,有了这
  • 屏幕顶端、应用界面区之外的那部分显示手机电池网络运营商信息的为“状态栏”,应用区域顶端、View绘制区外部显示Activity名称的部分我们称为“标题栏”。下边给出4中状态栏高度获取和2种标题栏获取高度的方法——
  • ASP.NET MVC公共模板、节、分部视图等

    千次阅读 2015-06-02 09:23:45
    一、公共模板 1、@RenderBody() 在网站公用部分通过一占位符@RenderBody()来为网站独立部分预留一位置。然后私有页面顶部通过@{Layout="公用模板路径"}来引入公用模板,并在自身放到公用模板的位置。同时也...
  • 公共语言运行库(CLR)

    千次阅读 2009-10-20 17:21:00
    一、公共语言运行库概述 公共语言运行库的功能通过公开编译器和工具,您可以编写利用此托管执行环境的代码。使用基于公共语言运行库的语言编译器开发的代码称为托管代码;托管代码具有许多优点,例如:跨语言集成、...
  • 7、公共电话交换网络(物理层)

    千次阅读 2018-12-06 15:44:31
    1、公共电话交换网络 1.1电话系统结构 贝尔发明电话后,最初的市场是电话销售,当时电话是成对出售的,顾客必须自己在一对电话之间拉上一条线,如果电话主人想跟其他n电话主人通话,则他必须拉n根单独的电话线...
  • 常用的公共数据集(二)

    万次阅读 多人点赞 2019-03-22 11:20:31
    视听事件(AVE)数据集- AVE数据集包含4143YouTube视频,涵盖28事件类别和AVE数据集中的视频,在时间上标有视听事件边界。(田亚鹏,景石,李伯辰,段志尧,徐晨亮) 多模态语义自我中心视频(DoMSEV)的数据...
  • 对于攻击区域的计算,请看上遍文章: MMO游戏技能攻击区域的计算 MMO游戏技能攻击区域的计算2--给地图划分格子 这篇文章已经对攻击区域进行详细讲解,分为没划分格子和划分格子的情况。这里就不在详述了。 在...
  • java 内存区域及存放内容

    千次阅读 2017-04-10 17:23:45
    新生代 ( Young ) 又被划分为三个区域:Eden、From Survivor、To Survivor。 这样划分的目的是为了使 JVM 能够更好的管理堆内存中的对象,包括内存的分配以及回收。 堆的内存模型大致为: 从图中...
  • 引用Delphi操作EXCEL (详细)

    千次阅读 2011-12-14 09:09:29
    引用Delphi操作EXCEL    来源:http://wenjieshiyu.blog.163.com/blog/static/10739413201072033115869/   Delphi 控制Excel (一) 使用动态创建的方法 首先创建 Excel 对象,使用ComObj: var ExcelApp: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,581
精华内容 16,232
关键字:

引用两个区域的公共部分