php study notes object-oriented

public public: this class, subclasses, and external objects can all call
protected: subclasses of this class can execute, external objects cannot call
private: only this class is executed, and neither subclasses nor external objects can be called
three major characteristics of object-oriented programming

1) closure

closeness can also be called information hiding . it is to separate the use and implementation of a class, leaving only limited interfaces (methods) to connect with the outside. for developers who use this class, they only need to know how to use this class, and do not need to care about how this class is implemented. doing so allows developers to better focus on other things, while also avoiding the inconvenience caused by interdependencies between programs.

2) inheritance

inheritance means that a derived class (subclass) automatically inherits the properties and methods in one or more base classes (parent classes), and can override or add new properties and methods. inheritance simplifies the creation of objects and classes and increases code reproducibility. inheritance is divided into single inheritance and multiple inheritance. php supports single inheritance, that is to say, a subclass has and has only one parent class.

3) polymorphism

polymorphism means that different objects of the same class can obtain different results using the same method. this technology is called polymorphism. polymorphism enhances software flexibility and reusability.

class definition

a class can contain its own constants, variables (called "properties") and functions (called "methods").
like many object-oriented languages, php also defines classes through the class keyword plus the class name. the format of the class is as follows:

the code is as follows:

<?php
  class myobject{
    //……
    }
?>

definition: birds of a feather flock together, and objects with similar characteristics are grouped into a class. the class defines these similar objects. has the same properties and methods. a class is a description of similar objects, called the definition of the class, which is the blueprint or prototype of the object of that class.

an object of a class is called an instance of the class. to create an instance of a class, the new keyword must be used.

<?php
//类的定义以关键字class开始，类的命名通常以每个单词第一个字母大写
    class nbaplayer{
        public $name = "jordan"; //定义属性
        public $height = "198cm";
        public $team = "bull";
        public $playernumber = "23";
        //定义方法
    public function run(){
        echo "running\n";
    }
    public function dribblr(){
        echo "dribbling\n";
    }
    public function pass(){
        echo "passing\n";
    }
}
    //类到对象的实例化
    //类的实例化为对象时使用关键字new，new之后紧跟类的名称和一对括号
    $jordan = new nbaplayer(); 
    //对象中的属性成员可以通过"->"符号来访问
    echo $jordan->name."\n";
    //对象中的成员方法可以通过"->"符号来访问
    $jordan->dribble();
    $jordan->run();
?>

member methods

functions in a class are called member methods. the only difference between functions and member methods is that functions implement an independent function, while member methods implement a behavior in the class and are part of the class.
let’s expand the myobject class above and add a member method to it. the code is as follows:

<?php
classmyobject{
   function getobjectname($name){
      echo "商品名称为：".$name;
   }
}
?>

the function of this method is to output the product name, which is passed in through the parameters of the method. .
a class is an abstract description, a collection of objects with similar functions. if you want to use the methods and variables in the class, you must first implement them into an entity, that is, an object.

class constants
since there are variables, of course there are also constants. a constant is a quantity that does not change and is a constant value. a well-known constant is pi. to define constants, use the keyword const, such as:
constpi=3.14159;

constructor

php 5 allows developers to define a method as a constructor in a class. classes with a constructor will call this method every time a new object is created, so it is very suitable for doing some initialization work before using the object.

destructor

<?php
//类的定义以关键字class开始，类的命名通常以每个单词第一个字母大写
    class nbaplayer{
        public $name = "jordan"; //定义属性
        public $height = "198cm";
        public $team = "bull";
        public $playernumber = "23";
        //构造函数，在对象被实例化的时候自动调用
        function __construct($name,$height,$weight,$team){
            echo "it is an  nbaplayer constructor\n";
            $this->name = $name;
            //$this是php里面的伪变量，表示对象自身。可以通过$this->的方式访问对象的属性和方法
            $this->height = $height;
            $this->weight = $weight;
            $this->team = $team;
        }
        //定义方法
    public function run(){
        echo "running\n";
    }
    public function dribblr(){
        echo "dribbling\n";
    }
    public function pass(){
        echo "passing\n";
    }
}
    //类到对象的实例化
    //类的实例化为对象时使用关键字new，new之后紧跟类的名称和一对括号
    $jordan = new nbaplayer("jordan","198cm","98kg","bull");   
    //对象中的属性成员可以通过"->"符号来访问
    echo $jordan->name."\n";
    //对象中的成员方法可以通过"->"符号来访问
    $jordan->dribble();
    $jordan->run();
    //每一次用new实例化对象的时候，都会用类名后面的参数列表调用构造函数
    $james = new nbaplayer("james","203cm","120kg","heat")
    echo $james->name."\n";
?>

the destructor occurs when all references to an object have been deleted or when the object is explicitly executed when destroyed.

object reference

<?php
//类的定义以关键字class开始，类的命名通常以每个单词第一个字母大写
    class NbaPlayer{
        public $name = "Jordan"; //定义属性
        public $height = "198cm";
        public $team = "Bull";
        public $playerNumber = "23";

        //构造函数，在对象被实例化的时候自动调用
        function __construct($name,$height,$weight,$team){
            echo "It is an  NbaPlayer constructor\n";
            $this->name = $name;
            //$this是PHP里面的伪变量，表示对象自身。可以通过$this->的方式访问对象的属性和方法
            $this->height = $height;
            $this->weight = $weight;
            $this->team = $team;
        }
        //析构函数，在程序执行结束的时候会自动调用
        //析构函数通常被用于清理程序使用的资源。比如程序使用了打印机，那么可以再析构函数里面释放打印机资源
        function __destruct(){
            echo "Destroying".$this->name."\n";
        }
        //定义方法
    public function run(){
        echo "Running\n";
    }
    public function dribblr(){
        echo "Dribbling\n";
    }
    public function pass(){
        echo "Passing\n";
    }
}
    //类到对象的实例化
    //类的实例化为对象时使用关键字new，new之后紧跟类的名称和一对括号
    $jordan = new NbaPlayer("Jordan","198cm","98kg","Bull");   
    //对象中的属性成员可以通过"->"符号来访问
    echo $jordan->name."\n";
    //对象中的成员方法可以通过"->"符号来访问
    $jordan->dribble();
    $jordan->run();
    //每一次用new实例化对象的时候，都会用类名后面的参数列表调用构造函数
    $james = new NbaPlayer("James","203cm","120kg","Heat")
    echo $james->name."\n";
    //对象的引用用于访问对象的属性和方法，$james,$james1和$james2都是对象的引用
    //$james和$james1是对象的两个独立引用
    //$james2是$james的影子，使用对象的同一个引用，任何一个赋值为null相当于删除了同一个引用
    $james1 = $james;
    $james2 = &$james
    $james = null;
    echo "from now on James will not be used.\n"
?>