Java面向对象

最新推荐文章于 2021-02-13 19:41:17 发布
最新推荐文章于 2021-02-13 19:41:17 发布
阅读量1.4k 收藏 1
点赞数
分类专栏： Java 文章标签： Java 编程语言 面向对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011204847/article/details/51118619
版权

Java面向对象

 

 

 

面向对象

面向对象在开发中是一种运用对象、类、继承、封装、聚合、消息传递、多态等概念来构造系统的软件开发方法。

 

面向对象其实是相对于面向过程而言。

 

面向对象在开发中的优点：


减少软件的复杂性

  • 可维护性
  • 可扩展性
  • 可重用性

表述非常自然

  • 将数据和功能并在一起考虑
  • 分析和实现的隔阂变得非常小

面向对象特征：

  • 封装(encapsulation)
  • 继承(inheritance)
  • 多态(polymorphism)

 

 

 

对象

对象是系统中用来描述客观事物的一个实体，它是构成系统的基本单位。

 

对象的性质：

  • 封装性
  • 自治性
  • 通信性
  • 被动性

 

对象的特性：

  • 对象的属性和方法称作对象的特性
  • 属性值即对象的状态
  • 方法即对象的行为

 

对象的标识：

缩写（OID）

是将一个对象和其它对象加以区分的标识符

一个对象标识和对象永久结合在一起，不管这个对象状态如何变化，一直到对象消亡为止。

 

 


类

类是具有相同属性和行为的一组对象的集合，它为属于该类的全部对象提供了统一的抽象描述，其内部包括属性和行为两个主要部分

 

  1. 对象按照不同的性质划分为不同的类
  2. 同类对象在数据和操作性质方面具有共性
  3. 把一组对象的共同特性加以抽象并存贮在一个类中
  4. 类是对象之上的抽象，有了类之后，对象则是类的具体化，是类的实例
  5. 类是静态概念，对象是动态概念

 

 

 

类的作用：

  • 一是作为对象的描述机制，刻划一组对象的公共属性和行为
  • 二是作为程序的基本单位，它是支持模块化设计的设施，并且类上的分类关系是模块划分的规范标准

 

 

类与对象：

  • 属于某个类的对象称为该类的一个实例（instance）
  • 类和对象间具有instance-of关系
  • 一个实例是从一个类创建而来的对象
  • 类描述了这个实例的行为（方法）及结构（属性）

 

 

类的定义格式：

class {
//属性...
//方法...
}

代码示例：

//定义Person类
class Person {
    //定义属性name和age
    String name;
    int age;

    //定义方法speak，可以定义具有返回值的方法
    public void speak() {
        System.out.println(("name=" + name + ",age=" + age));
    }
}


 

方法

  • 定义于某一特定类上的操作与规则
  • 具有同类的对象才可为该类的方法所操作
  • 这组方法表达了该类对象的动态性质，而对于其它类的对象可能无意义，乃至非法规则，说明了对象的其他特征之间是怎样联系的，或者对象在什么条件下是可行的
  • 方法也称作行为（behavior）

 

方法格式:

权限修饰符 返回值类型  函数名(){
    //业务逻辑
}
 

代码示例：

//定义返回值类型为String,权限为public的toStr方法
public String toStr() {
    //返回值
    return name + " : " + age;
}


 

类变量

类中局部变量和成员变量(类变量)

作用范围：

  • 局部变量：这个变量所属的花括号
  • 成员变量：这个变量随着对象的消失而消失，当java的垃圾回收机制把成员变量   所属的对象回收之后，这个变量就消失了

存储位置：

  • 局部变量：栈内存中
  • 成员变量：堆内存中

初始化值：

  • 局部变量：在使用的时候必须有值
  • 成员变量：不需要初始化值。因为它存在于堆内存中。默认会被初始化、。
  • String   null
  • int         0

使用场景：

  • 如果一个变量只需要在函数内部使用，那么就可以定义在函数内部。
  • 如果后期还需要通过对象操作这个变量，那么只能定义在成员位置了。

 

 


static

静态使用场景：

  • 针对所有对象的属性值都一样的时候，这个属性就可以使用static修饰，这个时候这个属性就存在于方法区中的静态区中。被所有对象共享。
  • 针对每个对象特有的属性，这个就不能使用static修饰了。

针对静态修饰的变量有两种调用方式

  • 1：使用对象进行调用
  • 2：直接使用类名调用。

生命周期：

静态区中的变量(所属于类的) > 堆内存中对象里面的变量(所属于对象的) > 栈内存中变量(所属于当前的花括号)

注意：

在静态方法内部职能调用静态属性，如果想要调用非静态属性，必须先要获取到这个属性所属的对象。

 

静态使用场景注意事项：

成员变量

普通成员变量(实例变量)

  • 所属于对象，必须先创建对象，才能使用这个变量，这个变量是存在于堆内存中，它的生命周期和对象一样，对象消失，实例变量才消失。


静态成员变量 ( 类变量 )

  • 所属于类，不需要对象，可以直接通过类名来调用，这个变量存在于方法区的静态区中，它的生命周期和java虚拟机一样，虚拟机执行结束，类变量才消失。

成员函数

普通成员函数

  • 可以调用普通成员变量和静态成员变量。

静态成员函数

  • 只能调用静态成员变量，因为当静态成员函数被调用的时候，可能对象还不存在，所以不能调用对象中的特有属性。
  • 在静态成员函数中不能使用this关键字。

main函数(主函数)

main函数是JVM运行java程序的入口。

格式：

public static void main(String[] args) {
    //业务逻辑
}

 

每个结构表示的意义：

  1. public：是一个权限修饰符，最大权限，因为这个方法需要被虚拟机所调用，所以这个函数的权限应该设置为最大
  2. static：因为java虚拟机在调用这个方法的时候，还没有对象，所以需要静态
  3. void ：因为虚拟机不需要返回值
  4. main：就是一个函数名，一个标识符，只不过比较特殊，可以被java虚拟机识别
  5. String[]：表示是一个字符串数组，
  6. args：参数名称//arguments

静态代码块

格式：

static{
//业务逻辑
}


静态代码块一般放在类中，和构造代码块平级

作用：

可以负责对类进行初始化。

静态代码块什么时候执行：

当类被加载进内存的时候，静态代码块执行。

 

 

 

Java面向对象三大特性

封装 继承 多态

封装

封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字private实现封装。什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。

 

  • 对象的数据封装特性彻底消除了传统结构方法中数据与操作分离所带来的种种问题，提高了程序的可复用性和可维护性，降低了程序员保持数据与操作内容的负担。
  •  对象的数据封装特性还可以把对象的私有数据和公共数据分离开，保护了私有数据，减少了可能的模块间干扰，达到降低程序复杂性、提高可控性的目的。

 

代码示例：

//定义Person类
class Person {
    //封装的属性
    String name;
    int age;

    //封装的方法
    public void speak() {
        System.out.println(("name=" + name + ",age=" + age));
    }
}


 

继承

使用关键字extends实现。

格式：

class Zi extends Fu{}


继承的好处：

  • 1：简化代码量，简化书写。代码看起来比较简洁
  • 2：让类与类之间产生了关系，所以导致了面向对象的第三个特征，多态的出现。

继承的特点：

  • java只支持单继承，不支持多继承。
  • java里面支持多层继承。

到底什么时候使用继承：

  • 1：可以分析两个类之间是否有包含关系，如果有，就可以继承。
  • 2：先假设让某一个类继承另一个类，看一下继承过来的功能是不是自己应该具备的，如果是，可以继承，如果不是，则不能继承。

   继承中的成员的特点

成员变量

  • this关键字：代表当前对象的引用
  • super关键字：代表父类的存储空间

this：是为了区分成员变化和局部变量重名的情况

super：是为了区分子父类中成员变量重名的情况

 

成员函数

当子父类中出现相同函数的时候，会出现函数的覆盖(重写，复写)，也就是子类中的函数覆盖了父类中的同名函数

这个就是函数的重写(overwriter)


函数的重载(overload)

依据：只和参数列表有关

如果子父类中函数相同的时候，需要使用super调用父类中的同名函数

构造函数

默认情况下子类在创建对象的时候都会调用父类的无参的构造函数。需要使用super语句

注意，这个super语句默认是在子类的构造函数的第一行，没有显示，如果显式调用super语句的话，也必须写到子类构造函数的第一行。

this()和super()的用法类似

  • this()：表示调用当前类中的空参构造函数
  • super()：表示调用父类中的空参构造函数

那也就意味着，在子类的构造函数中不能同时存在this和super语句。

小结：

  • 在子类的构造函数中，可以调用自己的构造函数，也可以调用父类的构造函数
  • 如果需要在子类的构造函数中调用父类的有参构造函数，必须手工显式指定 super(name);
  • 子类在创建对象的时候，一定会先调用父类的构造参数进行初始化。

 

代码示例：

//定义Person类
class Person {
    //定义类的属性
    String name;
    int age;

    //定义类的方法
    public void speak() {
        System.out.println(("name=" + name + ",age=" + age));
    }
}

//继承Person类
class employee extends Person{
    @Override
    public void speak() {
        System.out.println("this is employee");
    }
}


  

多态

体现：

  • 父类引用或者接口引用指向子类对象

Animal a = new Cat();//animal是cat的父类
Inter i  = new InterImpl();//interimpl是inter接口的实现类

作用：多态的存在提高了程序的扩展性和后期可维护性

前提：类与类之间需要存在继承或者实现关系，要有覆盖操作

弊端：只能调用父类或者接口中已经定义的功能，在执行的时候会执行对应子类或者实现类中的功能。


类型强制转换动作和判断实例动作(instanceof)一般会在一块使用。

if(c instanceof Dog){
Dog d = (Dog)c;
d.lookDoor();
}

多态中成员的特点：

成员变量

编译的时候，看等号左边

执行的时候，看等号左边

非静态成员函数

编译的时候：看等号左边

执行的时候：看等号右边

静态函数

编译的时候，看等号左边

执行的时候，看等号左边

小结：

  • 成员变量和静态函数：编译和执行都看等号左边
  • 非静态成员函数编译看左边，执行看右边

 



final关键字

final关键字可以修饰不同东西

1：修饰类

这个类就是一个最终类，不能被继承。


2：修饰函数

这个函数就是一个最终函数，在子类中不能被覆盖。


3：修饰变量

这个变量的值就是一个最终值，不能被修改，只能被显式初始化一次。

final修饰的变量必须要被初始化。

一般使用final修改一个常量的时候会和static组合使用，注意：static和final的位置可以互换

如果在函数上定义static和final的时候，一般放在public后面 返回数据类型前面

小结：

  • 1：当类中的所有函数不希望被重写的话，可以使用final修饰这个类，就变成了最终类，不能被继承。
  • 2：当类中某一些方法不希望被重写的时候，需要在方法定义中加上final
  • 3：如果变量的值是一个固定值，或者说是一个常量，这样可以使用final修改，一般还会加上static

 

抽象类

如果类中有抽象函数，那么类也必须是抽象的。

 

抽象类的特点：

  • 1：抽象类不能被new，因为调用抽象函数没有意义。
  • 2：如果父类中有多个抽象函数，子类要么全部实现，要么子类定义成抽象的。
  • 3：抽象类和普通类的区别只是说抽象类中有抽象方法而已，那也就是说抽象类中是有构造函数的，因为子类继承这个抽象类的时候，也需要Udine抽象类中的属性进行初始化。
  • 4：抽象类中可以没有抽象方法
  • 5：继承中的覆盖注意事项（子类想要重写父类中的函数，子类必须要保证自己的函数的访问权限大于等于父类中需要覆盖的函数的访问权限）



接口

特点：

  • 接口中的方法全部都是抽象方法，
  • 相当于是抽象类的一个特殊体现形式

成员特点：

成员函数

接口中的所有函数默认情况下都是抽象的，并且权限修饰符默认都是public，所以在定义的函数的时候，public abstract都可以省略


成员变量

默认情况向接口中的所有变量都是被public static final修饰

特性：

类只能单继承

class A extends B//只支持这中格式

接口可以多实现

class A implements B,C,D//支持实现多个接口 BCD 都是接口

抽象类(普通类)里面一般定义的东西：

都是一些事物共性的属性或行为


接口里面一般定义的东西：

一些扩展的东西

class A extends AbstractDemo implements Inter,Inter2{
   //业务逻辑
}

 

继承和实现的区别：

继承：extends

一个类继承一个抽象类，因为抽象类中可以存在非抽象方法，所以子类可以把父类中的非抽象方法直接继承过来使用。


实现：implements

因为接口中全部都是抽象方法，这些方法全部都需要进行实现，所以说一个类需要实现一个接口。

多继承的特性(了解)

interface A{}
interface B{}
interface C extends A,B{}//正确的 接口之间可以多继承
class A1{}
class B1{}
class C1 extends A1,B1{}//错误的，java中的类不支持多继承


 

object类中的方法

boolean equals(Object obj)

：比较两个对象是否相等，默认是比较内存地址值，这个意义不大，所以在工作中如果需要对对象进行比较的话，一般会重写此方法，实现自己的比较逻辑。


String toString()

：默认会打印对象的名称和内存地址值，但是打印这个意义不是很大，所以工作中一般会进行覆盖，在这个方法中把对象的基本属性信息给打印出去


Class getClass()

：获取当前对象的字节码文件对象，然后根据这个对象就可以获取字节码中保存的类的名称等信息getName和getSimpleName

int hashCode()

：返回的是对象在内存中的地址值

 

 

内部类

格式：

class Outer//外部
{
private int num;
class Inter//内部类，可以在成员位置
{
show(){
}
}
public void method(){
Inter inter = new Inter();
inter.show();
}
}


特点：

  • 1：内部类可以使用外部类中的所有属性，包括私有的
  • 2：如果外部类向访问内部类中的成员的话，默认情况下是需要创建内部类对象的

什么时候需要定义内部类呢？

假设A类可以随意访问B类中的属性，但是B类在访问A类中的属性的时候，需要创建A类的对象，才能调用

class B{
class A{
}
}
class Body{//身体
priavte class Heart{//心脏
}
public Heart method(){
if(是医生){
return new Heart();
}
return null;//Heart h = null;
}
}

如何在main函数中获取内部类对象(前提条件：内部类没有私有化)

//外部类名.内部类名 变量名 = 外部类对象.内部类对象
//内部类和函数都是普通的
//Outer.Inter io = new Outer().new Inter();
//io.show();
 
//如果内部类是静态的时候
//Outer.Inter io1 = new Outer.Inter();
//io1.show();
//如果内部类和调用的函数都是静态
Outer.Inter.show();


注意：

  • 如果内部类中有静态成员，那么这个内部类也需要静态。
  • 如果内部类中的函数是静态的，那么在这个函数内部就只能调用外部类的静态成员了。

内部类也可以放在函数内部

在这个位置的时候，需要注意：如果这个局部内部类访问到了函数的局部变量的时候，这个局部变量必须是final类型的。

内部类的命名：

Outer$1Inter.class
Outer$Inter2.class
Outer$1Inter.class
Outer$1Inter3.class


异常

Throwable

  • Error
  • Exception


处理方法有两种：

1：try-catch代码块

try{
//待检测的代码，也就是在运行时可能出现问题的代码
}catch(Exception e){//Exception e = new ArithmeticException();
//对异常情况进行处理
}


2：throws Exception

工作中针对异常到底使用哪种处理方案呢？

如果这个异常我能处理，就处理，不能处理的就抛出去。

jvm默认对异常的处理方式是这样的

  • 1：调用异常对象的printStackTrace()，打印异常出现的位置，具体的错误信息等内容
  • 2：退出程序

Exception包含两种异常

编译时异常：在编译的时候，如果没有处理，程序就会报错

如果调用的函数抛出了编译时异常，那么在使用这个函数的时候，必须要对这个异常进行处理。

包含Exception和（非runtimeException及其子类）


非编译时异常(运行时异常)：编译时不会报错，运行的时候才会报错

这种异常在调用的时候不需要进行处理。因为一般抛出这种异常的时候是想希望让程序停掉。

runtimeException 以及子类

运行时异常，一般不建议使用try-catch进行捕获处理，如果真想处理，也可以使用try-catch

什么时候抛出runtimeException：

下面例子中在调用div之后的代码的运算逻辑需要使用x(除法运算的结果)的值，也就是说，

如果除法运算出错了，那么后面的代码再执行就没有意义了。

那么这个时候，就可以在div方法上抛出一个运行时异常，main方法再调用的时候就不需要进行处理了，

如果除法运算在执行的时候真是出现了问题，那么就希望把程序停掉即可。

class Demo11{
public static void main(String[] args) {
Test t = new Test();
int x = t.div(10,0);
System.out.println(x);
System.out.println("hehe"+x);
}
}
class Test{
//除法运算
public int div(int a,int b) throws RuntimeException {//这也是一种对异常的处理方法
return a/b;
}
}


try-catch-finally

组合可以有下面这几种

  • try-catch
  • try-finally：这样对代码处理之后，如果是编译时异常，还是需要进程throws的，catch里面才是真正处理的代码。
  • try-catch-finally
  • try-catch-catch-catch.......-finally：针对函数抛出多个异常类，这样在处理的时候，可以分别进程catch，也可以catch一个顶层父类(Exception)

如果函数抛出的多个异常有父子关系，那么在写多个catch语句的时候，子类的异常需要先捕获，父类异常写在最下面的一个catch中。

父子类中进行函数覆盖的时候，如果父类的函数中抛出了异常，那么子类只能抛出父类异常的子类或者子集，子类中不能抛出未知的异常

如果子类中确实有新的异常产生，那么只能try-catch处理掉。

throws和throw

  • throws：用在函数上，用于向外声明异常，让上一级处理。后面跟的是异常类，可以跟多个

  • throw：用在函数内部，用户抛出异常对象。让函数处理这个异常。



设计模式

表示是解决某一个类问题最行之有效的方法。

Java有23种设计模式

比如单例设计模式

：这个设计模式可以保证在内存中一个对象只存在一份。

例子：现在有A程序和B程序，

使用场景：

  • 1：保证其他地方不能创建这个config的对象，
  • 2：我们自己创建一个对象，把这个对象对外开放出去
  • 3：对外提供公共的访问方式

代码实现过程：

  • 1：私有化构造函数
  • 2：在类中创建一个私有对象
  • 3：对外提供一份public的静态方法，把刚才创建的对象返回出去


 

 

聆听的幻树
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【笔记总结】C++面向对象三大特征（四大特征）
weixin_43965063的博客
05-28 1858
C++面向对象的三大特征（四大特征） 三大特征：封装、继承、多态 四大特征：抽象、封装、继承、多态 一、类和对象 什么是类，什么是对象，类和对象的区别？ 类是数据类型，是具有相同属性和服务的一组对象的集合。对一类对象的抽象就是类。 对象即观察研究对象，是类这种数据类型创建出的实例（相当于结构变量）。 类与对象的区别： 1、类是一个抽象的概念，类只是为所有的对象定义了抽象的属性和行为；对象是类的一个具体，是实体。 2、类是静态概念，本身不携带任何数据；对象是动态概念，每个对象都有自己独特的属性和行为，且它
intdiv() 函数
adf1256的博客
09-11 1376
PHP7 新增加了 intdiv() 函数，接收两个参数，返回值为第一个参数除于第二个参数的值并取整。 实例 1 2 3 4 5 6 7 <?php echo intdiv(9,3),PHP_EOL; echo intdiv(10,3),PHP_EOL; echo intdiv(5,10),PHP_EOL...
Groovy入门经典 随书重点
weixin_34302561的博客
06-07 103
1 数值和表达式 1.1数值 整数是Integer类的实例 有小数部分的数值是BigDecimal类的实例 不同于java，没有基础数据类型一切皆对象的概念重于java 1.2表达式 两个整数的除法运算通常会产生一个浮点数 获得两个整型值相除的整数部分，使用#intdiv 浮点数取模非法 1.3运算优先级 */% 优先于 +- 1....
java 减法 位运算_通过位运算实现两个数的加、减、乘、除-JAVA成长之路
weixin_39976960的博客
02-13 306
//通过位运算实现两个数的加、减、乘、除publicclassBitSuan{//(1)加法运算publicstaticintadd(inta,intb){intsum=a;while(b!=){//a与b无进位相加sum=a^b;b=(a&b)a=sum;}returnsum;}//负数按位置取反+1publicstaticintnegNum(intn){returnadd(~n,1);...
Java程序中异常的相关知识
nancy199006的专栏
02-05 470
package Java学习; /** * * @author zhaocx1 * */ /* * 异常：就是程序在运行时出现不正常情况。 * 异常由来：问题也是现实生活中一个具体的事物，也可以通过Java的类的形式进行描述，并封装成对象。 * 其实就是Java对不正常情况进行描述后的对象体现。 * 把问题封装成对象就是异常。 * 对于问题的划分：两种：一种
java面向对象编程pdf
04-16
Java面向对象编程PDF 在这篇文章中，我们将对Java面向对象编程的基础知识进行总结和解释。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为...
Java面向对象程序设计+源代码+课后习题答案)
10-31
Java面向对象程序设计是计算机科学中的一个重要领域，它基于面向对象编程（OOP）的概念，是一种强大的编程范式。在Java中，OOP的核心概念包括类、对象、封装、继承、多态等。这本书"Java面向对象程序设计"由耿祥义和...
java 面向对象 案例 合集
最新发布
07-18
java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 ...
JAVA面向对象
12-22
面向对象三大特征4. this关键字5. 构造方法6. 标准的类结构7. 匿名对象8. 对象数组9. ArrayList类10. ArrayList常用方法 1. 类的定义 成员变量 直接定义在类中，在方法外。 成员方法 不写static关键字。 public ...
java new左边_Java中的类与对象
weixin_39672296的博客
02-13 488
一、对象的内存分析1.程序运行会把class文件加载到内存Text.class,Person.class2.虚拟机调用Test类的main方法，进栈执行3.逐行执行主方法中的代码4.Person p = new Person();先执行等号右边，然后赋值给等号左边看到new就是创建对象，new会做的事情：1)在堆中为这个对象开辟空间，这个类型的成员属性，会跟随对象进入到堆的内存中2)把对象在堆内存...
php-------面向对象详解
weixin_38166852的博客
06-07 162
php面向对象详解 面向对象 对象概念是面向对象技术的核心。在显示世界里我们所面对的事情都是对象，如计算机、电视机、自行车等。在面向对象的程序设计中，对象是一个由信息及对信息进行处理的描述所组成的整体，是对现实世界的抽象. 对象的主要三个特性 对象的行为：可以对 面向对象 对象概...
【转】使用静态内部类提高封装性
weixin_30455067的博客
11-29 133
使用静态内部类提高封装性 转自这里 Java中的嵌套类（Nested Class）分为两种：静态内部类（也叫静态嵌套类，Static Nested Class）和内部类（Inner Class）。内部类我们介绍过很多了，现在来看看静态内部类。什么是静态内部类呢？是内部类，并且是静态（static修饰）的即为静态内部类。只有在是静态内部类的情况下才能把static修复符放在类前，其他任何时候s...
【面向对象】Part 1 基本概念
u014255299的专栏
03-15 643
OOP定义 1 一切都是对象。 2 计算通过对象间相互通信，请求其他对象执行动作来实现。对象间通过发送和接收消息来通信。 3 每个对象都有自己的内存，其中可能包括了其他的对象。 4 每一个对象都是某个某个类的实例。类就是一组相似的对象。 5 类是对象相关行为的存储库。也就是说，同一个类的所有对象都能执行同样的动作。 6 类被组织成有单个根节点的树状结构，被称为继承层次结构。与类实例相关的
ES6 类(Class)基本用法和静态属性+方法详解
热门推荐
pcaxb的专栏
12-20 11万+
转载请注明预见才能遇见的博客：http://my.csdn.net/ 原文地址： ES6 类(Class)基本用法和静态属性+方法详解 JavaScript语言的传统方法是通过构造函数,定义并生成新对象,prototype 属性使您有能力向对象添加属性和方法。下面是通过传统的方式创建和使用对象的案例: //Person.js function Person(x,y){ this
PHP 面向对象整理
chenx221105的博客
11-12 161
类的声明 1、使用class关键字和一个任意的类名来声明类 2、类名可以是任意的字符和数字的组合，但不能以数字开头 3、和类关联的代码必需使用大括号括起来 4、类中包含属性和方法 //举例说明 <? class perso...
在类的内部使用类中属性时，类名.属性名和self.属性名的异同
面向学姐编程
08-30 2403
在python中，定义了结构之后就产生了相应的命名空间，对类和函数的定义都会形成相应的命名空间。但是在两者的命名空间中有个差别值得我们关注，尤其在定义类中的函数时应该注意类命名空间的特性。 定义函数时产生的命名空间 定义一个简单函数： def foo(): a = 1 b = 2 c = 3 d = a + b + c print(d) ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值