精华内容
下载资源
问答
  • public(公有的)protected(受保护的)private(私有的)public、protected 和 private 可以控制类...定义为 public 的类成员,可以在任何地方访问(任何地方可见)。定义为 protected 的类成员,可以在其...

    访问控制(可见性)

    PHP 中,对类中的成员(属性和方法)的访问控制,是通过以下三个访问修饰符来实现的。

    • public(公有的)
    • protected(受保护的)
    • private(私有的)

    public、protected 和 private 可以控制类成员的可见性(visibility)。

    • 被定义为 public 的类成员,可以在任何地方被访问(任何地方可见)。
    • 被定义为 protected 的类成员,可以在其自身、子类和父类的内部访问。
    • 被定义为 private 的类成员,只能在其定义的类内部访问。
    <?php
    
    class A
    {
        public $public = 'Public';
        protected $protected = 'Protected';
        private $private = 'Private';
        const HASH = 'md5';
        const STATUS = ['success'=>0, 'fail'=>1];
        static $static = 'static';
        public static $s1 = [];
    
        public function __construct($alias)
        {
            $this->alias = $alias;   // 动态添加的属性,默认是 public。(不能动态添加一个静态属性)
        }
    
        function printHello()
        {
            // 在定义的类内部,可以访问自身的所有属性
            echo $this->public;
            echo $this->protected;
            echo $this->private;
            echo '<br>';
        }
    
        /**
         *  在父类中访问子类的成员,子类的 public、protected 的成员在父类中可见
         */
        public function accessChildClass() {
            $child = new static('b2');   // static 后期静态绑定
            echo $child->protected;echo '--';
            echo $child->alias;
            echo '<br>';
        }
    }
    
    class B extends A
    {
        protected $protected = 'Protected2';
    
        function printHello()
        {
            echo $this->public;
            echo $this->protected;
            echo $this->private;
            echo '<br>';
        }
    
        /**
         *  在子类中访问父类的成员,父类的 public、protected 的成员在子类中可见
         */
        public function accessParentClass() {
            $parent = new parent('a2');
            echo $parent->protected; echo '--';
            echo $parent->alias;
            echo '<br>';
        }
    }
    
    $obj = new A('a');
    echo $obj->public; echo '<br>'; // 正常执行,public 的属性在任何地方可见
    //echo $obj->protected; // 致命错误,因为 protected 的属性,只能在其自身、子类和父类中访问。致命错误会终止程序执行。
    //echo $obj->private; // 致命错误
    $obj->printHello(); // 正常执行,输出 Public、Protected 和 Private
    echo $obj->alias; echo '<br>';  // 正常执行,动态添加的属性,默认是 public
    echo A::HASH; echo '<br>';  // 正常执行,类常量在任何地方可见,是属于类的,而不是属于对象
    echo B::HASH; echo '<br>';  // 正常执行,类常量可以被子类继承
    
    $b = new B('b');
    echo $b->public; echo '<br>';  // Public
    echo $b->private; echo '<br>';  // Notice: Undefined property
    //echo $b->protected;  // Fatal error: Uncaught Error: Cannot access protected property
    $b->printHello();  // Public、Protected2、Notice: Undefined property: B::$private
    
    $b->accessChildClass(); // Protected2--b2,可以在父类中访问子类的 protected 和 public 的属性
    $b->accessParentClass(); // Protected--a2, 也可以在子类中访问父类的 protected 和 public 的属性
    
    var_dump(B::STATUS); echo '<br>';   // array(2) { ["success"]=> int(0) ["fail"]=> int(1) }
    
    echo A::$static; echo '<br>';   // static
    echo B::$static; echo '<br>';   // static
    
    var_dump(B::$s1); echo '<br>';   // array(0) { }

    属性的可见性

    类中的属性的可见性,除了遵循下面三条通用的规则:

    • public 的属性,可以在任何地方被访问(任何地方可见)。
    • protected 的属性,可以在其自身、子类和父类的内部访问。
    • private 的属性,只能在其定义的类内部访问。

    还需注意以下几点:

    • 动态添加的属性,默认是 public 。(不能动态添加一个静态属性)
    • static 关键字修饰的静态属性,默认是 public 。
    • 非静态属性,必须指定访问修饰符 public、protected 和 private 中的任意一个。

    非静态属性的访问方式

    • 通过 $this 访问,如 $this->public;
    • 通过具体的对象访问,如 (new A('a'))->public;

    静态属性的访问方式

    • 通过 self::、parent:: 和 static:: 访问,如:self::$static;
    • 通过具体的类名访问,如:A::$static;

    方法的可见性

    类中的方法的可见性,除了遵循下面三条通用的规则:

    • public 的方法,可以在任何地方被访问(任何地方可见)。
    • protected 的方法,可以在其自身、子类和父类的内部访问。
    • private 的方法,只能在其定义的类内部访问。

    还需注意以下几点:

    • 方法如果没有明确指定可见性,默认是 public 。
    • 也可用 static 关键字将方法修饰为静态方法。

    可以看出,方法的可见性和属性的可见性的规则基本是一致的。

    非静态方法的调用方式

    • 通过 $this 访问,如 $this->foo();
    • 通过具体的对象访问,如 (new B)->foo();
    • 通过 self::、parent:: 和 static:: 访问,如 static::foo();
    • 通过具体的类名访问,如 B::foo();

    在 PHP 7 中,已经废弃(弃用)了静态调用非静态的方法,未来可能会移除该功能。

    静态方法的调用方式

    • 通过 self::、parent:: 和 static:: 访问,如 static::foo();
    • 通过具体的类名访问,如 B::foo();
    • 通过 $this 访问,如 $this->foo();
    • 通过具体的对象访问,如 (new B)->foo();

    类常量

    类常量指的是在类内部的头部位置定义的常量。

    如:

    class A
    {
        const HASH = 'md5';
        const STATUS = ['success'=>0, 'fail'=>1];
        
        public function foo() { }
    }

    可以把在类中始终保持不变的值定义为常量。

    定义类常量只能使用 const 关键字。

    常量的值必须是一个定值,不能是变量,类属性或其它操作(如函数调用)的结果。

    在 PHP5.6 中,对 const 常量进行了增强,允许常量计算,允许使用包含数字、字符串字面值和常量的表达式结果来定义 const 常量。常量的值也可以是数组,但不能是变量。

    关于类常量,还需注意以下几点:

    • 类常量是属于类本身,而不是属于对象。
    • 类常量的访问方式和静态属性一致。
    • 类常量可以被继承。
    • 类常量不能被访问修饰符 public、protected 和 private 修饰。
    • 类常量不能被静态修饰符 static 修饰。
    • 类常量区分大小写。

    在 PHP 中,变量、常量区分大小写,函数和类名不区分大小。但魔术常量不区分大小写。

    继承

    在 PHP 中,类的继承会影响到类与类、对象与对象之间的关系。

    关于类的继承,需要注意以下几点:

    • 只有可见性为 public 和 protected 的属性和方法,才可以被子类继承。
    • 可见性为 private(私有)的属性或方法,不能被继承。
    • 类常量可以被继承。
    • 被子类继承的属性,可以在子类中重写(覆盖);否则,将沿用原有的值。
    • 被子类继承的方法,也可在子类中重写(覆盖);否则,将沿用原有的功能。
    <?php
    
    class Person
    {
        public $name;
        protected $age=18;
        private $phone='';
    
        public function getName()
        {
            echo $this->name;
        }
    
        protected function getAge()
        {
            echo $this->age;
        }
    
        protected function getClass()
        {
            echo __CLASS__;
        }
    
    
        private function getPhone()
        {
            echo $this->phone;
        }
    }
    
    class Tom extends Person
    {
        protected $age = 20;
    
        public function getName()
        {
            echo $this->name . '--' . __CLASS__; echo '<br>';
        }
    
        public function printInfo()
        {
            $this->getAge();    echo '--';
            parent::getAge();   echo '--';
            parent::getClass();
        }
    }
    
    $obj = new Tom();
    $obj->getName();    // --Tom
    
    $obj->printInfo();  // 20--20--Person
    展开全文
  • String是所有语言中最常用的一个类。我们知道在Java中,String是不可变的、final的。... 若 String 允许被继承, 由于它的高度使用率, 可能会降低程序的性能,所以 String 定义成 final。   一:St

    String是所有语言中最常用的一个类。我们知道在Java中,String是不可变的、final的。Java在运行时也保存了一个字符串池(String pool),这使得String成为了一个特别的类。

    主要是为了 “ 效率 ”  “ 安全性 ” 的缘故。  String 允许被继承由于它的高度被使用率可能会降低程序的性能,所以 String 被定义成 final

     

    一:String 和其他基本类型不同 , 他是个对象类型既然是对象类型 , 如果是在静态方法下是必须调用静态方法或值的 , 如果是非静态的方法 , 就必须要实例化.

     

    main 函数是个 static 所以String 要能像其他的基本类型一样直接被调用这也是为什么在 main 函数下使用 String 类型不会报告错误的原因..

     

    一下就解释了两个心里的疑问..

     

    以前一直觉得奇怪 ,为什么 String 是对象类型在 main 函数下却是不需要实例化的再次佩服 java 设计人员想得真周到.

     

    二:当定义 String 类型的静态字段(也成类字段),可以用静态变量(非 final)代替常量(final)加快程序速度。 反之,对于原始数据类型,例如 int,也成立。

     

    例如,你可能创建一个如下的 String 对象:

     

    Privatestatic final Stringx="example";

    对于这个静态常量(由 final 关键字标识),你使用常量的每个时候都会创建一个临时的 String 对象。 在字节代码中,编译器去掉 ”x”,代替它的是字符串 “example”, 以致每次引用 ”x”  VM 都会进行一次哈希表查询。

     

    相比之下,度于静态变量 (  final 关键字 ),字符串只创建一次。 仅当初始化 “x” 时, VM 才进行哈希表查询。

     

    还有另一个解释 :

    带有 final 修饰符的类是不可派生的。  java 核心 API 中,有许多应用 final 的例子,例如 java.lang.String  String 类指定 final 防止了人们覆盖 length() 方法。

     

    另外,如果指定一个类为 final,则该类所有的方法都是 final java 编译器会寻找机会内联(inline)所有的 final 方法(这和具体的编译器实现有关)。 此举能够使性能平均提高 50%

     

    示例:

     

    publicclassTest{

    publicstaticvoidmain(String[]args){

    //

    }

    }

    如果 String 不是 final 那么就可以继承

     

    publicclassString2extendsString{

    //..

    //...

    }

    那我们的 main 也就可以写成

     

    publicclassTest{

    publicstaticvoidmain(String2[]args){//注意此处

    //

    }

    }

    英文参考:http://forums.sun.com/thread.jspa?threadID=636414

     

    另外补充一点:

    作用就是 final的类不能被继承,不能让别人继承有什么好处?

     

    意义就在于,安全性,如此这般:

    java 自出生那天起就是“为人民服务”,这也就是为什么java做不了病毒,也不一定非得是病毒,反正总之就是为了安全, 人家java的开发者目的就是不想让 java干这类危险的事儿,java并不是操作系统本地语言, 换句话说java必须借助操作系统本身的力量才能做事,JDK中提供的好多核心类比如 String,这类的类的内部好多方法的实现都不是java编程语言本身编写的, 好多方法都是调用的操作系统本地的API,这就是著名的“本地方法调用”,也只有这样才能做事,这种类是非常底层的, 和操作系统交流频繁的,那么如果这种类可以被继承的话,如果我们再把它的方法重写了,往操作系统内部写入一段具有恶意攻击性质的代码什么的, 这不就成了核心病毒了么?

     

    上面所述是最重要的,另外一个方面,上面2位老兄说的也都很对, 就是不希望别人改,这个类就像一个工具一样,类的提供者给我们提供了, 就希望我们直接用就完了,不想让我们随便能改,其实说白了还是安全性, 如果随便能改了,那么java编写的程序肯定就很不稳定,你可以保证自己不乱改, 但是将来一个项目好多人来做,管不了别人,再说有时候万一疏忽了呢?他也不是估计的, 所以这个安全性是很重要的,javaC++相比,优点之一就包括这一点;

     

    原因绝对不只有这么多,因为如果这些个核心的类都能被随便操作的话,那是很恐怖的,会出现好多好多未知的错误,莫名其妙的错误….

     

    String类不可变性的好处

     

    只有当字符串是不可变的,字符串池才有可能实现。字符串池的实现可以在运行时节约很多heap空间,因为不同的字符串变量都指向池中的同一个字符串。但如果字符串是可变的,那么String interning将不能实现(译者注:String interning是指对不同的字符串仅仅只保存一个,即不会保存多个相同的字符串。),因为这样的话,如果变量改变了它的值,那么其它指向这个值的变量的值也会一起改变。

     

    如果字符串是可变的,那么会引起很严重的安全问题。譬如,数据库的用户名、密码都是以字符串的形式传入来获得数据库的连接,或者在socket编程中,主机名和端口都是以字符串的形式传入。因为字符串是不可变的,所以它的值是不可改变的,否则黑客们可以钻到空子,改变字符串指向的对象的值,造成安全漏洞。

     

    因为字符串是不可变的,所以是多线程安全的,同一个字符串实例可以被多个线程共享。这样便不用因为线程安全问题而使用同步。字符串自己便是线程安全的。

     

    类加载器要用到字符串,不可变性提供了安全性,以便正确的类被加载。譬如你想加载java.sql.Connection类,而这个值被改成了myhacked.Connection,那么会对你的数据库造成不可知的破坏。

     

    因为字符串是不可变的,所以在它创建的时候hashcode就被缓存了,不需要重新计算。这就使得字符串很适合作为Map中的键,字符串的处理速度要快过其它的键对象。这就是HashMap中的键往往都使用字符串 

    展开全文
  • String类能被继承吗?为什么

    千次阅读 2019-07-09 07:54:32
    因为我们查看String源码就知道,String被关键字final修饰,所以不能被继承。 这里就要简单介绍一下final的基础。 1、修饰类当用final去修饰一个类的时候,表示这个类不能被继承。注意:a. 被final修饰的类,final类...

    答案是不能的。

    因为我们查看String源码就知道,String被关键字final修饰,所以不能被继承。

    这里就要简单介绍一下final的基础。

    1、修饰类当用final去修饰一个类的时候,表示这个类不能被继承。注意:a. 被final修饰的类,final类中的成员变量可以根据自己的实际需要设计为fianl。b. final类中的成员方法都会被隐式的指定为final方法。说明:在自己设计一个类的时候,要想好这个类将来是否会被继承,如果可以被继承,则该类不能使用fianl修饰,在这里呢,一般来说工具类我们往往都会设计成为一个fianl类。在JDK中,被设计为final类的有String、System等。
    2、修饰方法
    被final修饰的方法不能被重写。
    注意:
    a. 一个类的private方法会隐式的被指定为final方法。
    b. 如果父类中有final修饰的方法,那么子类不能去重写。
    3、修饰成员变量
    注意:
    a. 必须初始化值。
    b. 被fianl修饰的成员变量赋值,有两种方式:1、直接赋值 2、全部在构造方法中赋初值。
    c. 如果修饰的成员变量是基本类型,则表示这个变量的值不能改变。
    d. 如果修饰的成员变量是一个引用类型,则是说这个引用的地址的值不能修改,但是这个引用所指向的对象里面的内容还是可以改变的。

    总之final就是像C语言中的const一样,代表一个常量,你在一开始初始化就要赋值,也不允许你改变它。

    参考链接:http://baijiahao.baidu.com/s?id=1601084106055683243&wfr=spider&for=pc


    展开全文
  • 哪些成员函数不能被继承

    千次阅读 2019-03-27 21:15:35
    C++中,并不是所有的成员函数都被子类继承,有三类成员函数不被子类继承,分别是:构造函数(包括拷贝构造)、析构函数、赋值运算符重载函数。 1. 构造函数  构造方法用来初始化类的对象,与父类的其它成员...

    C++中,并不是所有的成员函数都能被子类继承,有三类成员函数不能被子类继承,分别是:构造函数(包括拷贝构造)、析构函数、赋值运算符重载函数。

    1. 构造函数   

    构造方法用来初始化类的对象,与父类的其它成员不同,它不能被子类继承(子类可以继承父类所有的成员变量和成员方法,但不继承父类的构造方法)。因此,在创建子类对象时,为了初始化从父类继承来的数据成员,系统需要调用其父类的构造方法。   如果没有显式的构造函数,编译器会给一个默认的构造函数,并且该默认的构造函数仅仅在没有显式地声明构造函数情况下创建。 构造原则如下:

    1. 如果子类没有定义构造方法,则调用父类的无参数的构造方法。

    2. 如果子类定义了构造方法,不论是无参数还是带参数,在创建子类的对象的时候,首先执行父类无参数的构造方法,然后执行自己的构造方法。

    3. 在创建子类对象时候,如果子类的构造函数没有显示调用父类的构造函数,则会调用父类的默认无参构造函数。

    4. 在创建子类对象时候,如果子类的构造函数没有显示调用父类的构造函数且父类自己提供了无参构造函数,则会调用父类自己的无参构造函数。

    5. 在创建子类对象时候,如果子类的构造函数没有显示调用父类的构造函数且父类只定义了自己的有参构造函数,则会出错(如果父类只有有参数的构造方法,则子类必须显示调用此带参构造方法)。

    6. 如果子类调用父类带参数的构造方法,需要用初始化父类成员对象的方式 

    构造函数不能为虚:

    虚函数的作用是允许在派生类中重新定义与基类同名的函数,并且可以通过基类指针或引用来访问基类和派生类中的同名函数

    https://blog.csdn.net/LC98123456/article/details/81143102

    要成为虚函数必须满足两点,一就是这个函数依赖于对象调用,因为虚函数就是依赖于对象调用,因为虚函数是存在于虚函数表中,有一个虚函数指针指向这个虚表,所以要调用虚函数,必须通过虚函数指针,而虚函数指针是存在于对象中的。二就是这个函数必须可以取地址,因为我们的虚函数表中存放的是虚函数函数入口地址,如果函数不能寻址,就不能成为虚函数。构造函数内联函数不可作为虚函数

    2. 析构函数   

    析构函数也不会被子类继承,只是在子类的析构函数中会调用父类的析构函数。

    • 如果没有将基类的析构函数定义为虚函数
      当基类指针指向子类对象时,如果基类的析构函数不是virtual,那么子类的析构函数将不会被调用,子类的资源没有正确是释放,因此造成内存泄露

    3. 赋值运算符重载函数   

    赋值运算符重载函数也不会被子类继承,只是在子类的赋值运算符重载函数中会调用父类的赋值运算符重载函数。

    展开全文
  • String类为什么不能被继承

    千次阅读 2020-03-26 17:34:38
    面试的时候我们经常会被问到一个问题,那就是String类能被继承吗?为什么?我们都知道String类不能被继承,但为什么不能却不能回答地很完整。 首先我们可以看下String的源码(部分): public final class String ...
  • String类能被继承吗,为什么。

    千次阅读 2019-07-15 15:01:37
    在Java中,只要是被定义为final的类,也可以说是被final修饰的类,就是不能被继承的。 final是java中的一个关键字,可以用来修饰变量、方法和类。用关键词final修饰的域成为最终域。用关键词final修饰的变量一旦...
  • 首先我们先看下final在java中的作用 final在Java中可以用来修饰类、修饰方法和修饰变量 1. final修饰的类,为最终类,该类... final修饰的变量不能被修改,是个常量 举例说明: public class Person { private S...
  • 在lua里实现常量_类_继承_多态

    千次阅读 2011-08-08 03:36:10
    MONSTER1 = packMap.newConst({"哥斯拉", 1, 1}), --表项为常量的也需声明为常量表 MONSTER2 = packMap.newConst({"小强",2,2}), MONSTER3 = packMap.newConst({"史锐克",3,3}) } local t = packMap.new...
  • 1】常量的定义 使用关键字final定义常量,例如: final double PI=3.1415926; 作为一种约定,在定义常量时,通常采用大写形式 final常量可以在声明的同时赋初始值,也可以在构造函数中赋初始值。 为了节省内存...
  • 常量可以被子类继承 5.一个常量是属于一个类的,而不是某个对象的 作用:当某些值是固定不变的,就用const 1.const 定义的常量和define()定义的常量的区别? 希望一个成员变量不修改 例如圆周率 3.1415926 定义...
  • 在派生时,派生类是不能继承基类的析构函数的,也需要通过派生类的析构函数去调用基类的析构函数。在派生类中可以根据需要定义自己的析构函数,用来地派生类中所增加的成员进行清理工作。基类的清理工作任然由基类的...
  • Flex教程系列, ...Flex教程系列之(五) AS3语法——静态常量继承和接口 http://download.csdn.net/source/1161921 Flex教程系列之(六) AS3语法——数组和类型转换 http://download.csdn.net/source/1161978
  • )实现接口的类,其拥有接口中定义的常量和方法的使用权限(注意:接口中不定义私有变量) 2 )继承   子类继承父类的方法和属性(不包含私有方法和私有变量) 3 )方法的调用顺序   如果子类含有和...
  • 运行时初始化,但不希望改变的变量 编译时的常量,编译器可以将它的值代入用到它的任何地方,也就是说在编译时就已经执行了计算式,减少了运行时的负担,优化了性能。在Java这些常量必须为基本类型,并且必须赋值...
  • 解释:接口中的属性都是静态常量,不能被继承;方法均为抽象方法,没有具体实现的方法体,所以在多继承的情况下,即使方法同名,也不会出现类多继承那样的矛盾。 类与接口之间可以多实现 解释:与接口之间可多继承...
  • 不可以,因为String类有final修饰符,而final修饰的类是不能被继承的,实现细节不允许改变。 关于final修饰符,介绍如下: 根据程序上下文环境,Java关键字final有“这是无法改变的”或者“终态的”含义,它可以修饰...
  • String类能否被继承

    万次阅读 多人点赞 2016-03-31 12:49:16
    能被继承的类
  • Java常量池(静态常量池与运行时常量池)

    万次阅读 多人点赞 2018-03-02 11:12:50
    1、什么是常量用final修饰的成员变量表示常量,值一旦给定就无法改变!final修饰的变量有三种:静态变量、实例变量和局部变量,分别表示三种类型的常量。Java中的常量池,实际上分为两种形态:静态常量池和运行时...
  • Java常量final

    2020-01-26 00:01:12
    1. final修饰的类不可以被继承 2. final修饰的方法不可以重写 3. final修饰的变量不可以改变.如果修饰引用,那么表示引用不可变,引用指向的内容可变. 4. final修饰的方法,JVM会尝试将其内联,以提高...
  • 常量和枚举、常量类的区别

    万次阅读 2018-07-21 22:50:42
    一、实体常量类 /** * 实体常量类 * @author Administrator * @date 2018/7/21 */ public class ConstClass { private static final String Success = "成功"; private static final String Fail ...
  • python常量与变量

    千次阅读 2017-10-02 17:40:05
    python中的常量是一旦绑定,就不更改的量。 python中定义常量需要通过对象的方法来创建。 #这里主要定义了常量的功能, # 该类定义了一个方法__setattr()__,和一个异常ConstError, ConstError类...
  • java中关键字const是什么意思?  2009-4-7 21:31 提问者: 8fengchen8 | 来自手机知道 | 浏览次数:6806次 我来帮他解答 ...你可以用final关键字.final也可以用于声明方法或类,声明为final的方法或类不
  • golang 常量 iota

    2018-01-11 10:49:23
    package main import "fmt" const ( a = iota b c d = 1// 新的常量声明 iota 不再向下... f // 如果常量没有赋值,继承上一个常量值 ) // 如果都不赋值,语法错误 //const( // l // i // q //) const( e =
  • 项目代码优化:每页显示商品记录数在代码中原来是定义的一个类常量,因为在代码中多次使用到,因此在这个实现类中定义了一个类常量。使用和这样的代码运行是没有任何问题的,但是对于以后的代码维护和程序的灵活扩展...
  • Java--String类能否被继承

    千次阅读 2018-05-30 11:04:32
    之所以不能被继承就是因为其中的修饰关键字 final 其含义相当于C/C++的const,意味着不可修改。 final可以用来修饰 类 、变量 和 方法, final修饰类的时候 ,这个类就不能被继承了 类中所有的方法也就被隐式的...
  • python定义常量

    2020-10-30 11:30:26
    该类定义了一个方法__setattr()__,和一个异常ConstError, ConstError类继承 自类TypeError. 通过调用类自带的字典__dict__, 判断定义的常量是否包含在字典 中。如果字典中包含此变量,将抛出异常,否则,给新创建的...
  • 常量接口 vs 枚举常量

    千次阅读 2015-03-25 15:00:42
    常量定义在接口里与类里都通过编译,那2者到底有什么区别呢?那个更合理?  1. 常量接口  Java代码  public interface ConstInterfaceA {   public static final String CONST_A...
  • 常量应该封装到常量类,常量接口,还是枚举类中?前言之前项目中响应前台的接口中会用到一些公共常量。这个时候就比较纠结,常量到底是封装到哪里比较好呢,因为以前写的很多代码不怎么规范,而且有时候常量用到的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 269,061
精华内容 107,624
关键字:

常量能被继承