how to make showing and hiding outline?

You could calculate the distance from the object to the player like this. Then if the player is 2 meter or less from the object you could switch to another shader with an outline, like this shader (on the wiki). If player is more than 2 meters from the object, you switch to your default shader. You could also remove the "showing on top" effect of the shader by removing all occurrences of "ZTest Always" in the shader.

Edit: You could do something like this, for your script on the object (Not the best way to do it, I think, but it works). Drag your player to the player prop in the inspector, set the distance condition, set the outline color and width -> and i think you are ready to go.

 //ObjectOutliner.cs
 using UnityEngine;
 using System.Collections;
 
 public class ObjectOutliner : MonoBehaviour {
     public GameObject player;
     public Shader shader1;
     public Shader shader2;
     public float outlineSize = 0.01f;
     public float distanceToAct = 2;
     public Color outlineColor = Color.black;
     private bool alreadyNear = false;
     
     // Use this for initialization
     void Start () {
         shader1 = Shader.Find("Diffuse");
         shader2 = Shader.Find("Outlined/Silhouetted Diffuse");
     }
     
     // Update is called once per frame
     void Update () {
         float distance = Vector3.Distance(gameObject.transform.position, player.transform.position);

         if (distance <= distanceToAct) {
             if (!alreadyNear) {
                 alreadyNear = true;
                 renderer.material.shader = shader2;
                 renderer.material.SetFloat("_Outline", outlineSize);
                 renderer.material.SetColor("_OutlineColor", outlineColor);
             }
         } else {
             alreadyNear = false;
             renderer.material.shader = shader1;
         }
     }
 }

Your shader would be (Taken from unity wiki, and removed ZTest always):

 Shader "Outlined/Silhouetted Diffuse" {
     Properties {
         _Color ("Main Color", Color) = (.5,.5,.5,1)
         _OutlineColor ("Outline Color", Color) = (0,0,0,1)
         _Outline ("Outline width", Range (0.0, 0.03)) = .01
         _MainTex ("Base (RGB)", 2D) = "white" { }
     }
     
 CGINCLUDE
 #include "UnityCG.cginc"
 
 struct appdata {
     float4 vertex : POSITION;
     float3 normal : NORMAL;
 };
 
 struct v2f {
     float4 pos : POSITION;
     float4 color : COLOR;
 };
 
 uniform float _Outline;
 uniform float4 _OutlineColor;
 
 v2f vert(appdata v) {
     // just make a copy of incoming vertex data but scaled according to normal direction
     v2f o;
     o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
 
     float3 norm   = mul ((float3x3)UNITY_MATRIX_IT_MV, v.normal);
     float2 offset = TransformViewToProjection(norm.xy);
 
     o.pos.xy += offset * o.pos.z * _Outline;
     o.color = _OutlineColor;
     return o;
 }
 ENDCG
 
     SubShader {
         Tags { "Queue" = "Transparent" }
 
         // note that a vertex shader is specified here but its using the one above
         Pass {
             Name "OUTLINE"
             Tags { "LightMode" = "Always" }
             Cull Off
             ZWrite Off
             ColorMask RGB // alpha not used
 
             // you can choose what kind of blending mode you want for the outline
             Blend SrcAlpha OneMinusSrcAlpha // Normal
             //Blend One One // Additive
             //Blend One OneMinusDstColor // Soft Additive
             //Blend DstColor Zero // Multiplicative
             //Blend DstColor SrcColor // 2x Multiplicative
 
 CGPROGRAM
 #pragma vertex vert
 #pragma fragment frag
 
 half4 frag(v2f i) :COLOR {
     return i.color;
 }
 ENDCG
         }
 
         Pass {
             Name "BASE"
             ZWrite On
             ZTest LEqual
             Blend SrcAlpha OneMinusSrcAlpha
             Material {
                 Diffuse [_Color]
                 Ambient [_Color]
             }
             Lighting On
             SetTexture [_MainTex] {
                 ConstantColor [_Color]
                 Combine texture * constant
             }
             SetTexture [_MainTex] {
                 Combine previous * primary DOUBLE
             }
         }
     }
     
     SubShader {
         Tags { "Queue" = "Transparent" }
 
         Pass {
             Name "OUTLINE"
             Tags { "LightMode" = "Always" }
             Cull Front
             ZWrite Off
             ColorMask RGB
 
             // you can choose what kind of blending mode you want for the outline
             Blend SrcAlpha OneMinusSrcAlpha // Normal
             //Blend One One // Additive
             //Blend One OneMinusDstColor // Soft Additive
             //Blend DstColor Zero // Multiplicative
             //Blend DstColor SrcColor // 2x Multiplicative
 
             CGPROGRAM
             #pragma vertex vert
             #pragma exclude_renderers gles xbox360 ps3 flash
             ENDCG
             SetTexture [_MainTex] { combine primary }
         }
 
         Pass {
             Name "BASE"
             ZWrite On
             ZTest LEqual
             Blend SrcAlpha OneMinusSrcAlpha
             Material {
                 Diffuse [_Color]
                 Ambient [_Color]
             }
             Lighting On
             SetTexture [_MainTex] {
                 ConstantColor [_Color]
                 Combine texture * constant
             }
             SetTexture [_MainTex] {
                 Combine previous * primary DOUBLE
             }
         }
     }
     
     Fallback "Diffuse"
 }

Here's a package of an working example: OutlineExample Here's the testbuild for Windows. Here's a testbuild for WebPlayer.