Php inheritance details

Inheritance: This class is usually required. these classes have the same variables and functions as other existing classes. In fact, a general class is defined for all projects, it is a good practice to enrich the class to adapt to each specific project.

Inheritance:This class is usually required. these classes have the same variables and functions as other existing classes. In fact, a general class is defined for all projects, it is a good practice to constantly enrich the class to adapt to each specific project. to make this easier, the class can be extended from other classes, the extended or derived class has all the variables and functions of its base class (this is called "inheritance", but no one is dead) and contains the sections defined in all derived classes, the elements in the class cannot be reduced. that is to say, you cannot cancel any existing functions or variables. an extended class always depends on a separate base class. that is to say, it does not support multi-inheritance, use the keyword "extends" to extend a class.

2. Class test {
3.  
4. Public function _ construct (){
5. }
6.  
7. Public function name (){
8. $ This-> xname ('John ');
9. }
10.  
11. Private function showName ($ name ){
12. Echo 'my name in test is '. $ name;
13. }
14. }
15.  
16. Class extendTest extends test {
17.  
18. Public function _ construct (){
19. Parent: :__ construct ();
20. }
21.  
22. Private function showName ($ name ){
23. Echo 'my name in extendTest is '. $ name;
24. }
25. }
26.  
27. $ Test = new extendTest ();
28. $ Test-> name ();
29. ?>

The above example defines the class named Named_Cart, which has all the variables and functions of the Cart class, plus the additional variable $ owner and an additional function set_owner (). now, A shopping cart with a name can be created in a normal way and the owner of the shopping cart can be set and obtained. functions of the normal shopping cart class can still be used in the shopping cart class with a name:

2. $ Ncart = new Named_Cart; // create a shopping cart with a name.
3. $ Ncart-> set_owner ("kris"); // name the cart.
4. Print $ ncart-> owner; // output the name of the shopping cart owner.
5. $ Ncart-> add_item ("10", 1); // (functions inherited from the shopping cart class)
6. ?>

This can also be called the "parent-child" relationship. create a class and parent class, and use extends to create a new class based on the parent class: subclass, you can even use this new subclass to create another class based on this subclass.

Note:Classes can be used only after they are defined. if the class Named_Cart inherits the class Cart, you must first define the Cart class. if you need to create another Named_Cart class based on the Named_Cart class, you must first define the Named_Cart class, to put it simply, the sequence of class definitions is very important.

2. Class Person {
3. Protected $ name; // The permission protected by protected. it can be accessed by sub-classes, but cannot be accessed externally.
4. Protected $ age;
5. Protected $ sex;
6.  
7. Function _ construct ($ name, $ age, $ sex ){
8. $ This-> name = $ name; // when this is used,
9. $ This-> age = $ age;
10. $ This-> sex = $ sex;
11.  
12. Echo "###############";
13. }
14.  
15. Public function say (){
16. Echo "my name: {$ this-> name}, my age {$ this-> age }:, my gender: {$ this-> sex}
    ";
17. }
18.  
19. Protected function eat (){
20.  
21. Echo "wwwwwwwwwwwwwwwwwwwww
    ";
22.  
23. }
24.  
25. Function run (){
26.  
27. }
28. Protected $ name; // The permission protected by protected. it can be accessed by sub-classes, but cannot be accessed externally.
29. Protected $ age;
30. Protected $ sex;
31. }
32.  
33. // Inherit
34. Class Student extends Person {
35. Var $ school;
36.  
37. Function _ construct ($ name, $ age, $ sex, $ school ){
38. Parent: :__ construct (); // call the constructor of the parent class.
39. $ This-> school = $ school;
40. }
41.  
42. // Reload the say () method for extension
43. Protected function say () {// the parent class uses public. the permission of the subclass cannot be lower than that of the parent class, and the permission of the parent class can be the same.
44. // Person: say (); // call the say () method of the parent class
45. Parent: say (); // call the statement () method of the parent class. parent indicates the parent class name. it can also be called when the parent class name changes.
46.  
47. Echo "My school {$ this-> school}
    ";
48. }
49.  
50. Function study (){
51. Echo "{$ this-> name} is learning
    ";
52. }
53.  
54. }
55.  
56. $ S = new Student ("zhangsan", 23, "male ");
57. $ S-> say ();
58. $ S-> study ();
59. ?>

1. one of the three features of object-oriented

2. openness and scalability

3. added code reusability.

4. improved software maintainability

5. inheritance is to "extend" the parent class with sub-classes.

C ++ is multi-inheritance. the same class can have multiple parent classes.

PHP and JAVA belong to single inheritance, and the same class can only have one parent class

No matter how many inheritance or single inheritance, you can have multiple subclasses.

When you design two classes and have members that can be shared, you can use the shared content separately as a base class.

I. Application of class inheritance

1. declare a subclass and use the extends keyword to inherit (extend) a parent class

2. subclass can inherit all content from the parent class, including the member attribute method and constructor method..., which can be used in the subclass.

II. access type control

Although the subclass can inherit all content from the parent class, the private member can only be used in this class, and not in the subclass.

During encapsulation, the class can be accessed internally or used by subclass, but the class cannot be used externally, as long as the permission is set to protected

III. Methods for overloading parent classes in child classes

1. the subclass can declare the same method name as the parent class, that is, the subclass overwrites the method with the same name as the parent class.

2. extension of the subclass method to the parent class method

3. call the override method in the parent class in the subclass.

Use the parent class name: method name () parent: method name ()

4. Compile the constructor in the subclass. if the parent class also has constructor, you must call the constructor that is overwritten in the parent class once.

Note:The method that is overloaded in the subclass cannot be lower than the access permission in the parent class (the subclass can enlarge the permission, but cannot narrow down the permission ).