精华内容
下载资源
问答
  • 面向对象编程语言是一个独立程序单位,它应该有一个类名并包括属性说明和操作说明两个主要部分。1、类的定义:i. 类的关键字定义使用class1.定义一个空Class Person{};2.定义一个有成员属性和操作的类...

    类的概念:类是具有相同属性和操作的一组对象的集合。它为属于该类的所有对象提供了统一的抽象描述,其内部包括属性和操作两个主要部分。在面向对象的编程语言中,类是一个独立的程序单位,它应该有一个类名并包括属性说明和操作说明两个主要部分。

    1、类的定义:

    i. 类的关键字定义使用class

    1.定义一个空类

    Class Person{};

    2.定义一个有成员属性和操作的类

    Class Person{

    成员属性……..

    操    作……..

    }

    3.定义一个不能被继承的类,使用final关键字

    Final class Person{

    成员属性……..

    操    作……..

    }

    4.注意:final关键字不能用来修饰成员属性 ,只能修饰类和方法(final方法后面介绍)

    5.这里举一个带有final的class

    定义一个final的类FinalClass,包含一个公共函数

    final class FinalClass {

    public function ffun() {

    echo “本类为final类”;

    }

    }

    定义一个类ChildFinalClass 并继承FinalClass 类

    class ChildFinalClass extends FinalClass {

    public function fchildfun() {

    echo ‘本类继承final类FinalClass ’;

    }

    }

    这样当执行以上命令的时候系统会提示

    Fatal error: Class ChildFinalClass may not inherit from final class (FinalClass)

    证明由final关键字定义的class是不可以被子类继承的

    2、类中成员属性的定义

    i. 成员属性就是对该类定义的一些变量属性,那人作为一个类来说,人都有一对眼睛(正常的啊,二郎神除外),一张嘴,两个耳朵,等这样的一些固定的用来描述或表现某种事物的专有名词称为成员属性

    ii. 类中成员属性的声明使用的关键字

    iii. 常见成员属性声明是由关以下键字

    public,var,protected,private开头的,然后跟一个变量来组成的。还有一些成员属性包括,静态static,常量const.

    Public: 表示全局的,类内部外部子类都可以访问

    Var:     php 5 版本中会认为这个成员属性为public类型的属性

    protected 表示受保护的,只有本类或子类或父类中可以访问

    private

    表示私有的,只有本类内部可以使用

    Static:    1)静态的属性,

    2)用static修饰的成员属性可以被同一个类的所有对象共享

    3) 静态的数据是在类第一次被加载的时候就存在了内存中的数据段中(初始化静态段)

    4)类中使用self::成员属性名

    5)类外  类名::成员属性名

    Const:   1)类中常量属性,在类中声明常量必须使用const

    2)类中使用  self::成员属性名

    3)类外使用  类名::成员属性名

    注意:属性中的变量可以初始化,但是初始化的值必须是常数,这里的常数是指php脚本在编译阶段时就为常数,而不是在编译阶段之后在运行阶段运算出的常数。例如,不能包含任何运算符,不能是任何变量,不能是一个函数等。

    iv. 成员属性的调用方式:

    在类的成员方法里面,可以通过 $this->property(property是属性名字)这种方式来访问类的属性、 方法,但是要访问类的静态属性或者在静态方法里面却不能使用,而是使用 self::$property。 在类的非静态方法里面可以使用伪变量 $this,这个伪变量是调用该方法的实例化对象引用。

    接下来用代码对上面的内容做一下解释:

    class FinalClass {

    //static $a = strTolower();

    //这种写法错误

    //const  A = 1+2;              //这种写法错误

    //public $name = 123+456;

    //这种写法错误

    static $a = ‘$a’;

    const  A = ‘A’;

    public $name = ‘凤姐’;

    protected $sex = ‘男+女’;

    private $age = 23;

    }

    class ChildFinalClass extends FinalClass{

    public function fchildfun(){

    echo ‘ChildFinalClass类中ChildFinalClass::$a->’.ChildFinalClass::$a.”


    ”;

    Echo ‘ChildFinalClass类中ChildFinalClass::A->’.ChildFinalClass::A.”


    ”;

    echo ‘大家好,我叫’.$this->name.”


    ”;

    echo ‘我是:’.$this->sex.’生


    ’;

    echo ‘我今年:’.$this->age.'


    ’;

    //由于age是私有的成员属性,所以在这里将不会被调用,将提示没有定义此属性在ChildFinalClass类中。

    }

    }

    $obj = new ChildFinalClass();

    $obj->fchildfun();

    3、类中操作的定义

    i. 我本人一般喜欢叫操作为成员方法,以下我会叫操作为方法其实都是一样的

    ii. 成员方法的定义:成员方法就是对该类定义的一些函数方法,比如拿这个类来例句例子,人能吃饭,能跑步,能敲代码,这就是成员方法。也就是可以做一些可执行性的动作我们理解为成员方法

    iii. 成员方法的访问和成员属性一样可以参照上面成员属性的访问介绍。

    iv. 成员方法和成员属性一样也包括public,protected,private,static,final并且作用域也是一样的,接下来举一些例子供大家参考和理解。

    v. 静态的成员方法只能访问静态的成员属性和成员方法,并且类内部访问静态方法可以使用self::静态方法(),  类外部访问使用类名::静态方法()

    1. 自定义方法:

    class FinalClass {

    static $a = ‘$a’;

    const  A = ‘A’;

    public $name = ‘凤姐’;

    protected $sex = ‘男+女’;

    private $age = 23;

    //定义一个公共方法

    public function publickfun(){

    echo ‘FinalClass类中self::$a->’.self::$a.”


    ”;

    echo “FinalClass类中self::A->”.self::A.”


    ”;

    echo ‘大家好,我叫:’.$this->name.”


    ”;

    echo ‘我是:’.$this->sex.’生


    ’;

    echo ‘我今年:’.$this->age.'


    ’;

    }

    //定义一个受保护的方法

    protected function protectedfun(){

    echo ‘FinalClass类中self::$a->’.self::$a.”


    ”;

    echo “FinalClass类中self::A->”.self::A.”


    ”;

    echo ‘大家好,我叫:’.$this->name.”


    ”;

    echo ‘我是:’.$this->sex.’生


    ’;

    echo ‘我今年:’.$this->age.'


    ’;

    }

    //定义一个私用方法

    private function privatefun(){

    echo ‘FinalClass类中self::$a->’.self::$a.”


    ”;

    echo “FinalClass类中self::A->”.self::A.”


    ”;

    echo ‘大家好,我叫:’.$this->name.”


    ”;

    echo ‘我是:’.$this->sex.’生


    ’;

    echo ‘我今年:’.$this->age.'


    ’;

    }

    }

    class ChildFinalClass extends FinalClass{

    public function fchildfun(){

    echo ‘ChildFinalClass类中ChildFinalClass::$a->’.ChildFinalClass::$a.”


    ”;

    Echo ‘ChildFinalClass类中ChildFinalClass::A->’.ChildFinalClass::A.”


    ”;

    echo ‘我是:’.$this->sex.’生


    ’;

    echo ‘我今年:’.$this->age.'


    ’;

    //由于age是私有的成员属性,可以理解为我不想让别人知道我的年龄,所以在这里将不会被调用,将提示没有定义此属性在ChildFinalClass类中。

    $this->publickfun();

    $this->protectedfun();

    $this->privatefun();

    //由于privatefun是私有的成员方法,所以在这里将不会被调用。

    }

    }

    $obj = new ChildFinalClass();

    $obj->fchildfun();

    2.魔术方法

    i. 魔术方法必须被定义为公共的,所有其他魔术方法都必须如此

    ii. 从PHP 5以后的版本,PHP中的类就可以使用魔术方法了。其规定以两个下划线(__)开头的方法都保留为魔术方法,所以建议大家函数名最好不用__开头,除非是为了重载已有的魔术方法,接下来列出一些魔术方法,如果大家想详细了解可以针对某一个进行查询了解,这里就不大篇幅的介绍了。

    1、__construct() 构造方法

    __destruct()

    析构方法

    2、__clone()

    如果想复制一个对象则需要使用clone方法

    3、__toString()

    方法在将一个对象转化成字符串时自动调用,比如使用echo打印对象时

    4、__sleep()  串行化的时候用

    __wakeup 反串行化的时候调用

    5、 __set_state()

    当调用var_export()时,这个静态 方法会被调用(自PHP 5.1.0起有效)

    6、__invoke(PHP 5.3.0以上版本有效)

    当尝试以调用函数的方式调用一个对象时,__invoke 方法会被自动调用。

    7、__callStatic(PHP 5.3.0以上版本有效) 是为了处理静态方法调用

    8、__get()  当调用一个未定义的属性时,此方法会被触发,传递的参数是被访问的属性名。

    __set()  给一个未定义的属性赋值时,此方法会被触发,传递的参数是被设置的属性名和值。 这里的没有声明包括当使用对象调用时,访问控制为proteced,private的属性(即没有权限访问的属性)。

    9、__isset() 当在一个未定义的属性上调用isset()函数时调用此方法

    __unset() 当在一个未定义的属性上调用unset()函数时调用此方法

    10、__call( $method, $arg_array )

    当调用一个未定义的方法是调用此方法

    这里的未定义的方法包括没有权限访问的方法;如果方法不存在就去父类中找这个方法,如果父类中也不存在就去调用本类的__call()方​法,如果本类中不存在__call()方法就去找父类中的__call()方法。

    11、__autoload() 自动加载魔术方法

    展开全文
  • 类中的静态成员

    2019-11-12 11:36:43
    静态成员,指的是在c++类中声明成员时可以加上static关键字,这样声明的成员就叫做静态成员(包括数据成员和成员函数)。即声明为static的类成员或者成员函数便能在类的范围内同享。 示例: class CRectangle{ ...

    1.类中的静态成员

    1.1概念

    静态成员,指的是在c++类中声明成员时可以加上static关键字,这样声明的成员就叫做静态成员(包括数据成员和成员函数)。即声明为static的类成员或者成员函数便能在类的范围内同享。

    示例:

    class CRectangle{

    private:

        int w,h;

        static int nTotalArea;  //静态成员变量

        static int nTotalNumber;  //静态成员变量

    public:

        static void PrintTotal ();  //静态成员函数

    };

     

    1.2静态和非静态的区别

    静态数据成员和普通数据成员区别较大,体现在下面几点:

    (1)普通数据成员属于类的一个具体的对象,只有对象被创建了,普通数据成员才会被分配内存。而静态数据成员属于整个类,即使没有任何对象创建,类的静态数据成员变量也存在。

    (2)因为类的静态数据成员的存在不依赖与于任何类对象的存在,类的静态数据成员应该在代码中被显式地初始化,一般要在类外进行,例如上例。在C++11标准中,我们可以为静态成员提供const整数类型的类内初始值,不过要求静态成员必须是字面值常量类型的constexpr(源自C++Primer中文版270页)。

    (3)外部访问类的静态成员能直接通过类名来访问,例如:test::getCount()。虽然静态成员不属于类的某个对象,但是我们仍然可以使用类的对象、引用或指针来访问静态成员,例如:

    test ac1,*ac2;

    int r;

    r=ac1.getCount();// 或者 r=ac2->getCount();

    (4)类的静态成员函数无法直接访问普通数据成员(可以通过对象名间接的访问),而类的任何成员函数都可以访问类的静态数据成员。

    (5)静态成员和类的普通成员一样,也具有public、protected、private3种访问级别,也可以具有返回值、const修饰符等参数。

    (6)在使用静态成员变量时,必须要先显式地给它初始化,初始化了才算是真正的定义了,直接使用的化会报错为“error LNK2001: 无法解析的外部符号”。初始化要在类外进行,一般是实现成员函数的cpp头部初始化。

    (7)不能直接在类中给静态成员变量赋值,只有成员常量才能在类中被赋初始值。

    展开全文
  • C#中类的成员

    2019-10-04 21:57:45
    类中的数据和函数都称为类的成员。类的成员可以分为两类: ?类本身所声明的。 ?从基类中继承来的。 如果在类声明中没有指定基类,则该类将继承System.Object类的所有成员。 2. 成员的类别 类的成员有以下几种...

    一、C#中类的成员

    1. 类的成员

    类中的数据和函数都称为类的成员。类的成员可以分为两类:

    ?类本身所声明的。

    ?从基类中继承来的。

    如果在类声明中没有指定基类,则该类将继承System.Object类的所有成员。

    2. 成员的类别

    类的成员有以下几种类别:

    注:C#中的类成员可以是任意类型,包括数组和集合。

    3. 类的成员的访问级别

    ?public:声明为公有成员,访问不受限制。公有成员提供了类的外部界面,允许类的使用者从外部进行访问。

    ?protected:声明为受保护成员,只能访问包含类或从包含类派生的类。受保护成员对于外界是隐藏的。

    ?internal:声明为内部成员,只能访问当前程序集。

    ?protected internal:声明为受保护的内部成员,只能访问当前程序集或从包含类派生的类。

    ?private:声明为私有成员,只有该类中的成员可以访问。如果在声明中没有设置成员的访问修饰符,成员会被默认为private。

    二、示例
      
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    namespace Test
    {
        class Program
        {
            public class classTest                      // 定义一个classTest类
            {
                public int ID;                          // 公有成员ID
                protected int age;                      // 保护成员age
                private string name;                    // 私有成员name
                public static int count;                // 静态成员count
                public classTest(string name, int age)  // 公有成员,构造函数
                {
                    this.name = name;                   // 正确,允许访问自身成员
                    this.age = age;                     // 正确,允许访问自身成员
                    count++;                            // 正确,允许访问自身成员
                }
                public void Show()                      // 公有方法成员
                {
                    // 正确,允许访问自身成员
                    Console.WriteLine("Name:{0}\t Age:{1}", name, age);
                }
            }
            static void Main(string[] args)
            {
                // C#中类的成员-www.baike369.com
                // 创建一个classTest类的对象classTest1
                classTest classTest1 = new classTest("BaiXue", 18);
                classTest1.ID = 001;          // 正确,允许访问classTest1的公有成员
                //classTest1.age = 30;        // 错误,不允许访问classTest1的保护成员
                //classTest1.name = "LiPing"; // 错误,不允许访问classTest1的私有成员
                classTest1.Show();            // 正确,允许访问classTest1公有函数成员
                // 正确,允许通过类名来访问静态成员
                Console.WriteLine("count:{0}", classTest.count);
                Console.ReadLine();
            }
        }
    }

    运行结果:
     
    Name:BaiXue     Age:18
    count:1

    转载于:https://www.cnblogs.com/melao2006/p/4239327.html

    展开全文
  • 中包括成员变量的声明和方法定义,而成员变量又可细分为实例变量和变量。什么成员变量时,用关键字static给予修饰称作变量,否则称作实例变量,同样,方法类型前面不加关键字static修饰方法是实例...

    首先, 类的目的是抽象出一类事物共有的属性和行为,并用一定的语法格式来描述所抽象出的属性和行为。也即是说,类是一种用于创建具体实例(对象)的数据类型。

    类体中包括成员变量的声明和方法的定义,而成员变量又可细分为实例变量和类变量。在什么成员变量时,用关键字static给予修饰的称作类变量,否则称作实例变量,同样,方法类型前面不加关键字static修饰的方法是实例方法,否则则是类方法 , 例如:

    public class Demo{

    int x;  // 实例变量

    static int y;//类变量

    float max(float m , float n ){ //实例方法

    ....

    }

    static float min(float m , float n ){ //类方法

    ....

    }

    }

    3. 明白实例变量和类变量的区别

    1)   不同对象的实例变量互不相同:

    一个类通过使用new运算符可以创建多个不同的对象,而这些对象将分配不同的成员变量,即分配给不同的对象的实例变量占有不同的内存空间。改变其中一个对象的实例变量不会影响其他的对象的变量。

    2)  所有对象共享类变量

    当类中存在类变量,当创建多个不同对象时,分配给这些对象的这个类变量占有相同的一处内存。改变其中一个会影响其他, 即说对象共享类变量。

    3)  通过类名直接访问类变量

    当java程序运行时,类的字节码文件被加载到内存,如果该类没有创建对象,类中的实例变量不会被分配内存。但是,类中的类变量,在该类被加载到内存时,就分配了相应的内存空间。如果该类创建对象,那么不同的对象的实例变量互不相同,即分配不同的内存空间,而类变量不在重新分配内存,所有的对象共享类变量,即所有的对象的类变量是相同的一处内存空间。

    4.  实例方法和类方法的区别

    1)  对象调用实例方法

    当类的字节码文件被加载到内存时,类的实例方法不会被分配入口地址,只有该类创建对象后,类中的实例方法才分配入口地址,从而实例方法可以被类创建的任何对象调用执行。  的那个创建第一个对象时,类中的实例方法就分配了入口地址,当在创建对象是,不在分配入口地址。即方法的入口地址被所有对象共享,当所有的对象都不存在时,方法的入口地址才会被取消。

    实例方法中不仅可以操作实例变量,也可以操作类变量。

    2)   类名调用方法

    对于类方法,在该类被加载到内存时,就分配了相应的入口地址,从而类方法不仅可以被类创建的任何对象调用执行,也可以直接通过类名调用。类方法的入口地址知道程序退出才被取消。需要注意的是,实例方法不能通过类名调用,只能有对象调用。

    和实例方法不同的是,类方法不可以操作实例变量,这是因为在类创建对象之前,实例成员变量还没有分配内存。

    /**

    * @author 牧羊的伯格女皇

    * date: 2015-10-12

    */

    public class Lader {

    private double upper; //上底

    private double height;  //高

    public static double bottom; // 下底  类变量

    public double getUpper() {

    return upper;

    }

    public void setUpper(double upper) {

    this.upper = upper;

    }

    public double getHeight() {

    return height;

    }

    public void setHeight(double height) {

    this.height = height;

    }

    public static double getBottom() {  //类方法

    return bottom;

    }

    public static void setBottom(double bottom) {  //  类方法

    Lader.bottom = bottom;

    }

    //求面积:

    public double laderarea(){

    return (bottom+upper)*height/2;

    }

    }

    /**

    * TestLader.java

    * */

    public class TestLader {

    public static void main(String[] args) {

    Lader laderOne = new Lader();

    Lader laderTwo = new Lader();

    Lader.bottom = 10;  //Lader的字节码被加载到内存,通过类名直接访问类变量

    System.out.println("通过类名直接访问类变量的值是:   " + Lader.bottom );   //  10

    laderOne.setHeight(10);

    laderOne.setUpper(10);

    double areaOne = laderOne.laderarea();

    System.out.println("通过类名直接调用执行类方法得到梯形One下底的值:  "+Lader.getBottom()); // 10

    System.out.println("求得梯形One面积为:  " + areaOne  + "\n" );  // 100

    laderTwo.setHeight(20);

    laderTwo.setUpper(20);

    Lader.setBottom(20);  // 通过对象调用执行类方法

    System.out.println("通过对象调用执行类方法得到的梯形Two下底的值:  "  + Lader.getBottom() );//20

    double areaTwo = laderTwo.laderarea();

    System.out.println("求得梯形Two面积为:  " + areaTwo  );   //400

    }

    }

    展开全文
  • c++:类中的static成员

    2018-06-20 16:16:35
    c++:类中的static成员首先静态成员可以是public,也可以是private,只需一般变量、函数声明语句前加上static关键字即可声明一个static变量。类中的静态成员存在与任何对象之外,所有该类对象共享一个...
  • 静态成员和非静态成员都可以访问外围的所有成员,包括那些声明为private的成员。 两者非常相似,主要静态成员多累static修饰词。 正因此,非静态成员的每个实例都隐含着与外部的一个实例所相关联。非...
  • 面向对象编程语言是一个独立程序单位,它应该有一个类名并包括属性说明和操作说明两个主要部分。1、类的定义:i. 类的关键字定义使用class1.定义一个空Class Person{};2.定义一个有成员属性和操作的类...
  • 类中的静态成员真是个让人爱恨交加特性。我决定好好总结一下静态类成员知识点,以便自己以后面试中,此类问题上不被动。  静态类成员包括静态数据成员和静态函数成员两部分。  一 静态数据成员:  ...
  • 中包括成员变量的声明和方法定义,而成员变量又可细分为实例变量和变量。什么成员变量时,用关键字static给予修饰称作变量,否则称作实例变量,同样,方法类型前面不加关键字static修饰方法是实例...
  • 静态成员和非静态成员都可以访问外围的所有成员,包括那些声明为private的成员。  两者非常相似,主要区别在于静态成员多了static关键字。  正因此,非静态成员的每个实例都隐含着与外围的一个外围
  • 声明一个图书,其数据成员为书名、编号(利用静态变量实现自动编号)、书价,并拥有静态数据成员册数、记录图书总册数,构造方法利用些静态变量为对象编号赋值,主方法定义数组对象,并求出总册数
  • C++---类中的静态成员

    2013-07-23 22:23:48
    1>静态成员,可在类声明之外,使用单独语句初始化,因为静态成员单独存储,不是对象组成部分 2>初始化放在头文件,而不是类声明文件  原因:类声明位于头文件,程序可能将头文件包括在其他几个文件,...
  • 声明成员方法可以定义类的行为,行为表示一个对象能够做事情或者能够从一个对象取得信息。类的各种功能操作都是用方法来实现,属性只不过提供了相应数据。一个完整方法通常包括方法名称、方法主体、方法...
  • C# 类的成员

    2018-02-01 16:48:00
    C#,通过class关键字定义是存储堆(heap)上的引用类型。 类的成员:数据成员和函数成员。成员的访问性可以是public、protected、internal protected、private、internal 1.数据成员 的数据成员包括...
  • 要求:必须再类中,方法外面,和成员变量是平级 语法格式: 【修饰符】class类{ 【修饰符】 数据类型 成员变量名; 【修饰符】返回值 方法名【形参列表】{ 方法体语句块;//实现方法功能 } } 返回值类型: ...
  • 主要包括类的声明、对象定义、构造函数和析构函数、运算符重载、继承和派生、多态性实现等。 课程需要有C语言程序设计基础(可以利用本人开出《C语言与程序设计》系列课学习)。学习者能够通过...
  • 主要包括类的声明、对象定义、构造函数和析构函数、运算符重载、继承和派生、多态性实现等。 课程需要有C语言程序设计基础(可以利用本人开出《C语言与程序设计》系列课学习)。学习者能够通过...
  • C#的声明及语法结构前言类...字段是用来让编程人员定义对象特征,属于内部数据,一般只让其在类内部访问,而属性则是对字段进行保护,使外部成员访问,并且可限定其取值和赋值,方法则与之前一致。 public c...
  • 类的静态成员

    2013-02-18 14:58:29
     在类中的数据成员的声明前加上关键字static,则该数据成员就成为了该类静态数据成员。和类其他数据成员一样,静态数据成员也遵循public/protected/private访问规则。同时,静态数据成员还有以下一些特点: ...
  • 友元声明 前面加上关键字friend,该声明可以放在任何一个地方,一般放在类的定义。当声明了友元函数或者友元类之后,该...另外,如果要在类的前面声明该友元函数,需要用到类,因此还得在该声明的前面声明类的定义,
  • 一、静态数据成员  类中数据成员声明前加上... 1、不能在类中进行初始化,只能在类外。  因为静态数据成员为所有类对象公有(包括派生类),不占用类对象存储空间。若在类中初始化,容易造成对其他对象中该数
  • 2、abstrate:将一个类声明为抽象,没有实现方法,需要子类实现; 3、final:将一个类声明为非继承,表明此类不可以被子继承。 成员变量修饰符 1、public:将变量声明为公共,它可以被任何...
  • 一、什么是嵌套嵌套是指被定义另一个类的内部的类。嵌套存在目的应该只是为他外围提供服务。...最好把他看做是普通,只是碰巧被声明在另一个类的内部而已,它可以访问外围类的所有成员包括哪些...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,647
精华内容 658
关键字:

在类中声明的成员包括