面向对象的基本概念,面向对象编程,oop,面向对象,面向对象的分析,面向对象的设计,面向对象的编程,什么是类。
类,属性和方法,类,对象,面向对象编程的三大特点。特点,封装性,继承性,多态性。
封装性,也可以称为信息隐藏。
继承性就是派生类(子类)自动继承一个或多个基类(父类)中的属性与方法,并可以重写或添加新的属性或方法。
多态性是指同一个类的不同对象,使用同一个方法可以获得不同的结果,这种技术称为多态性。
类的定义,成员方法,类的实例化,成员变量,类常量,构造方法和析构方法,继承和多态的实现,数据的隐藏,静态变量。
类的定义:
<?php
class SpoObject{ //定义类
//…
}
?>
成员方法:
<?php
class SportObject{
function beatBasketball()($name,$height,$avoirdupois,$age,$sex){ //声明成员方法
echo "姓名:".$name; //方法实现的功能
}
}
?>
类的实例化:
对象名 -> 成员方法
成员变量
类中的变量,也称为成员变量
关键字 成员变量名
对象名 -> 成员变量
类常量
常量就是不会改变的量,是一个恒值。
定义常量使用关键字const
输出格式:
类名::常量名
构造方法和析构方法
void __construct([mixed args [,…]])
void __destruct ( void )
示例:
<!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=gb2312" />
<title>成员变量</title>
<style type="text/css">
<!--
body,td,th {
font-size: 12px;
}
body {
margin-left: 10px;
margin-top: 10px;
margin-right: 10px;
margin-bottom: 10px;
}
-->
</style></head>
<body>
<?php
class SportObject{
public $name; //定义成员变量
public $height; //定义成员变量
public $avoirdupois; //定义成员变量
public function bootFootBall($name,$height,$avoirdupois){ //声明成员方法
$this->name=$name;
$this->height=$height;
$this->avoirdupois=$avoirdupois;
if($this->height<185 and $this->avoirdupois<85){
return $this->name.",符合踢足球的要求!"; //方法实现的功能
}else{
return $this->name.",不符合踢足球的要求!"; //方法实现的功能
}
}
}
$sport=new SportObject(); //实例化类,并传递参数
echo $sport->bootFootBall('1','185','80'); //执行类中的方法
?>
</body>
</html>
<!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=gb2312" />
<title>成员方法</title>
<style type="text/css">
<!--
body,td,th {
font-size: 12px;
}
body {
margin-left: 10px;
margin-top: 10px;
margin-right: 10px;
margin-bottom: 10px;
}
-->
</style></head>
<body>
<?php
class SportObject{
function beatBasketball($name,$height,$avoirdupois,$age,$sex){ //声明成员方法
if($height>180 and $avoirdupois<=100){
return $name.",符合打篮球的要求!"; //方法实现的功能
}else{
return $name.",不符合打篮球的要求!"; //方法实现的功能
}
}
}
$sport=new SportObject();
echo $sport->beatBasketball('1','185','80','20周岁','男');
?>
</body>
</html>
<!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=gb2312" />
<title>常量</title>
<style type="text/css">
<!--
body,td,th {
font-size: 12px;
}
body {
margin-left: 10px;
margin-top: 10px;
margin-right: 10px;
margin-bottom: 10px;
}
-->
</style></head>
<body>
<?php
class SportObject{
const BOOK_TYPE = '计算机图书';
public $object_name; //图书名称
function setObjectName($name){ //声明方法setObjectName()
$this -> object_name = $name; //设置成员变量值
}
function getObjectName(){ //声明方法getObjectName()
return $this -> object_name;
}
}
$c_book = new SportObject(); //实例化对象
$c_book -> setObjectName("PHP类"); //调用方法setObjectName
echo SportObject::BOOK_TYPE."->"; //输出常量BOOK_TYPE
echo $c_book -> getObjectName(); //调用方法getObjectName
?>
</body>
</html>
<!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=gb2312" />
<title>构造方法</title>
<style type="text/css">
<!--
body,td,th {
font-size: 12px;
}
body {
margin-left: 10px;
margin-top: 10px;
margin-right: 10px;
margin-bottom: 10px;
}
-->
</style></head>
<body>
<?php
class SportObject{
public $name; //定义成员变量
public $height; //定义成员变量
public $avoirdupois; //定义成员变量
public $age; //定义成员变量
public $sex; //定义成员变量
public function __construct($name,$height,$avoirdupois,$age,$sex){ //定义构造方法
$this->name=$name; //为成员变量赋值
$this->height=$height; //为成员变量赋值
$this->avoirdupois=$avoirdupois; //为成员变量赋值
$this->age=$age; //为成员变量赋值
$this->sex=$sex; //为成员变量赋值
}
public function bootFootBall(){ //声明成员方法
if($this->height<185 and $this->avoirdupois<85){
return $this->name.",符合踢足球的要求!"; //方法实现的功能
}else{
return $this->name.",不符合踢足球的要求!"; //方法实现的功能
}
}
}
$sport=new SportObject('1','185','80','20','男'); //实例化类,并传递参数
echo $sport->bootFootBall(); //执行类中的方法
?>
</body>
</html>
析构方法,是对象被销毁时被调用的,作用是释放内存。
void __destruct ( void )
<!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=gb2312" />
<title>析构方法</title>
</head>
<body>
<?php
class SportObject{
public $name; //定义成员变量
public $height; //定义成员变量
public $avoirdupois; //定义成员变量
public $age; //定义成员变量
public $sex; //定义成员变量
public function __construct($name,$height,$avoirdupois,$age,$sex){ //定义构造方法
$this->name=$name; //为成员变量赋值
$this->height=$height; //为成员变量赋值
$this->avoirdupois=$avoirdupois; //为成员变量赋值
$this->age=$age; //为成员变量赋值
$this->sex=$sex; //为成员变量赋值
}
public function bootFootBall(){ //声明成员方法
if($this->height<185 and $this->avoirdupois<85){
return $this->name.",符合踢足球的要求!"; //方法实现的功能
}else{
return $this->name.",不符合踢足球的要求!"; //方法实现的功能
}
}
function __destruct(){
echo "<p><b>对象被销毁,调用析构函数。</b></p>";
}
}
$sport=new SportObject('1','185','80','20','男'); //实例化类,并传递参数
//unset($sport);
?>
</body>
</html>
继承和多态的实现
所有成员变量和方法
构造函数
先调用子类中的方法
去调用父类中的构造方法
class subClass extends superClass{
…
}
多态存在两种形式:覆盖和重载。
<!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=gb2312" />
<title>继承的实现</title>
<style type="text/css">
</head>
<body>
<?php
/* 父类 */
class SportObject{
public $name; //定义姓名成员变量
public $age; //定义年龄成员变量
public $avoirdupois; //定义体重成员变量
public $sex; //定义性别成员变量
public function __construct($name,$age,$avoirdupois,$sex){ //定义构造方法
$this->name=$name; //为成员变量赋值
$this->age=$age; //为成员变量赋值
$this->avoirdupois=$avoirdupois; //为成员变量赋值
$this->sex=$sex; //为成员变量赋值
}
function showMe(){ //定义方法
echo '这句话不会显示。';
}
}
/* 子类BeatBasketBall */
class BeatBasketBall extends SportObject{ //定义子类,继承父类
public $height; //定义身高成员变量
function __construct($name,$height){ //定义构造方法
$this -> height = $height; //为成员变量赋值
$this -> name = $name; //为成员变量赋值
}
function showMe(){ //定义方法
if($this->height>185){
return $this->name.",符合打篮球的要求!"; //方法实现的功能
}else{
return $this->name.",不符合打篮球的要求!"; //方法实现的功能
}
}
}
/* 子类WeightLifting */
class WeightLifting extends SportObject{ //继承父类
function showMe(){ //定义方法
if($this->avoirdupois<85){
return $this->name.",符合举重的要求!"; //方法实现的功能
}else{
return $this->name.",不符合举重的要求!"; //方法实现的功能
}
}
}
//实例化对象
$beatbasketball = new BeatBasketBall('','190'); //实例化子类
$weightlifting = new WeightLifting('','185','80','20','男');
echo $beatbasketball->showMe()."<br>"; //输出结果
echo $weightlifting->showMe()."<br>";
?>
</body>
</html>
继承的实现
<!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=gb2312" />
<title>继承的实现</title>
<style type="text/css">
</head>
<body>
<?php
/* 父类 */
class SportObject{
public $name; //定义姓名成员变量
public $age; //定义年龄成员变量
public $avoirdupois; //定义体重成员变量
public $sex; //定义性别成员变量
public function __construct($name,$age,$avoirdupois,$sex){ //定义构造方法
$this->name=$name; //为成员变量赋值
$this->age=$age; //为成员变量赋值
$this->avoirdupois=$avoirdupois; //为成员变量赋值
$this->sex=$sex; //为成员变量赋值
}
function showMe(){ //定义方法
echo '这句话不会显示。';
}
}
/* 子类BeatBasketBall */
class BeatBasketBall extends SportObject{ //定义子类,继承父类
public $height; //定义身高成员变量
function __construct($name,$height){ //定义构造方法
$this -> height = $height; //为成员变量赋值
$this -> name = $name; //为成员变量赋值
}
function showMe(){ //定义方法
if($this->height>185){
return $this->name.",符合打篮球的要求!"; //方法实现的功能
}else{
return $this->name.",不符合打篮球的要求!"; //方法实现的功能
}
}
}
/* 子类WeightLifting */
class WeightLifting extends SportObject{ //继承父类
function showMe(){ //定义方法
if($this->avoirdupois<85){
return $this->name.",符合举重的要求!"; //方法实现的功能
}else{
return $this->name.",不符合举重的要求!"; //方法实现的功能
}
}
}
//实例化对象
$beatbasketball = new BeatBasketBall('','190'); //实例化子类
$weightlifting = new WeightLifting('','185','80','20','男');
echo $beatbasketball->showMe()."<br>"; //输出结果
echo $weightlifting->showMe()."<br>";
?>
</body>
</html>
重载:
传递的参数个数不同,调用不同的方法,返回不同的值。
<?php
class C{
function __call($name,$num){ //调用不存在的方法
echo "方法名称:" . $name . "<p>"; //输出方法名
echo "参数存在个数:" . count($num) . "<p>"; //输出参数个数
if (count($num) == 1){ //根据参数个数调用不同的方法
echo $this->list1($a);
}
if (count($num) == 2){ //根据参数个数调用不同的方法
echo $this->list2($a,$b);
}
}
public function list1($a){ //定义方法
return "这是list1函数";
}
public function list2($a,$b){ //定义方法
return "这是list2函数";
}
}
$a = new C; //类的实例化
$a->listshow(1,2); //调用方法,传递参数
?>
关键字::变量名/常量名/方法名
<!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=gb2312" />
<title>伪变量$this</title>
</head>
<body>
<?php
class example{
function exam(){
if(isset($this)){
echo '$this的值为:'.get_class($this);
}else{
echo '$this未定义';
}
}
}
$class_name = new example();
$class_name->exam();
?>
</body>
</html>
<!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=gb2312" />
<title>“::”操作符</title>
</head>
<body>
<?php
class Book{
const NAME = 'computer'; //常量NAME
function __construct(){ //构造方法
echo '本月图书类冠军为:'.Book::NAME.' '; //输出默认值
}
}
class l_book extends Book{ //Book类的子类
const NAME = 'foreign language'; //声明常量
function __construct(){ //子类的构造方法
parent::__construct(); //调用父类的构造方法
echo '本月图书类冠军为:'.self::NAME.' '; //输出本类中的默认值
}
}
$obj = new l_book(); //实例化对象
?>
</body>
</html>
parent: 可以调用父类中的成员变量,成员方法和常量。
self:可以调用当前类中的静态成员和常量。
类名:可以调用本类中的变量,常量和方法。
数据隐藏
public(公共成员)
private(私有成员)
protected(保护成员)
public, private, protected, static, final
静态变量(方法)
关键字::静态成员
<!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=gb2312" />
<title>private关键字</title>
</head>
<body>
<?php
class Book{
private $name = 'computer'; //声明私有变量$name
public function setName($name){ //设置私有变量
$this -> name = $name;
}
public function getName(){ //读取私有变量
return $this -> name;
}
}
class LBook extends Book{ //Book类的子类
}
$lbook = new LBook(); //实例化对象
echo '正确操作私有变量的方法:';
$lbook -> setName("PHP"); //对私有变量进行操作
echo $lbook -> getName();
echo '<br>直接操作私有变量的结果:'; //对私有变量进行操作
echo Book::$name;
?>
</body>
</html>
private只能在所属类的内部被调和修改,不可以在类外被访问。
protected修饰的类成员,可以在本类和子类中被调用,其他地方不可以被调用。
<!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=gb2312" />
<title>protected关键字</title>
</head>
<body>
<?php
class Book{
protected $name = 'computer'; //声明保护变量$name
}
class LBook extends Book{ //Book类的子类
public function showMe(){
echo '对于protected修饰的变量,在子类中是可以直接调用的。如:$name = '.$this -> name;
}
}
$lbook = new LBook(); //实例化对象
$lbook -> showMe();
echo '<p>但在其他的地方是不可以调用的,否则:'; //对私有变量进行操作
$lbook -> name = 'history';
?>
</body>
</html>
<!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=gb2312" />
<title>protected关键字</title>
</head>
<body>
<?php
class Book{
protected $name = 'computer'; //声明保护变量$name
}
class LBook extends Book{ //Book类的子类
public function showMe(){
echo '对于protected修饰的变量,在子类中是可以直接调用的。如:$name = '.$this -> name;
}
}
$lbook = new LBook(); //实例化对象
$lbook -> showMe();
echo '<p>但在其他的地方是不可以调用的,否则:'; //对私有变量进行操作
$lbook -> name = '会报错,这里就错了';
?>
</body>
</html>
静态变量:
关键字::静态成员
self,在类内部调用 静态成员所使用
在静态方法中,只能调用静态变量,不能调用普通变量,而普通方法可以调用静态变量。
对象被销毁后,仍然保存被修改的静态数据。
<!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=gb2312" />
<title>静态变量的使用</title>
</head>
<body>
<?php
class Book{ //Book类
static $num = 0; //声明一个静态变量$num,初值为0
public function showMe(){ //申明一个方法
echo '您是第'.self::$num.'位访客'; //输出静态变量
self::$num++; //将静态变量加1
}
}
$book1 = new Book(); //实例化对象$book1
$book1 -> showMe(); //调用showMe()方法
echo "<br>";
$book2 = new Book(); //实例化对象$book2;
$book2 -> showMe(); //再次调用showMe()方法
echo "<br>";
echo '您是第'.Book::$num.'为访客'; //直接使用类名调用静态变量
?>
</body>
</html>
运行效果是:
您是第0位访客
您是第1位访客
您是第2位访客
对象的高级应用
final关键字,抽象类,接口的使用,克隆对象,对象比较,对象类型检测,魔术方法。
不可以被继承,不能有子类
final class class_name{
//…
}
final function method_name() 不可以重写和覆盖
<!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=gb2312" />
<title>final类</title>
></head>
<body>
<?php
final class SportObject{
function __construct(){
echo '不能被继承,不能有子类';
}
}
class MyBook extends SportObject{
static function exam(){
echo "会报错的";
}
}
MyBook::exam();
?>
</body>
</html><
请发表评论