面向对象基础和面向对象的三大特性之一:封装(20161024)

面向对象

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>无标题文档</title>
</head>

<body>
<?php

//定义数组
/*$attr = array();
echo $attr;*/
//$attr[0] = 1;
//索引数组
//$attr = array(1,2,3,4);
//关联数组
//$attr = array("code"=>"p001","name"=>"张三");

//二维数组
/*$attr = array(
    array(),
    array()
);*/

//数组遍历

//for循环遍历
/*for($i=0;$i<count($attr);$i++)
{
    $attr[$i];
}*/

//foreach遍历
/*foreach($attr as $v)
{
    $v;
}
foreach($attr as $k=>$v)
{
    $k;$v;
}*/

//$attr = array(1,2,3,4,5,2);
/*    放在别的语言里面foreach遍历数组和集合的情况下不能删除和添加内容
foreach($attr as $k=>$v)
{
    if($v==3)
    {
        unset($attr[$k]);//删除元素
    }
}
$attr = array_values($attr); //重新索引
var_dump($attr);*/

//each()和list()方法遍历
//var_dump(each($attr));
//list($a,$b)=$attr;  取前两个
//echo $b;

//指针遍历
//echo current($attr);
//echo key($attr);
//next($attr);
//prev($attr);
//end($attr);
//reset($attr);

//var_dump(in_array(9,$attr));//判断某一个值是否在数组里面存在
//var_dump(array_reverse($attr));//翻转数组
//var_dump(array_unique($attr)); //去重
//var_dump(array_count($attr));//取数组长度
//unset($arr[0])//删除数组的某个值
//array_values($arr)//重新索引
//$attr1 = array(9,10);
//var_dump(array_merge($attr,$attr1));//合并数组
//array_push($attr,10); //添加元素到数组,返回值不是新的数组
//var_dump($attr);
//$attr[]=11; //添加元素到数组
//var_dump($attr);

//面向对象
//面向过程
//$a = 10;
//$b = 15;
//echo $a+$b;

//面向对象
//1.什么叫做对象
//一切皆为对象
//2.什么叫做类
//由众多对象的抽象

//做类

/*class Ren
    //  class 类名(首字母大写)  class是用来定义类的
{
    //通过变量和方法来描述人类的特征

    //成员变量和成员方法总和起来叫做类的成员

    //成员变量    类里面的普通成员是属于对象的
    public $name;
    public $sex;

    //构造方法
    function __construct($n)    //统一的构造方法名
    {
        //$sex = $n; //错误    public $sex;里的$sex是类的、抽象的,这里的$sex是对象的、具体的
        //$this关键字,在类里面代表该对象,谁用就代表谁
        $this->sex =$n; //正确
    }

    //成员方法
    public function Speak()
    {
        echo "正在讲话";
    }
}

$r = new Ren("男"); //实例化对象    对对象初始化

//object    类,对象

var_dump($r);

$r1 = new Ren("女");
var_dump($r1);*/

//构造方法,始终存在,如果不写也是存在的

//var_dump($r);
//$r->name = "李四"; //赋值    其他语言都是点
//echo $r->name; //取值
//var_dump($r);
//$r->Speak();
//$r1 = new Ren(); //实例化对象
//$r1->name = "数据";

//var_dump($r==$r1);

//每一个对象都是一个独立的个体,都不一样

//访问修饰符
//public:代表公有的,在任何地方都可以访问
//protected:代表受保护的,只能在该类或该类的子类中访问
//private:代表私有的,只能在该类中访问

?>

</body>
</html>

1024morningtest.php

封装

研究一个类,要先看它的构造方法

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>无标题文档</title>
</head>

<body>
<?php

class Ren
{
    private $name;
    private $sex;
    private $age; //年龄必须在18-50之间

    function __construct($v)//构造方法
    {
        $this->sex = $v;
    }
    //魔术方法 以双下划线打头
    //魔术方法set
    function __set($n,$v)//成员变量的名称,成员变量的值
    {
        if($n=="age")
        {
            if($v>=18 && $v<=50)
            {
                $this->$n = $v;
            }
        }
        else
        {
            $this->$n = $v;
        }
    }

    //魔术方法get
    function __get($n)
    {
        return $this->$n;
    }

    /*//设置age的值
    function setage($a)
    {
        if($a>=18 && $a<=50)
        {
            $this->age = $a;
        }
    }
    //获取age的值
    function getage()
    {
        return $this->age;
    }*/

    function say()
    {
        echo "hello";
    }

    //析构方法    在对象释放的时候执行,自动调用;如果连接数据库的话,可以在里面写断开连接
    function __destruct()
    {
        echo "这是一个析构方法";
    }

    function __tostring()
    {
        return "这个类是人类";

        //可以用来输出对象,比如介绍功能
    }

}

$r = new Ren("男");

//$r->setage(20);
//echo $r->getage();

$r->say();
//$r->age = 30;        等价于    $r->__set("age",20);

//echo $r->age;

//$r->__get("age");

//$r->__set("age",20);

var_dump($r);

//构造方法:写法特殊,执行时间特殊

//OOP(面向对象)三大特性:封装,继承,多态

//封装的目的:为了让类更安全
//封装的做法:
//1.类里面的成员变量做为private
//2.使用成员方法来间接访问成员变量
//3.在该方法里面加限制条件

//php类里面不允许出现同名方法,但是

//函数重载
//在类里面写多个同名方法来实现不同功能
/*public string Show()
{
    return "显示";
}
public string Show(string a)
{
    return a+"显示";
}
public string Show(string a,string b)
{
    return a+b+"显示";
}
public string Show(int b)
{
    return b+"数字";
}*/

//1.函数名必须相同
//2.参数个数不同或参数类型不同

//例子:求两个圆之间的阴影面积
/*$maxr = 20;
$minr = 10;
$mj = 3.14*$maxr*$maxr - 3.14*$minr*$minr;

class Yuan
{
    //代表半径
    public $r;

    function __construct($n)
    {
        $this->r = $n;
    }

    //求面积的方法
    function MJ()
    {
        return 3.14*$this->r*$this->r;
    }
}

$r1 = new Yuan(20);
$r2 = new Yuan(10);

$mianji = $r1->MJ()-$r2->MJ();*/

//例子:计算器

$a = 10;
$b = 5;

$jia = $a+$b;
$jian = $a-$b;
$cheng = $a*$b;
$chu = $a/$b;

class jisuan
{
    public $a;
    public $b;

    function __construct($n,$m)
    {
        $this->a = $n;
        $this->b = $m;
    }

    function jia()
    {
        return $this->a+$this->b;
    }
    function jian()
    {
        return $this->a-$this->b;
    }
    function cheng()
    {
        return $this->a*$this->b;
    }
    function chu()
    {
        return $this->a/$this->b;
    }
    function quyu()
    {
        return $this->a%$this->b;
    }
}

$j = new jisuan(10,5);
$j->quyu();

?>

</body>
</html>

1024afternoontest.php

时间: 2025-01-02 19:17:02

面向对象基础和面向对象的三大特性之一:封装(20161024)的相关文章

java基础篇(一) ----- java面向对象的三大特性之封装

java面向对象的三大特性之封装:   封装(Encapsulation)是面向对象的一个重要特征,就是把对象的属性和操作(或服务)结合为一个独立的整体,并尽可能隐藏对象的内部实现细节. 通俗的讲所谓封装就是将属性和方法捆绑到一起,封装到一个对象中去, 形成一个不可分割的独立单位,以及尽可能隐藏对象的内部结构,也就是说,如果我们使用了封装技术的话,别人就只能用我们做出来的东西而看不见我们做的这个东西的内部结构了. 如果形容一个人(假设把人看做一个类),我们可以用姓名.年龄,性别等来描述,如果不封

java学习中,面向对象的三大特性:封装、继承、多态 以及 super关键字和方法的重写(java 学习中的小记录)

java学习中,面向对象的三大特性:封装.继承.多态 以及 super关键字和方法的重写(java 学习中的小记录) 作者:王可利(Star·星星) 封装     权限修饰符:public 公共的,private 私有的     封装的步骤:          1.使用private 修饰需要封装的成员变量.          2.提供一个公开的方法设置或者访问私有的属性              设置 通过set方法,命名格式:     set属性名();  属性的首字母要大写 访问 通过ge

Python 面向对象的三大特性:封装,继承,多态

# 面向对象的三大特性:封装,继承,多态 # 继承的影响:资源的继承,资源的使用,资源的覆盖,资源的累加 # 资源的继承,在Python中的继承是指能使用父类的资源,而不是说在子类也复制一份父类代码到子类中 class Animate: a = 1 # 公有的资源 _b = 2 # 受保护的资源 __c = 3 # 私有的资源 def t1(self): print("t1") def _t2(self): print("t2") def __t3(self): p

面向对象的三大特性之封装

# 面向对象的三大特性之封装 # 第一个层面的封装:类就是麻袋,这本身就是一种封装 # 第二个层面的封装:类中定义私有的,只在类内部使用,外部无法访问 # 约定一:任何以单下划线开头的名字都应该是内部的,私有的 # 约定二:双下划线开头的名字(如__name),外部无法直接访问,因为这种双下划线开头的名字已经被python转化为 _类名__name # 第三个层面的封装:明确区分内外,内部的实现逻辑,外部无法知晓,并且为封装到内部的逻辑提供一个访问接口给外部使用 # 如def getvalue(

Python 入门 之 面向对象的三大特性(封装 / 继承 / 多态)

Python 入门 之 面向对象的三大特性(封装 / 继承 / 多态) 1.面向对象的三大特性: (1)继承 ? 继承是一种创建新类的方式,在Python中,新建的类可以继承一个或多个父类,父类又可以称为基类或超类,新建的类称为派生类或子类. ? 在Python中实现继承非常简单,在声明类的时候,在类名后面添加一个小括号,就可以完成继承关系.单纯的从代码的层面上来看当两个类具有相同的功能或者特征的时候就可以使用继承.提取一个父类,这个父类中编写者两个类相同的部分,然后两个类分别去继承这个类就可以

(转载)OC学习篇之---类的三大特性:封装,继承,多态

之前的一片文章介绍了OC中类的初始化方法和点语法的使用,今天来继续学习OC中的类的三大特性,我们在学习Java的时候都知道,类有三大特性:继承,封装,多态,这个也是介绍类的时候,必须提到的话题,那么今天就来看一下OC中类的三大特性: 一.封装 学习过Java中类的同学可能都知道了,封装就是对类中的一些字段,方法进行保护,不被外界所访问到,有一种权限的控制功能,Java中有四种访问权限修饰符:public,default,protected,private,访问权限一次递减的,这样我们在定义类的时

【转】C#三大特性之 封装、继承、多态

C#三大特性之 封装.继承.多态 一.封装: 封装是实现面向对象程序设计的第一步,封装就是将数据或函数等集合在一个个的单元中(我们称之为类).被封装的对象通常被称为抽象数据类型.  封装的意义: 封装的意义在于保护或者防止代码(数据)被我们无意中破坏.在面向对象程序设计中数据被看作是一个中心的元素并且和使用它的函数结合的很密切,从而保护它不被其它的函数意外的修改. 封装提供了一个有效的途径来保护数据不被意外的破坏.相比我们将数据(用域来实现)在程序中定义为公用的(public)我们将它们(fie

转:java提高篇(一)-----理解java的三大特性之封装

转 CSDN https://blog.csdn.net/chenssy/article/details/12757911?utm_source=blogxgwz0 从大二接触java开始,到现在也差不多三个年头了.从最基础的HTML.CSS到最后的SSH自己都是一步一个脚印走出来的,其中开心过.失落过.寂寞过.虽然是半道出家但是经过自己的努力也算是完成了"学业".期间参加过培训机构,但是极其不喜欢那种培训方式,于是毅然的放弃了选择自学(可怜我出了6000块钱啊),虽然自学途中苦很多,

三大特性之---封装

三大特性之---封装 封装从字面上来理解就是包装的意思,专业点就是信息隐藏,是指利用抽象数据类型将数据和基于数据的操作封装在一起,使其构成一个不可分割的独立实体,数据被保护在抽象数据类型的内部,尽可能地隐藏内部的细节,只保留一些对外接口使之与外部发生联系.系统的其他对象只能通过包裹在数据外面的已经授权的操作来与这个封装的对象进行交流和交互.也就是说用户是无需知道对象内部的细节(当然也无从知道),但可以通过该对象对外的提供的接口来访问该对象. 对于封装而言,一个对象它所封装的是自己的属性和方法,所