需求

最近碰上这么一个需求：

一张表里面有一组数据的标准值（阀值），其余数据全是实际情况的具体值，现在要求如果实际情况的具体值大于了标准值，就要吧这条数据插入另一张表里面；

其实本质情况不就是对比两个对象中的全部属性值大小嘛

示例数据
实际数据展示：



标准值（阀值）展示


思路
因为要对比所有的属性值大小，首先要拿到单个属性，所以这块我们可以利用反射去做：

暴力反射拿到类中所有的值；（因为都是private修饰，所以必须得是暴力反射）
获取各个属性值的大小，然后作比较；（有个小细节，注意值的类型）
超过标准值（阀值），塞进另一张表。

代码
public void compareObject(Object obj1, Object obj2) throws Exception{
    	//确保是同一对象
        if (obj1.getClass() == obj2.getClass()) {
            // 获取所有属性
            Field[] fs = obj1.getClass().getDeclaredFields();
            //获取各个属性的值
            for (Field field : fs) {
                //true代表暴力反射，可以访问private修饰的东西，否则无法访问
                field.setAccessible(true);
                Object v1 = field.get(obj1);
                Object v2 = field.get(obj2);
                if(v1 instanceof Double && v1 instanceof Double){//值的类型
                    ifOverThreshold(field.getName(),v1, v2);
                }
            }
        }
    }

public void ifOverThreshold(String fieldName, Object obj1, Object obj2) throws Exception {
        String message = "";
        if((double)obj1 > (double)obj2){
           message =fieldName + "数据超阈值";
            System.out.println(message);
            
            //超出阀值插入另一张表的操作
            
        }else{
            //符合标准值以下的操作
            
        }
    }

一：JSON的定义

JSON是JS的一种简单的数据格式，JSON是javaScript的原生格式，它是一种严格的

js对象的格式，JSON的属性名必须有双引号，如果值是字符串，也必须是双引号；

二：JSON的具体的表示规则

对象是一个无序的"名称/值对"的集合，

一个对象用花括号{}括起来，

每个名称后面加上一个冒号：

名称/值对之间用逗号分隔

注意：（JOSN是一种严格的js对象的格式，JSON属性名称必须是双引号，如果

值是字符串，也必须是双引号），不能使用单引号 ；

下面是一些具体的实例：

<script>

　　　　var obj ={};//这只是JS对象

　　　　var obj1={width:100,height:200}//JS对象

　　　　var obj2={'width':100,'height':100}//JS对象

        //JSON格式的JS对象
　　　　var obj3={"width":100,"height":100,"name":"rose"}

        //我们可以把这个称做：JSON格式的字符串
　　　　var obj4='{"width":100,"height":200,"name":"rose"}';
        //这个叫JSON格式的数组，是JSON的稍复杂一点的形式
　　　　var array=[
　　　　 {"width":100,"height":200,"name":"rose"}
        {"width":100,"height":200,"name":"rose"},
        {"width":100,"height":200,"name":"rose"},
　　　　] 
//这个叫稍复杂一点的JSON格式的字符串 
var arrayStr='['+
 　　　　'{"width":100,"height":200,"name":"rose"},'+
 　　　　'{"width":100,"height":200,"name":"rose"},'+
 　　　　'{"width":100,"height":200,"name":"rose"},'+
 　　　　']' ;
　　</script>




三：JSON与JavaScript的区别

（1）：JSON仅仅是一种数据格式，JavaScript表示类的实例；

（2）：JSON可以跨平台数据传输，JavaScript不能传输；

（3）：JSON的表示：（1：键值对的方式，键必须加双引号；2：值不能是方法函数，不能是undefine或者NaN）

             JavaScript的表示：（1：键值对方式，键值不加引号；2：值可以是函数，对象，字符串，数字，boolean等）

（4）：JSON转换为对象方法：JSON.parse(JsonStr);

JavaScript转换为JSON的方法：JOSN.stringify(jsObj);

 

总结：JSON是JS下的一种数据格式，JSON是从属于JS，并且在处理JSON

数据时可直接使用JS内置API;

 

学习方法
不管再复杂项目，都是由简单的知识点构成的，复杂的项目搞不定，根本原因是简单的知识点没理解到位


类和对象的区分

类是抽象的，抽象的，代表以类事物，比如人类，猫类…
对象是具体的，实际的，代表一个具体的事物
类是对象的模板，对象是类的一个个体实例

类属性/成员属性

关于类属性的值，可以声明属性并赋值，也可以声明属性先不赋值如果不赋值，则属性的初始值是 null
类属性的值必须是一个直接的值 (常数)  ，不能是，表达式1+2 或函数 time()【资料说类属性可以是八种数据类型任意，不确定】
对象属性的值可以是任意值，包括对象，表达式，函数，类似于变量

类属性示例
class Person{
    public $name = '张三';
    // public $age;
    public $salary;
    public $isMarry;
    public $hobby;
    public $lover;
}

$p1 = new Person();
// 修改对象属性的值，可以是任意数据类型，包括表达式 函数
$p1->name = '至尊宝';
// 给对象添加 age属性
$p1->age = 20;
$p1->salary = 5667.2;
$p1->isMarry = false;
$p1->hobby = array('吃','喝','玩','乐');

$p2 = new Person();
$p2->name = '紫霞';
// 对象的属性值是另一个对象
$p1->lover = $p2;

// 输出 $p1 对象的爱好'玩'
echo $p1->hobby[2],'<br>';
// 输出 $p1 对象的情人的名字
echo $p1->lover->name,'<br>';

echo "<pre>";
var_dump($p1);
var_dump($p2);

类方法/成员方法

当我们需要让对象完成某个任务，就需要在类中定义函数，我们将类中的函数成为类方法
类方法前面可以有访问修饰符，若不写，默认为public
类方法的运行原理和普通函数完全一样，可以有参数、返回值等
php中同一作用域中函数不能重复定义 (JS可以) ，同一作用域中变量可以重复定义 (相当于修改变量)
类中的方法可以看理解"包含在类中的函数"，和全局的函数不是一回事，因此可以和类外部的函数重名
类方法中想访问类属性，必须用$this，如果不加，则理解为方法内部的一个局部变量
与函数一样，类方法如果如果省略了return，则返回值为NULL

类方法示例
class Person{
    public $name;
    public $age;
    public function sayHello(){
        echo 'hello','<br>';
    }
    public function getResult(){
        $result = 0;
        for ($i=0;$i<=10;$i++){
            $result += $i;
        }
        return $result;
    }
}

$p1 = new Person();
$p1->name = '木头人';
$p1->age = '10';

$p1->sayHello();    // hello
$res = $p1->getResult(); 
echo $res;			// 55

内存层面分析图


内存流程详解
栈区运行$p1=new Person代码

导致数据区生成一个对象内存，存放name=null age=null两个数据，同时在对象内存中分出一块区域存放函数(类方法)的地址
同时，会产生一个对象标识符#1，$p1指向#1，#1指向对象内存

栈区运行$p1->name='木头人'代码

p1先找到对象的标识符#1，然后通过标识符#1找到对象内存
然后修改对应的属性值

栈区运行$p1->sayHello()代码

p1先找到对象的标识符#1，然后通过标识符#1找到对象内存中的函数地址，再由函数地址到代码区寻找对应函数
若未找到，报错，若找到，则会在栈区开辟新的栈空间，在新的栈空间运行该函数，返回null，函数运行结束，该栈空间销毁

栈区运行$res = $p1->getResult()代码

p1先找到对象的标识符#1，然后通过标识符#1找到对象内存中的函数地址，再由函数地址到代码区寻找对应函数
若未找到，报错，若找到，则会在栈区开辟新的栈空间，在新的栈空间运行该函数，返回$result，函数运行结束，该栈空间销毁

类方法练习
class Person{
    public $name;
    public $age;
    // 类方法
    public function sayHello(){
        echo 'hello','<br>';
    }
    // 类方法
    public function getResult(){
        $result = 0;
        for ($i=0;$i<=10;$i++){
            $result += $i;
        }
        return $result;
    }
    // 类方法接收参数
    public function getResult2($num){
        return $num*3;
    }
    // 类方法直接调用系统函数
    public function getMax($n1,$n2,$n3){
        return max($n1,$n2,$n3);
    }
    // 类方法调用类方法和类属性
    public function show(){
        $this->sayHello();
        echo $this->age;
    }
}

$p1 = new Person();
$p1->name = '木头人';

$p1->sayHello();    // hello
echo $p1->getResult(),'<br>'; // 55
echo $p1->getResult2(5),'<br>'; // 15
echo $p1->getMax(1,2,3),'<br>'; // 3
$p1->show();    // hello null

对象运算符

对象名->属性名/方法名()，->就是对象运算符
->这种方式来访问非静态属性，静态属性则是用 ::

new 对象时

申请内存，生成对象(属性集合)
如果有构造函数，则执行
返回该对象地址
当我们需要看一个对象的情况时，我们可以通过 var_dump 来输出该对象



this绑定解析

对象调用类中的非静态方法时，该方法执行之前先完成一个绑定， this绑定到调用此方法的对象
对象调用类中的静态方法，不需要绑定this，因为，静态方法不属于哪个对象
静态调用类中所有类型的方法都不需要绑定this
this关键字只能在类的方法中使用，不能在类外部使用

class A{
    public function foo(){
        if (isset($this)){
            echo 'this is defined~',get_class($this),"\n";
        }else{
            echo 'this is not defined',"\n";
        }
    }

}

class B extends A{
    public function bar(){
        parent::foo();
    }
}

$b = new B();
$b->bar();  // bar()是非静态方法，$b绑定了bar()方法中的$this, bar(){parent::foo()-这里是静态调用，不操作$this},因此this is defined~B
B::bar();   // 静态调用 未绑定$this  this is not defined
B::foo();   // 静态调用 未绑定$this  this is not defined

构造函数  析构函数
构造函数 在对象产生时，自动执行，为对象成员变量赋初始值。

析构函数 在对象销毁时，自动执行。
class People {
    function __construct($name,$age) {    // 构造函数  这里也可以不传参，看需求
        echo '构造函数执行'.'<br>';
        $this->name = $name;              // 类属性
        $this->age = $age;
    }

    function fun(){                       // 类方法
        echo '类方法执行'.'<br>';
        echo $this->name.'<br>';          // 类方法中调用类属性
    }

    function __destruct() {               // 析构函数
        echo "析构函数执行".'<br>';
    }
}


$obj = new People('张三',18);             // 创建对象 并传参给构造函数
$obj->fun();                              // 对象调用类方法

// 打印结果
构造函数执行   类方法执行    张三    析构函数执行

析构函数与回收机制的深度解析
1. $a $b $c 分别指向不同内存空间(对象)，共有3个对象

unset($a)  未必销毁了对象，$a并不是对象，他只是一个变量名，指向对象。一个对象如果还有其他变量来引用，unset($a)并不会销毁，当引用为0时，对象才销毁。
$b = 2/null/ture 同理

// 横线下边 "析构函数执行X" 打印1次； 上边打印2次
// 有3个对象 故执行3次析构函数
class People{
    function __construct()
    {
        echo '构造函数执行' . '<br>';
    }

    function __destruct()
    {
        echo "析构函数执行X" . '<br>';
    }
}

// $a $b $c 分别指向不同内存空间(对象)
$a = new People();
$b = new People();
$c = new People();	// 这里共有3个对象 开辟了3个内存空间

unset($a);      // unset 销毁$a对象
$b = 2;         // $b重新赋值指向另一个内存空间  原内存空间不在有变量指向 因此内存回收，对象销毁
echo '<hr>';

// 最后一次销毁，此时php页面执行完毕，系统内存回收，$c对象此时销毁



2. $a $b $c 指向相同一个的内存空间(对象)，只有1个对象，$a $b $c是该对象的不同名字

$b=$c=$a;在对象中默认引用传值，指向同一个内存空间，在变量中是赋值传值
$a=new People(); $b=$c=$a; 这句话等同于 $b=$c=$a=new People();
参考 传值赋值 引用赋值 变量销毁 相关知识点

// 横线下边 "析构函数执行X" 打印1次 
// 只有1个对象 故只执行1次析构函数
class People
{
    function __destruct()
    {
        echo "析构函数执行X" . '<br>';
    }
}

// $a $b $c 指向相同一个的内存空间(对象)
$a = new People();
$b=$c=$a;   // 对象默认引用传值 $a $b $c指向同一个对象 开辟了1个内存空间(对象)，$a $b $c只是该对象的不同名字

unset($a);      // $b $c仍在指向该内存空间(对象)，因此对象不能销毁
echo '<hr>';

// 此时php页面执行完毕，系统内存回收，共有1个对象(该对象有3个不同的名字) 开辟了1个内存空间，因此析构函数此时执行1次


访问(权限)控制
public protected  private 注意权限控制以类为单位 类内 类外，而不是对象内外，更详细解释在继承处。

PHP 对属性或方法的访问控制，是通过在前面添加关键字 public(公有)，protected(受保护),  private(私有)来实现的。
public修饰的属性 / 方法，可以在任意位置调用
private和protected修饰的属性 / 方法，只能在类 {} 内调用，可以类内添加方法间接在 {} 外部调用
类属性必须定义为公有，受保护，私有之一。如果用 var 定义，则被视为公有。
类方法可以被定义为公有，私有或受保护。如果没有设置这些关键字，则该方法默认为公有。
建议养成好习惯，在属性和方法前面加上权限修饰符

// public（公有） private（私有）
class  Human{
    public $mood = '';
    private $money = '1000';

    private function secret(){
        echo '我喜欢xxx';
    }

    public function tellme(){
        echo $this->money,'<br>';  // 私有属性可以类内调用
        $this->secret();    // 私有方法可以类内调用
    }
}

$lisi = new Human();

$lisi->mood = 'happy';
echo $lisi->mood,'<br>';

// echo $lisi->money;   // $money是私有属性  无法在类{}外调用
// $lisi->secret();     // secret是私有方法  无法在类{}外调用

echo $lisi->tellme();   // tellme是公共的  可以在类{}外调用  间接访问到私有属性/方法

权限控制以类为单位(深刻理解)
权限控制的bug案例 (就是这样设计的 编程更简单)

在php中，并不是一对象为单位来控制权限的，而是以类为单位。
应该尽量的来调用对象的方法，而不应该直接把对象当参数传过去。

// 权限控制的bug案例
class Human{
    private $money = 1000;

    public function showMoney($people){
        echo $people->money,'<br>';
    }
    public function getMoney($people){
        echo $people->money-=100,'<br>';
    }
}

$zhangsan = new Human();
$lisi = new Human();

// 张三查看自己的银行卡 没毛病
$zhangsan->showMoney($zhangsan);
// 李四查看张三的银行卡 竟然可以
$lisi->showMoney($zhangsan);
// 李四从张三银行卡取钱 小偷！！取了100
$lisi->getMoney($zhangsan);

print_r($zhangsan);

/*
1.李四可以读取张三的钱，显然不合理
private $money 钱是私有属性，按道理"每个对象的钱，针对每个对象私有"，李四不应该有权直接引用
实质上，在php中，并不是一对象为单位来控制权限的，而是以类为单位。

2.为何这样设计？
类声明一次，而对象却可能非常多，以类为单位简化了判断模型

3.代码角度 
$lisi-->类-->Human()类    李四属于Human类
$lisi 调用的getMoney()函数 也在Human类中 因此李四可以调用

4.从其他语言来看
java c# 也存在此问题

5.总结
在php中，并不是一对象为单位来控制权限的，而是以类为单位。
应该尽量的来调用对象的方法，而不应该直接把对象当参数传过去。
*/

类与对象在内存中分布图

对象
JS就定义了一个对象数据结构 允许使用 key: value作为一组键值对

对象可以有多个key:value对组成
对象的使用

对象： 是一组k:v对的集合。
每一组k:v对，叫做对象的属性。
k表示对象的属性名
v表示对象的属性值。
每一组k:v对，使用逗号隔开，推荐一行一个k:v对
k最好符合变量的命名规范（属性名必须是字符串 " ‘’、’ '，但是只要属性名是符合变量命名规则，那么可以省略双引号或者单引号）
v是具体的数据,可以是任何类型的数据。

定义对象：

字面量 (推荐方式)

    var obj = {}; // 字面量定义对象

    // 定义对象并设置属性
    var obj1 = {
        name: "张三"
    };


构造函数

    var obj = new Object();


构造函数

    var obj = Object();

对象的属性操作：

读取属性

点语法

    var obj = {
        name: "张三"
    }
    console.log(obj.name); // 张三

方括号语法
    var obj = {
        name: "张三"
    }
    console.log(obj["name"]); // 张三


设置属性

点语法

    var obj = {
        name: "张三"
    }
    obj.age = 12;
    console.log(obj); // {name: "张三", age: 12}

方括号语法
    var obj = {
        name: "张三"
    }
    obj["age"] = 13;
    console.log(obj); // {name: "张三", age: 13}

注意： 点语法 是 方括号语法 的简写，但是属性名必须符合变量名规则，当不符合时，使用点语法会报错，只能使用方括号语法

删除属性

delete关键字，该关键字只能用来删除对象的属性，而不可以用来删除变量

    var obj = {
        name: "张三"
    }
    delete obj["name"];
    console.log(obj); // {} 

对象的循环遍历
语法：
for (var i in obj) {} 

实例：
    var obj = {
        name: "小明",
        age: 13,
        sex: "男",
        married: false
    }
    // 使用for in 循环遍历对象
    for (var k in obj) {
        // k 是对象的属性名 
        // obj[i] 是对象的属性值
    }

注意： obj.i 这种方式，是真的在读取 obj的 k 这个属性，而不是读取i变量所保存的值属性
方括号语法与点语法的区别


方括号语法

[] 之间是一个JS的执行环境，可以使用变量，表达式
[] 最终需要的是一个字符串，如果不是字符串，会转为字符串（调用toString方法）
[] 只要内容是字符串，不论是否符合变量命名规范，都可以成功



点语法

点语法，点什么，就是什么
点语法，必须符合变量的命名规范



    var a = "name";
    var obj = {
        name: "张三",
        a: 123
    }
    // 点语法：
    console.log(obj.name); // "张三"
    console.log(obj.a); // 123
    // 方括号语法：
    console.log(obj[a]); // "张三"
    console.log(obj["a"]); // 123

请实现函数copy，接收一个参数，参数是对象。该函数返回一个新对象，该新对象拥有与传递对象完全一致的属性和属性值。
        var obj = {
            name: "张三", 
            age: 22,
            sex: "男",
            married: false
        }
        function copy(){
            var obj1 = {};
            for (var key in obj){
                obj1[key] = obj[key];
            }
            console.log(obj1);
            console.log(obj === obj1); // false表示成功复制，但是两个是指向不同的地址，是两个不同的对象

        }
        copy(obj);


有数组如下  [{name: “张三”, year: 13}, {name: “李四”, year: 14}, {name: “王五”, year: 15}]

编写一段程序，得到 {张三: 13, 李四: 14, 王五: 15}
        var arr = [{name: "张三", year: 13}, {name: "李四", year: 14}, {"name": "王五", year: 15}];
        var arr1 = {};
        for (var key in arr){
            arr1[arr[key]["name"]] = arr[key]["year"];
        }
        console.log(arr1);



统计字符串中每个字符的个数
    var str = "abcd.acbabc.bababc  babc abdiawe你好，你们好！fioewafmklsdnvklsnaaeofihoai";
    var newStr = ""; // 用来存放经过去重之后的字符
    var obj = {};
    // 将原字符串中每一个字符都遍历出来
    for (var i = 0; i < str.length; i++){
        // console.log(str[i]);
        // 去重：判断遍历出来的字符与字符串newStr内的字符是否匹配，若匹配则不再存入newStr，-1表示不匹配
        if(newStr.indexOf(str[i]) == -1){
            // 将不匹配的（也就是newStr里面还没有的字符，但str里面有的字符）存入newStr
            newStr += str[i];
        }
    }
    // console.log(newStr);
    // 遍历newStr中每一个字符
    for (i = 0; i < newStr.length; i++){
        var count = 0; // 记录每一个字符在str中出现的次数，为什么要在这里定义变量并赋值为0呢，因为计算完上一个字符出现的次数后，下一个字符的出现次数要重新开始计算
        // 遍历str中每一个字符
        for (j = 0; j < str.length; j++){
            // 如果str中下标为j的字符与newStr中下标为i的字符匹配，出现的次数将+1
            if(newStr[i] === str[j]){
                count++;
            }
        }
        // console.log(newStr[i],count);
        // 将每一个不同的字符当做对象的一个属性名，将每一个不同的字符出现的次数当做对应的属性名的属性值
        obj[newStr[i]] = count;
    }
    console.log(obj);