精华内容
下载资源
问答
  •  Kotlin中的object关键字在多种情况下出现,但是他们都遵循同样的核心理念:这个关键字定义一个类并同时创建一个实例(换句话说就是一个对象)让我们看看使用场景: 对象声明是定义单例的一种方式 伴生对象可以...

    4.4 “object” 关键字:将声明一个类与创建一个实例结合起来

     Kotlin中的object关键字在多种情况下出现,但是他们都遵循同样的核心理念:这个关键字定义一个类并同时创建一个实例(换句话说就是一个对象)让我们看看使用场景:

    • 对象声明是定义单例的一种方式
    • 伴生对象可以持有工厂方法和其他与这个类有关,但在调用时并不依赖类实例的方法。它们的成员可以通过类名来访问
    • 对象表达式用来替代Java的匿名内部类

    4.4.1 对象声明:创建单例易如反掌

     在面向对象系统设计中一个相当常见的情形只需要一个实例的类。在Java中,这通常通过单例模式来实现,定义一个使用private构造方法并且用静态字段来持有这个类的实例。

     在Kotlin中,使用对象声明功能为这一切提供了更高级的语言支持。对象声明将类声明与类的单一实例声明结合到了一起。

    例如,可以使用一个对象声明来表示一个公司的工资单,你也许不会有多个工资单,所以用一个对象来表示看起来是明智的。

    object Payroll {
       val allEmployees = arrayListOf<Person>()
        fun calculateSalary() {    // 展示所有员工工资单
            for (people in Payroll.allEmployees) {
                println("name:${people.name} salary;${people.salary}")
            }
        }
    }
        Payroll.allEmployees.add(Person("klaus1", 500))
        Payroll.allEmployees.add(Person("klaus2", 600))
        Payroll.allEmployees.add(Person("klaus3", 700))
        Payroll.calculateSalary()

    >>>

    name:klaus1 salary;500
    name:klaus2 salary;600
    name:klaus3 salary;700

    • 一个对象声明可以非常高效地以一句话来定义一个类和一个该类的变量
    • 与类一样,一个对象声明也可以包含属性、方法、初始化语句块等声明。唯一不允许的就是构造方法。
    • 与普通的实例不同,对象声明在定义的时候就立即创建了,不需要在代码的其他地方调用构造方法。所以为对象声明定义构造方法是没有意义的

    对象声明同样可以继承自类和接口,这通常在你使用的框架需要去实现一个接口,并且你的实现并不包含任何状态的时候很有用,比如实现比较器Comparator。比较器通常来说都不存储任何数据,所以通常只需要一个单独Comparator实例来以特定的方式比较对象。这是一个非常完美的对象声明使用场景

    object CaseInsensitiveStringComparator : Comparator<String> {
    
        override fun compare(o1: String, o2: String): Int {
            return o1.compareTo(o2)
        }
    
    }
        println(CaseInsensitiveStringComparator.compare("c","b"))
    
        val listString = listOf<String>("a","c","b","g","f")
    
        val sortedWith = listString.sortedWith(CaseInsensitiveStringComparator)
        println(sortedWith)

    sortWith函数,返回一个比较器比较过的列表

    使用嵌套类实现Comparator

    data class Person(val name: String, val salary: Int) {
    
        object SalaryComparator : Comparator<Person> {
            override fun compare(o1: Person, o2: Person): Int {
               return o1.salary.compareTo(o2.salary)
            }
        }
    
    }
     val persons = listOf<Person>(Person("klaus", 300),Person("Bob", 100), Person("Alice", 200))
        println(persons.sortedWith(Person.SalaryComparator))

    >>  [Person(name=Bob, salary=100), Person(name=Alice, salary=200), Person(name=klaus, salary=300)]

    在Java中使用Kotlin对象

    Kotlin中的对象声明被编译成了通过静态字段来持有它的单一实例,这个字段始终是INSTANCE,

    Java中访问

    CaseInsensitiveStringComparator.INSTANCE.compare(str1,str2)

     

    4.4.2 伴生对象:工厂方法和静态成员的地盘 

     Kotlin中的类不能拥有静态成员:Java的static关键字并不是Kotlin语言的一部分。作为替代,Kotlin依赖包级别函数(在大多数情形下能够替代Java的静态方法)和对象声明(在其他情况下替代Java的静态方法,同时还包括静态字段)。

    在大多数情况下,还是推荐使用顶层函数。单是顶层函数不能访问类的private成员。

    在类中定义对象之一可以使用一个特殊的关键字来标记:companion 如果这样做,就获得了直接通过容器类名称来访问这个对象的方法和属性的能力,不再需要显式地指明对象的名称,最终的语法看起来就像在Java中调用静态方法一样

    class A {
        companion object {
            fun bar() {
                println("companion object called!")
            }
        }
    }
    
       A.bar()

    定义一个拥有多个从构造方法的类

    class User {
    
        val nickname: String
    
        constructor(email: String) {        //从构造方法
            nickname = email.substringBefore('@')
        }
    
        constructor(facebookID: Int) {       //从构造方法
            nickname = getFacebookName(facebookID)
        }
    
    }

    表示相同逻辑的另一种方法,就是使用工厂方法来创建类的实例,这有多方面的好处。User实例就是通过工厂方法创建的,而不是通过多个构造方法。

    class User private constructor(val nickname: String) {
        companion object {
            fun newSubcribingUser(email: String) = User(email.substringBefore('@'))
            
            fun newFacebookUser(facebookID:Int) = User(getFacebookName(facebookID))
        }
    }
     val user1 = User.newFacebookUser("klaus@qq.com")
        val user2 =  User.newSubcribingUser(1)

    4.4.3 作为普通对象使用的伴生对象

    伴生对象是一个声明在类中的普通对象。它可以有名字,实现一个接口或者扩展函数或属性

    声明一个命名伴生对象

    class User(val name: String) {
    
        companion object GsonUtil {
            fun fromJson(jsonString: String) = Gson().fromJson<User>(jsonString, User::class.java)
        }
    
    }
        val user = User.GsonUtil.fromJson("{name:'klaus'}")
      //val user = User.fromJson("{name:'klaus'}")
        println(user.name)

    >>  klaus

    在大多数情况下通过类名来引用伴生对象,所以不用关心它的名字。但是也可以指明。如果你省略了名字,默认的名字将会是Companion。接下来当我们讲到伴生对象扩展时,你将会看到使用这名字的一些例子。

    在伴生对象中实现接口

    interface JSONFactory<T> {
        fun fromJson(jsonString: String): T
    }
    
    class User(val name: String) {
        companion object GsonUtil : JSONFactory<User> {     //实现接口的伴生对象
            override fun fromJson(jsonString: String) = Gson().fromJson<User>(jsonString, User::class.java)
        }
    }

    这时 定义一个函数

    fun loadFromJSON(factory: JSONFactory<User>,jsonStr:String): User {
        return factory.fromJson(jsonStr)
    }
        val user = loadFromJSON(User, "{name:'klaus'}")
        println(user.name)

    >> klaus
    注意 ,User类的名字被当作JSONFactory的实例。

    在Java中如何调用伴生对象,如果伴生对象没有命名

    User.Companion.fronJson(""),

    如果有名字,那就用名字代替Companion

    伴生对象扩展

    就像在3.3节看到的那样,扩展函数允许你定义代码库中其他地方定义的方法,但是如果你想定义通过类自身调用的方法,就像伴生对象或者Java静态方法该怎么办?如果类有一个伴生对象,可以通过在其上定义扩展函数来做到这一点。具体来说,如果类C有一个伴生对象,并且在C.Companion上定义了一个扩展函数func,那么可以通过C.func()来调用。

    /**
     * 扩展User的伴生对象,可以直接用类名调用
     * 伴生对象名字是GsonUtil,如果没有命名,则用Companion代替
     */
    fun User.GsonUtil.toJson(user: User) = Gson().toJson(user)
        val jsonStr = User.toJson(User("Alice"))
        println(jsonStr)

    >> {"name":"Alice"}

    你调用toJson方法,就好像它是一个伴生对象定义的方法一样,但是实际上它是作为扩展函数在外部定义的。,如果你想为你的类定义扩展,必须在其中定义一个伴生对象,即使它是空的。

     

    4.4.4 对象表达式:改变写法的匿名内部类

    object 关键字不仅仅能用来声明单例式的对象,还能用来声明匿名对象。匿名对象替代了Java中匿名内部类的用法。例如,让我们来看看怎样将一个典型的Java匿名内部类用法-事件监听-转换成Kotlin:

    实现一个按钮的点击事件

            button.setOnClickListener(
                    object : View.OnClickListener {    //声明一个继承自OnClickListener的匿名对象
                        override fun onClick(v: View?) {
                            TODO("not implemented")
                        }
                    }
            )

    除了去掉对象的名字外,语法和对象声明相同。

    对象表达式声明了一个类并创建了改类的一个实例,但是并没有给这个实例分配名字。通常来说它是不需要名字的,因为你会将这个对象作为一个参数来使用。如果你需要给对象分配名字,可以将其存储到一个变量中:

        val onClickListener = object : View.OnClickListener{
            override fun onClick(v: View?) {
                TODO("not implemented") 
            }
        }
    

    与Java匿名内部类不同,Kotlin匿名对象可以实现多个接口或者不实现接口。

    注意:与对象声明不同,匿名对象不是单例的。每次对象表达式被执行都会创建一个新的对象实例。

    匿名内部类访问局部变量

     

    与Java不同,访问局部变量并没有被限制在final变量,还可以修改变量的值。例如:记录按钮的点击次数。

            var clickCount: Int = 0
    
            button.setOnClickListener(
                    object : View.OnClickListener {
                        override fun onClick(v: View?) {
                            clickCount++
                        }
                    }
            )
    展开全文
  • PHP使用static关键字声明静态属性和静态方法 在PHP中,通过static关键字修饰的成员属性和成员方法被称为静态属性和静态方法。 静态属性和静态方法不需要在被类实例化的情况下就...静态属性不能通过一个类已实例化...

    PHP使用static关键字声明静态属性和静态方法

    在PHP中,通过static关键字修饰的成员属性和成员方法被称为静态属性和静态方法。

    静态属性和静态方法不需要在被类实例化的情况下就可以直接使用。

    1. 静态属性

    静态属性就是使用static关键字修饰的成员属性,它属于类本身而不属于类的任何实例。它相当于存储在类中的全局变量,可以在任何位置通过类来访问。

    静态属性不能通过一个类已实例化的对象来访问。

    静态属性访问的语法格式如下:

    类名称::$静态属性名称

    其中的符号“::”被称为范围解析操作符,用于访问静态属性、静态方法和常量,还可以用于覆盖类中的成员和方法。

    在静态属性的名称前加上操作符“self::”,即可在类内部的成员方法中访问静态属性。而只使用类名称::,则可以在类外面调用类内部的静态属性。

    注意:

    静态属性不可以由对象通过->操作符来访问。

    就像其它所有的PHP静态变量一样,静态属性只能被初始化为文字或常量,不能使用表达式。所以可以把静态属性初始化为整数或数组,但不能初始化为另一个变量或函数返回值,也不能指向一个对象。

    2. 静态方法

    静态方法就是通过static关键字修饰的成员方法。由于它不受任何对象的限制,所以可以不通过类的实例化直接引用类中的静态方法。

    静态方法可以通过一个类已实例化的对象来访问。

    静态方法引用的语法格式如下:

    类名称::静态方法名称([参数1,参数2,...])

    同样,在静态方法的名称前加上操作符“self::”,即可在类内部的成员方法中引用静态方法。而只使用类名称::,则可以在类外面调用类内部的静态方法。

    注意:

    在静态方法中,只能调用静态变量,而不能调用普通变量;而普通方法则可以调用静态变量。

    用静态方式调用一个非静态方法会导致一个E_STRICT级别的错误。

    由于静态方法不需要通过对象即可调用,所以伪变量$this在静态方法中不可用。


    提示

    使用静态成员,除了可以不需要实例化对象,另一个作用就是在对象被销毁后,仍然保存被修改的静态数据,以便下次继续使用。

    为了兼容PHP 4,如果没有指定为protected或private,静态属性和静态方法则默认为公有public。

    自PHP 5.3.0起,可以用一个变量来动态调用类,但该变量的值不能为关键字self、parent或static。


    说明

    静态成员不用实例化对象,当类第一次被加载时就已经分配了内存空间,所以直接调用静态成员的速度要快一些。但如果静态成员声明得过多,空间一直被占用,反而会影响系统的功能。这个尺度只能通过实践积累才能真正把握!


    实例

    <?php
    class website{
      static $num="0";                         // 定义静态变量
      public function visit(){                 // 定义visit方法
        echo "您是第".self::$num."位访客!";   // 输出静态变量信息
        self::$num++;                          // 静态变量做自增运算
      }
    }
    
    echo '第一次实例化调用:<br />';
    $website=new website();                    // 实例化对象
    $website->visit();                         // 调用对象$website的visit()方法
    $website->visit();
    $website->visit();
    
    echo '<br />第二次实例化调用:<br />';
    $website2=new website();                   // 改变对象句柄实例化对象
    $website2->visit();
    $website2->visit();
    $website2->visit();
    ?>
    

    在浏览器中查看PHP使用static关键字声明静态属性和静态方法的显示效果。如下图所示:

     

    转载于:https://www.cnblogs.com/qiaodan/p/5854246.html

    展开全文
  • 包含一个抽象方法的就是抽象 抽象方法: 声明而未被实现的方法就是抽象方法,抽象方法必须使用 abstract 关键字进行声明 需要注意的是, 1. 抽象被子继承时,子类(如果不是抽象)必须重写抽象...

    抽象类的概念:

    包含一个抽象方法的类就是抽象类

     

    抽象方法:

    声明而未被实现的方法就是抽象方法,抽象方法必须使用 abstract 关键字进行声明

     

    需要注意的是,

    1. 抽象类被子类继承时,子类(如果不是抽象类)必须重写抽象类中的『所有』抽象方法

    2. 抽象类不能直接被实例化,需要通过其子类进行实例化

     

    抽象类的定义格式:

     abstract class className{

      属性

      方法

      抽象方法

    }

     

    代码如下:

    package hello;
    
    abstract class Abs{
    	private int age;
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public void tell(){
    		
    	}
    	abstract public void say();
    }
    
    class Demo extends Abs{
    	public void say(){
    		
    	}
    	
    }
    
    public class AbstractDemo {
    
    	public static void main(String[] args) {
    		Demo aDemo = new Demo();
    		System.out.println(aDemo.getAge());
    	}
    
    }
    

      

    转载于:https://www.cnblogs.com/changzhi/p/6747545.html

    展开全文
  • 通过友元一个普通函数或类的成员函数可以访问封装于另一个类中的数据。从一定程度上讲,友元是对数据隐藏和封装的破坏,但是为了数据共享和提高程序的效率与可读性,小的破坏是必要的。  友元函数不属于该类的成员...

    一、友元函数

      1、友元函数允许在类外访问该类中的任何成员,使用关键字friend说明。通过友元一个普通函数或类的成员函数可以访问封装于另一个类中的数据。从一定程度上讲,友元是对数据隐藏和封装的破坏,但是为了数据共享和提高程序的效率与可读性,小的破坏是必要的。

        友元函数不属于该类的成员函数,它是定义在类外的普通函数,只是在类中通过friend关键字声明,从而使该函数可以访问类中的private与protected成员

      2.友元函数的声明一般形式:

    • friend <返回值类型>  <函数名>  (<参数列表>)

      3.使用友元函数注意的要点

    • 1---类中通过使用关键字friend来说明友元函数,但该函数并不是类的成员函数,其声明可以放在类的私有部分也可以放在类的公有部分。友元函数的定义在类体外实现,不需要加类限定。
    • 2---一个类的成员函数可以是另一个类的友元函数,而且一个函数可以是多个类的友元函数。
    • 3---友元函数可以访问类的私有成员和数据,但是可以访问但不能直接使用数据成员需要通过对对象进行引用使用数据成员
    • 4---友元函数在调用上同一般函数一样,不必通过对对象进行引用

    对于1、2、4、的使用解释详见下面代码:

    • class persion{
      public:
            persion(char *pn);
              //友元函数;
            friend void setweigth(persion &p,int h);//注意,参数列表中一般会有一个引用类型的形参,原因参考上面的使用要点3和4;
            void disp(); //类成员函数
      private:
            char name[20];
            int weigth,age;      
      };
      
      persion::persion(char *pn)   //构造函数
      {
         strcpy(name,pn);
         weigth=0;
      }
      void persion::disp()
      {
      cout<<name<<"--"<<weigth<<endl;
      }
      //友元函数的具体实现:这里没有类限定例如 (perion::setweigth)这种形式,这里可以与上面的disp()做个对比,一个属于类的成员,有限定,一个不属于类的成员函数,没有加限定。
      void setweigth(persion &pn,int w)
      {
      pn.weigth=w;       //私有成员数据赋值
      }
      void  main()
      {
        persion p("zhansan");
        setweigth(p,60);//调用实现setweigth(),与一般函数调用一致。
        p.disp();  //调用类的成员函数。
      }

      对于第2点的使用详见下边的代码:一个类的成员函数可以是另一个类的友元函数

    •  1 class wheel;
       2 class car{
       3 public:
       4     car(char *pn);
       5     void run(wheel &w);    //成员函数,做成wheel类中友元函数实现
       6 private:
       7     char name[20];
       8 
       9 };
      10 car::car(char *pn)
      11 {
      12 strcpy(name,pn);
      13 }
      14 
      15 class wheel{
      16 public:
      17     wheel(int s);
      18     friend void car::run(wheel &w);   //这里把car类的成员函数做了友元函数。
      19 private:
      20     int speed;
      21 };
      22 wheel::wheel(int s)
      23 {
      24   speed=s;
      25 }
      26 
      27 void car::run(wheel &w)   //car类成员函数的实现
      28 {
      29     cout<<"the car is running"<<endl;
      30     cout<<"name: "<<name<<" speed :"<<w.speed<<endl;
      31 }
      32 
      33 int  main(int argc, char const *argv[])
      34 {
      35     wheel w(60);
      36     car c("New car");
      37     c.run(w);   //通过car的成员函数作为友元函数访问类wheel类中的数据成员
      38     return 0;
      39 }

    • 使用友元函数计算两点之间的距离:代码示例如下
      •  1 #include <iostream>
         2 #include <cmath>
         3 using namespace std;
         4 //使用友元函数计算两点之间的距离
         5 class Point{
         6 public:
         7     Point(int xx = 0, int yy = 0) { X = xx; Y = yy;}
         8     int GetX() {return X;}
         9     int GetY() {return Y;}
        10     friend float fDist( Point &a, Point &b );
        11 private:
        12     int X, Y;
        13 };
        14  
        15 float fDist(Point &p1, Point &p2){
        16     double x = double(p1.X - p2.X);//通过对象访问私有数据成员,而不是必须使用Getx()函数
        17     double y = double(p1.Y - p2.Y);
        18     return float(sqrt(x*x + y*y));
        19 }
        20 int main(){
        21     Point p1(1, 1), p2(4, 5);
        22     cout << "the distance is:";
        23     cout << fDist(p1, p2) << endl;//计算两点之间的距离
        24     return 0;
        25 }

         友元函数直接使用了对象名访问了私有数据成员X,Y,而不是通过类的成员函数Getx(),Gety(),函数。




     

    二、友元类

      1、和友元函数一样,一个类也可以声明为另一个类的友元类。声明为友元的类可以访问该类的私有数据成员,该类的成员函数都是该友元类的成员函数

    • 友元类的应用详见下边代码:
    •  1 class A{
       2 public:
       3     int GetX() { return x; }
       4     friend class B;//B类是A类的友元类
       5     //其它成员略
       6 private:
       7     int x;
       8 };
       9 class B{
      10 public:
      11     void set(int i);
      12     //其他成员略
      13 private:
      14     A a;
      15 };
      16 void B :: set(int i){
      17     a.x = i;//由于B类是A类的友元类,所以在B的成员函数中可以访问A类对象的私有成员
      18 }

       

       

     

    转载于:https://www.cnblogs.com/southcyy/p/10260092.html

    展开全文
  • C++ 中的static关键字

    2018-12-04 17:32:39
    当我们声明类的成员为静态时,这意味着无论创建多少个类的对象,静态成员都只有一个副本。 静态成员在类的所有对象中是共享的。如果不存在其他的初始化语句,在创建第一个对象时,所有的静态数据都会被初始化为零。...
  • 在c++模板中的static变量是分开运算的,即所有的int类型类使用一个static变量,所有char类型的类使用一个static关键字,这与c++编译器的编译原理有关 编译器并不是把函数模板处理成能够处理任意的函数 编译器从函数...
  • ​ 通常情况下,成员必须通过它的的对象访问,但是我们可以在成员的声明前面加上关键字static(静态的),这样它就能够使用类名来直接调用,而不必创建对象来调用。 ​ 如果一个成员被声明为static,它就...
  • 当某个基类方法不适用于派生时,我们在...要屏蔽一个继承的数据成员,需要声明一个新的相同类型的成员,并使用相同的名称。 /// 2.通过在培生累中声明新的带有相同签名的函数成员,可以隐藏或屏蔽继承的函数成...
  • c++模板遇上static关键字

    千次阅读 2016-04-10 21:42:42
    当我们声明类的成员为静态时,这意味着无论创建多少个类的对象,静态成员都只有一个副本。静态成员在类的所有对象中是共享的。如果不存在其他的初始化语句,在创建第一个对象时,所有的静态数据都会被初始化为零。 ...
  • object是Kotlin中的一个重要的关键字,也是Java中没有的。object主要有以下三种使用场景: 对象声明(Object Declaration) 伴生对象(Companion Object) 对象表达式(Object Expression) 下面就一一介绍它们所...
  • abstract关键字 1.abstract --抽象的; 2. abstract可以用来修饰的结构:和方法; 3. abstract修饰:抽象; 3.1 抽象不能被实例化 ...4.2 包含抽象方法的一定是一个抽象,但是抽象不一定有抽象方
  • implements关键字

    2020-03-17 20:35:05
    (1)定义:接口是一个抽象方法声明和静态不能被修改的数据的集 合,不能被实例化。从某种意义说,接口是一种特殊形式的抽象。 (2)实现:接口通过implements关键字来实现接口, 接口允许多继承. public interface...
  • final关键字 最终无法改变的final修饰的变量如果是成员...一个常量当使用的数据不变时,定义阅读性强的名称来表示该数据被final修饰的变量,名称规范:所有字母大写,如果由多个字母组成,通过“-”分割public st...
  • (1)使用final关键字声明一个类,该类不能被继承。 (2)使用final关键字声明一个方法,该方法不能被子类重写。 (3)使用final关键字声明一个常量,用final关键字修饰的属性为常量(值不能改变)。 常量进行...
  • 有时你希望定义一个类成员,使它的使用完全独立于该类的任何对象。通常情况下,类成员必须通过它的类的对象访问,但是可以创建这样一个成员,它能够被它自己使用, 而不必引用特定的实例。在成员的声明前面加上...
  • C# 关键字

    2018-10-08 11:13:37
    关键字是对编译器具有特殊意义的预定义保留标识符。它们不能在程序中用作标识符,...在类声明使用 abstract 修饰符以指示某个只能是其他的基类。标记为抽象或包含在抽象中的成员必须通过从抽象派生的...
  • 通过派生只能访问重定义的版本,如果派生通过自身类型使用基类所有的重载版本,则派生要么重定义所有重载版本,要么一个也不重定义。如果基类中重载版本太多,在派生中全重定义一遍太麻烦了。 这就是...
  • 一个类通过关键字implements声明自己使用一个或者多个接口。在类的声明中,通过关键字extends来创建一个类的子类。class 子类名 extends 父类名 implenments 接口名{...}==========================================...
  •  一旦一个成员被声明为static,它能够在它的的任何对象创建之前被访问,而不必引用任何对象。  声明为static 的变量实质上就是全局变变量,当声明一个对象时,并不是staitc 变量的拷贝,...
  • static关键字

    2018-08-04 17:25:00
    static关键字: static可以修饰中的属性和方法。 使用static修饰的变量为静态变量 ...使用static修饰的方法为静态方法 ...静态变量和方法都可以直接通过类名来访问 ... 的变量分为静态变量和实例... 声明一个...
  • static 关键字

    2020-06-27 16:47:49
    修饰成员变量和成员方法:被 static 修饰的成员属于类,不属于单个这个类的某个对象,被类中所有对象共享,可以并且建议通过类名调用。被static 声明的成员变量属于静态成员变量,静态变量 存放在 Java 内存区域的...
  • 父类使用虚函数是为了让子类重写,那子类重写的时候也需要带virtual关键字吗?比如: class Base{ virtual bool init();...c++规定,当一个成员函数被声明为虚函数后,其派生中的同名函数都自动成为
  • object是Kotlin中的一个重要的关键字,也是Java中没有的。object主要有以下三种使用场景: 对象声明(Object Declaration) 伴生对象(Companion Object) 对象表达式(Object Expression) 下面就一一介绍它们所...
  • 一、static关键字的作用1、可以用于修改类的成员变量、代码块和类通过static可以将类的成员声明为静态成员,静态的成员归属于整个类,而不是属于某个对象。无论通过类还是对象访问静态成员,操作的都是同一个静态...
  •   有时,在处理数据的时候需要两个类在同一内存区域中共享一个数据。比如说,在计算圆的面积这一类中需要使用PI这个常量,同样,在计算球的体积这一类中同样也要用到。没有必要去在两个类分别创建这一个常量PI,...

空空如也

空空如也

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

一个类通过使用关键字声明