PHP study notes - object-oriented_php basics

Object-oriented is a computer programming architecture that is more flexible and scalable than process-oriented editing. Here I would like to remind beginners: If you want to go further than others on the road of programming, you must master object-oriented programming technology.

public Public: this class, subclasses, and external objects can all call
protected: subclasses of this class can be executed, external objects cannot call
private: only This class can be 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 ones. 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 refers to the fact 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.

Definition of class

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:

Copy code The code is as follows:

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

Definition: Birds of a feather flock together, and objects with similar characteristics are grouped together Within a class, a class defines the same properties and methods that these similar objects have. 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.

The object of a class is called an instance of the class. To create an instance of a class, the new keyword must be used.
001ZpQGYty6MeYnSNUh25&690

##Copy code The code is as follows:

<?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 method

The function in the class is 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:

Copy code 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 will also be 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.

Copy code The code is as follows:

<?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";
?>

Destructor

Copy code The code is as follows:

<?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";

    //通过把变量设为null，可以触发析构函数的调用
    //当对象不再使用的时候会触发析构函数
    $james = null;
    echo "from now on James will not be used.\n"
?>

The destructor will be executed when all references to an object are deleted or when the object is explicitly destroyed.

Object reference

Copy code The code is as follows:

<?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"
?>

Related recommendations:

PHP object-oriented inheritance constructor

PHP object-oriented this binding detailed explanation

PHP object-oriented use of some keywords

The above is the detailed content of PHP study notes - object-oriented_php basics. For more information, please follow other related articles on the PHP Chinese website!