demo1.php
<?php
//创建一个电脑类
class Computer {
//什么叫做类内，就是创建类的花括号内的范围叫做类内，其他地方则内外。
//public是最字段的公有化，这个字段类外即可访问，赋值和取值
public $_name;
}
$computer = new Computer();
$computer->_name = 'dell';
echo $computer->_name;
?>
demo2.php
<meta charset="UTF-8">
<?php
class Computer {
//private是私有化，即对字段进行封装的操作，类外无法访问，取值和赋值都不能操作
private $_name = '联想';
}
$computer = new Computer();
echo $computer->_name;
?>
demo3.php
<meta charset="UTF-8">
<?php
class Computer {
private $_name = '联想';
//这个时候我采用一个公共对外的方法来访问私有字段
//因为私有字段只能在类内访问，而对外的公共方法是类内的。
//更而公共方法又是公共的，所以类外又可访问。
public function _run() {
//字段在类内调用的时候必须是类->字段，而$_name只是一个普通变量而已。
//字段在类外调用的方法是对象->字段，而类内就必须使用Computer->_name
//但是在本类中，可以用一个关键字来代替Compouter，那就是$this
echo $this->_name;
}
}
$computer = new Computer();
$computer->_run();
?>
demo4.php
<?php
class Computer {
private $_name;
private $_model;
private $_cpu;
private $_keyboard;
private $_show;
private $_zb;
//必须写一个对内的入口，对私有字段进行赋值
public function setName($_name) {
//这里的$_name只是一个变量而已，参数而已
//$this->_name才是类的字段
$this->_name = $_name;
}
//必须写个对外的入口，才可以取到
public function getName() {
return $this->_name;
}
}
$computer = new Computer();
$computer->setName('dell');
echo $computer->getName();
?>
demo5.php
<meta charset="UTF-8">
<?php
class Computer {
private $_name;
private $_model;
private $_cpu;
//当类外的对象直接调用私有字段时，会跟着去检查是否有拦截器,
//如果直接对$_name进行赋值，那么__set()方法就会拦截住，就不会报错了。
//采用拦截器进行赋值和取值
//赋值
public function __set($_key,$_value) {
//那么$_key = '_name'，那么$_value = '联想';
//$this->_name = '联想'
//那么$_key = '_cpu'，那么$_value = '四核'
//$this->_cpu = '四核'
//那么$_key = '_model'，那么$_value = 'i7'
//$this->_model = 'i7'
$this->$_key = $_value;
}
//取值
public function __get($_key) {
return $this->$_key;
//如果$_key = '_name' 那么$this->_name;
//如果$_key = '_cpu' 那么$this->_cpu;
//如果$_key = '_model' 那么$this->_model;
}
}
$computer = new Computer();
$computer->_name = '联想';
$computer->_cpu = '四核';
$computer->_model = 'i7';
echo $computer->_name;
echo $computer->_cpu;
echo $computer->_model;
?>
demo6.php
<meta charset="UTF-8">
<?php
class Computer {
private $_name;
private $_model;
private $_cpu;
//__set()和__get()方法私有了，还是可以执行，是因为
//因为目前程序的指针已经在类内了。而类内可以执行封装的方法
//类内执行私有方法，不会出现任何错误。
//它只需要间接的拦截就可以了。拦截是在内类执行的。
//所白了，__set()和__get()是PHP内置的方法，具有一定的特殊性
public function __set($_key,$_value) {
$this->$_key = $_value;
}
public function __get($_key) {
return $this->$_key;
}
}
$computer = new Computer();
$computer->_name = '联想';
$computer->_cpu = '四核';
$computer->_model = 'i7';
echo $computer->_name;
echo $computer->_cpu;
echo $computer->_model;
?>
demo7.php
<?php
class Computer {
const NAME = 'DELL';
}
//常量的输出方法 类::常量
echo Computer::NAME;
?>
demo8.php
<?php
class Computer {
public $_count = 0;
public function _add() {
$this->_count++; //$count = $count +1 $count++
}
}
//做一个累计的效果
$computer1 = new Computer();
$computer1->_add();
$computer1->_add();
$computer1->_add();
echo $computer1->_count;
echo '<br />';
$computer2 = new Computer();
$computer2->_add();
$computer2->_add();
$computer2->_add();
echo $computer2->_count;
?>
demo9.php
<?php
class Computer {
public static $_count = 0;
public function _add() {
//如果是静态成员字段，那么就应该用self来调用，而不是$this
self::$_count++;
}
}
//echo Computer::$_count;
//做一个累计的效果
$computer1 = new Computer();
$computer1->_add();
$computer1->_add();
$computer1->_add();
echo Computer::$_count;
echo '<br />';
$computer2 = new Computer();
$computer2->_add();
$computer2->_add();
$computer2->_add();
echo Computer::$_count;
?>
demo10.php
<?php
class Computer {
public static $_count = 0;
public static function _run() {
self::$_count++;
}
}
Computer::_run();
Computer::_run();
Computer::_run();
Computer::_run();
echo Computer::$_count;
?>
demo11.php
<?php
class Computer {
}
$computer = new Computer();
echo ($computer instanceof Computer);
?>
demo12.php
<meta charset="UTF-8">
<?php
//这是父类，电脑类
class Computer {
public $_name = '联想';
public function _run() {
echo '联想在运行！';
}
}
//子类，笔记本电脑类
class NoteComputer extends Computer {
}
$notecomputer = new NoteComputer();
echo $notecomputer->_name;
$notecomputer->_run();
?>
demo13.php
<meta charset="UTF-8">
<?php
class Computer {
public $_name = '联想';
public function _run() {
echo '联想在运行！';
}
}
class NoteComputer extends Computer {
//我不需要父类的字段和方法，那么可以采用重写的方法覆盖掉父类的字段和方法
public $_name = 'dell';
public function _run() {
echo 'dell在运行！';
}
}
$notecomputer = new NoteComputer();
echo $notecomputer->_name;
$notecomputer->_run();
?>
demo14.php
<meta charset="UTF-8">
<?php
class Computer {
//私有化，但是无法被子类继承，这个时候就应该用受保护的修饰符来封装
protected $_name = '联想';
protected function _run() {
return '联想在运行！';
}
}
class NoteComputer extends Computer {
public function getTop() {
echo $this->_name;
echo $this->_run();
}
}
$notecomputer = new NoteComputer();
$notecomputer->getTop();
?>
demo15.php
<meta charset="UTF-8">
<?php
class Computer {
public $_name = '联想';
public function _run() {
return '联想在运行！';
}
}
class NoteComputer extends Computer {
//我子类已经覆盖了父类的字段和方法
//但是我又要调用父类的字段和方法,那怎么办呢？
public $_name = 'dell';
public function _run() {
echo 'dell在运行！';
echo parent::_run();
}
}
$notecomputer = new NoteComputer();
echo $notecomputer->_name;
$notecomputer->_run();
?>
demo16.php
<?php
//final如果加在类前面，表示这个类不能被继承
// final class Computer {
//
// }
class Computer {
//final如果加在方法前面，表示不能够重写此方法。
final public function _run() {
}
}
class NoteComputer extends Computer {
public function _run() {
}
}
?>
demo17.php
<meta charset="UTF-8">
<?php
//创建一个抽象类,只要在class前面加上abstract就是抽象类了
//抽象类不能够被实例化，就是创建对象
//只要类里面有一个抽象方法，那么这个类就必须是抽象类，类前面必须加上abstract
abstract class Computer {
public $_name = '联想';
//在抽象类里创建一个抽象方法
//抽象方法不能够实现方法体的内容
abstract public function _run();
//我在抽象类里能否创建一个普通方法
public function _run2() {
echo '我是父类的普通方法';
}
}
//类不能够实现多继承,只支持单继承。
//抽象类是给子类用来继承的，实现一种规范和资源的共享
class NoteComputer extends Computer {
//抽象类里的抽象方法，子类必须重写，不然会报错。
//抽象类里的普通方法不需要重写，子类会直接继承下来
public function _run() {
echo '我是子类的方法！';
}
}
$notecomputer = new NoteComputer();
$notecomputer->_run2();
echo $notecomputer->_name;
?>
demo18.php
<meta charset="UTF-8">
<?php
//到底应该用抽象类还是接口呢
//如果你要继承多个类的方法规范，那么就用接口好了。
//如果你要共享一个方法体内容，那么就用抽象类。
//创建一个接口
//接口也不能被实例化
//接口是为了规范实现它的子类，以达到统一的目的。也可以共享数据
interface Computer {
//成员字段必须是常量
const NAME = '联想';
//接口里的所有方法都是抽象方法，不能够写方法体
//并且接口的抽象方法不需要写abstract
public function _run();
public function _run2();
}
interface Computer2 {
public function _run3();
}
//子类继承接口的说话，叫做实现，接口可以多实现
class NoteComputer implements Computer,computer2 {
public function _run() {
echo '我重写了run';
}
public function _run2() {
echo '我重写了run2';
}
public function _run3() {
}
}
$notecomputer = new NoteComputer();
$notecomputer->_run();
//接口::常量
//echo Computer::NAME;
?>
demo19.php
<meta charset="UTF-8">
<?php
//什么叫做多态，字面意思，多种形态
//一个动作由不同的人去执行，而产生不同的效果或者结果，即为多态。
//一个人通过不同的状态去执行同一种动作，形成不同的结果，也可以称作为多态。
//园丁 剪 修理花草
//理发师 剪 理发
//总裁 剪 裁员
//人 笔记本 运行 win7开机了
//人 台式机 运行 xp开机了
//创建一个接口，来规范运行的方法
interface Computer {
public function version(); //这个方法表示采用什么电脑
public function work(); //这台电脑是怎么运行的
}
//创建一个笔记本类来实现接口
class NoteComputer implements Computer {
public function version() {
echo '笔记本';
}
public function work() {
echo '可以便携式运行win7';
}
}
//创建一个台式机的类来实现接口
class DesktopComputer implements Computer {
public function version() {
echo '台式机';
}
public function work() {
echo '在工作站运行XP';
}
}
//创建一个用户
class Person {
//创建一个方法来接受电脑（笔记本电脑，也可是台式电脑）
//怎么接受，将他们的对象传进来就OK啦。
public function _run($type) {
echo '这个人的';
$type->version();
$type->work();
}
}
//多态的原理，就是类都写好了，不要去修改他，只要在类外的调用参数的更改
//而最后的结果也会得到更改，那么这个就是多态。
//有一个接口，两个类，一个是笔记本的类，一个是台式机的类
//创建了笔记本
$notecomputer = new NoteComputer();
//创建台式机
$desktopcomputer = new DesktopComputer();
//创建一个人
$person = new Person();
//使用电脑
$person->_run($notecomputer); //这种传递，叫做对象引用的传递
?>
相关推荐
继承是面向对象的另一关键特性，它允许子类从父类继承属性和操作，从而实现代码重用和减少重复工作。继承可分为单继承（一个子类只有一个父类）和多继承（一个子类可以有多个父类），且具有传递性。多态性使得基类的...
《C++面向对象程序设计》是谭浩强教授编著的一本经典教材，它深入浅出地介绍了C++编程语言的面向对象特性。第二章主要涉及C++的基础知识，包括类与对象的概念、构造函数与析构函数的使用、封装与继承的基本原理，...
本资源集合是"李爱华"和"程磊"编写的《面向对象程序设计》一书第二章的C++语言基础案例源程序，涵盖了C++的基本要素，旨在帮助学习者通过实践理解C++的基础知识。 在第二章中，主要讨论了C++语言的基础，包括以下几...
在北大青鸟S2课程中，第二章主要讲解了如何使用Java来实现面向对象编程的基本概念和技术。 首先，我们来理解面向对象编程的三大基本概念：封装、继承和多态。 1. 封装：封装是将数据和操作数据的方法捆绑在一起，...
继承是面向对象编程的基本特性之一，继承使父类的代码得到重用，在继承父类提供的共同特性基础上添加新的代码，使编程不必一切都从头开始，有效提高了编程效率。继承可以发生在同一个层次上，也可以发生在不同层次上...
### Java面向对象高级特性详解 #### 一、静态特性（static） **静态修饰符static**在Java中扮演着至关重要的角色，它允许某些类成员在类级别而非对象级别上进行共享。具体而言： 1. **静态属性（类变量）**：这类...
Java面向对象编程是Java语言的核心特性，它基于面向对象编程思想，使得代码更易于理解和维护。孙卫琴老师的《深入浅出Java面向对象》是一本深受程序员喜爱的教材，其中的课后习题旨在帮助学生深入理解面向对象的原理...
《VC++6[1].0入门【第二章_面向对象程序设计的概念】》是一本针对初学者的编程书籍，旨在通过实例分析和实践教学，帮助读者掌握使用Visual C++进行可视化窗口应用程序开发的基础知识和技能。书中涵盖了面向对象程序...
根据提供的文件标题、描述以及部分无法识别的内容，我们可以聚焦于《C++面向对象程序设计》这本书，特别是由谭浩强编著的第三版，并且关注的是该书第1-14章的课后习题答案。 ### C++面向对象程序设计概述 C++是一...
### 第八章 面向对象 #### 一、面向对象的基本概念 面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它使用“对象”来设计软件。面向对象的核心思想是将数据和处理这些数据的方法封装成一个...
这些语言提供了支持面向对象特性的语法结构，如类定义、对象创建、继承、多态等。 四、面向对象方法的应用 面向对象方法广泛应用于各种软件开发中，包括操作系统、数据库管理系统、图形用户界面、游戏开发等。它的...
面向对象编程是现代软件开发中的核心概念，易语言作为一款中国本土的编程语言，也采用了这一编程范式。本章将深入探讨面向对象的概念及其在易语言中的应用。 首先，对象是面向对象编程的核心概念。对象是现实世界中...
在面向对象编程中，**类**是一种定义通用特性的抽象模型，它描述了一组具有相同属性和行为的对象。例如，在本例中提到的“汽车”类就定义了所有汽车的共性特征，比如车门数量、变速箱配置等。而**对象**则是类的具体...
《面向对象程序设计:C++语言描述(原书第2版)》内容丰富，结构合理，写作风格严谨，深刻地论述了c++语言的面向对象编程的各种技术，主要内容包括:面向对象编程方法、c++语言的各种特性、stl、c++输入/输出流、mfc等。...
- **第二章：面向对象编程简介**：解释OOP的基本概念和原则。 - **第三章：JavaScript中的类和对象**：详细介绍如何使用JavaScript创建类和对象。 - **第四章：继承**：探讨JavaScript中实现继承的不同方式。 - **第...
在本教程中，我们将深入探讨PHP5的面向对象特性，这是继第一章之后的进一步学习，主要聚焦于PHP5面向对象编程的高级概念。面向对象编程（Object-Oriented Programming，OOP）是一种软件开发方法，它以对象为基本单位...
面向对象是一种编程范式，以对象为核心，通过封装、继承和多态三大特性来组织和设计程序。对象是由数据（属性）和操作这些数据的方法（行为）组成的，它们之间通过消息传递实现通信。 在面向对象分析（OOA）阶段，...
总的来说，“面向对象程序设计与C++语言”是一门深入学习编程思维和C++特性的课程，适合初学者逐步掌握面向对象编程的精髓。通过仔细研究和实践，可以提高编程技能，为未来更复杂的软件开发打下坚实基础。在学习过程...