面向对象开发技术05_消息、实例和初始化

最新推荐文章于 2024-04-30 17:28:01 发布
最新推荐文章于 2024-04-30 17:28:01 发布
阅读量1.5k 收藏 6
点赞数 1
分类专栏： 面向对象 文章标签： java 开发语言 其他 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52370024/article/details/125284495
版权

05 消息、实例和初始化

1.消息

对象间相互请求或相互协作的途径。

面向对象消息模型

  • 对象作为用传递消息的方式互相联系的通信实体 ，既可以接收也可以拒绝外界发来的消息

对象接收它能识别的消息
拒绝它不能识别的消息

对象不可能在不可预知或事先不允许的方式下与其他对象交互

发送消息的流程

考虑对象A向对象B发送消息，也可以看成对象A向对象B请求服务

  • 对象A要明确知道对象B提供什么样的服务
  • 根据请求服务的不同，对象A可能需要给对象B一些额外的信息，以使对象B明确知道如何处理该服务
  • 对象B可将最终的执行结果以报告形式反馈回去

消息传递语法

  • 消息→接收器。
  • 响应行为随接收器不同而不同。
    在这里插入图片描述

2.静态与动态语言

动/静态类型语言

  1. 动态类型语言(Dynamically Typed Language ):变量看作名称标识，类型和数值联系在一起
  • 类型的检查是在运行时做的;
  • 一般在变量使用之前不需要声明变量类型，而变量的类型通常是由被赋的值的类型决定。
  • 优点是方便阅读，不需要写非常多的类型相关的代码
  • 缺点是不方便调试，命名不规范时会造成读不懂，不利于理解等
  • 如php、Python和Ruby。
  1. 静态类型语言(Statically Typed Language ):类型和变量联系在一起
  • 类型的检查是在编译时做的.
  • 在编译时，便需要确定类型的语言。即写程序时需要明确声明变量类型。
  • 如C/C++、Java、C#等。
  • 优点在于其结构非常规范，便于调试，方便类型安全；
  • 缺点是为此需要写更多的类型相关代码，导致不便于阅读、不清晰明了
  • 编译时作出内存分配决定。不必运行时刻重新分配。
  • 控制类型错误。

面向对象静态
C++,Delphi pascal,Eiffel,Java
面向对象动态
Objective-c,Smalltalk,Dylan,Python
非面向对象静态
Ada,Algol,C,Fortran,Haskell,ML,Modula
非面向对象动态
APL,Forth,Lisp,Prolog,Snobol

动态类型语言与静态类型语言之间的差异在于变量或数值是否具备类型这种特性。

伪变量

  • 大多数面向对象语言中，接收器并不出现在方法的参数列表中，而是隐藏于方法的定义之中。只有当必须从方法体内部去存取接收器的数值时，才会使用伪变量(pseudo-variable)。
  • 伪变量和通常的变量很相似，只是它不需要声明，也不能被更改（也许用伪常量这一术语更加合适，但是这一术语好像没有出现在任何语言的定义中）

Java, C++: this
Eiffel: Current
Smalltalk, object-c: self

伪变量在使用时就好像是作为类的一个实例。

  • 在很多编程语言中，对接收器伪变量的使用都可以忽略。
  • 如果在没有引用接收器的条件下，访问一个数据字段或者调用一个方法，那么这意味着接收器伪变量将作为消息的主体。
Java中this的使用
  • 使用this关键字引用成员变量
  • 使用this关键字在自身构造方法内部引用其它构造方法
  • 使用this关键字引用成员方法
  • 使用this关键字代表自身类的对象
使用this关键字引用成员变量

在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的格式来引用成员变量名，有些时候可以省略，有些时候不能省略

public class ReferenceVariable {
	private int a;
	public ReferenceVariable(int a){
		this.a = a;
	}
	public int getA(){
		return a;
	}
	public void setA(int a){
		this.a = a;
		}
	}

java语言规定当变量作用范围重叠时，作用域小的变量覆盖作用域大的变量。所以在构造方法和setA方法内部，参数a起作用。
这样如果访问成员变量a则必须使用this进行引用。

引用构造方法
public class ThisTest {
    private int i=0;
    //  第一个构造器：有一个String型形参
    ThisTest(String s){
       System.out.println("String constructor:  "+s);
    }
    //  第二个构造器：有一个int型形参和一个String型形参
    ThisTest(int i,String s){
       this(s);//this调用第一个构造器
       this.i=i++;//this以引用该类的成员变量
       System.out.println("Int constructor:  "+i+"/n"+"String constructor:  "+s);
    }

注意：

  1. 其他任何方法都不能调用构造器，只有构造方法能调用它。
  2. 就算是构造方法调用构造器，也必须位于其第一行，构造方法也只能调用一个且仅一次构造器！
使用this关键字代表自身类的对象
public class ThisTest {
    private int i=0;
    //第一个构造器：有一个int型形参
    ThisTest(int i){
       this.i=i+1;//此时this表示引用成员变量ｉ，而非函数参数ｉ
       System.out.println("Int constructor i——this.i:  "+i+"——"+this.i);
       System.out.println("i-1:"+(i-1)+"this.i+1:"+(this.i+1));
       //从两个输出结果充分证明了i和this.i是不一样的！
    }
    public ThisTest increment(){
       this.i++;
       return this;//返回的是当前的对象，该对象属于（ThisTest）
    }
    public static void main(String[] args){
       ThisTest t0=new ThisTest(10);
       System.out.println(t0.increment().increment().increment().i);
       //t0.increment()返回一个在t0基础上i++的ThisTest对象，
       //接着又返回在上面返回的对象基础上i++的ThisTest对象！
    }
}

Java:构造函数中，使用this区分参数和数据成员。

3.对象创建

类的实例

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

类及实例具有下面特征

  • 同一个类的不同实例具有相同的数据结构，承受的是同一方法集合所定义的操作，因而具有相同的行为
  • 同一个类的不同实例可以持有不同的值，因而可以有不同的状态
  • 实例的初始状态（初值）可以在实例化中确定

对象=状态(实例变量)+行为(方法)

  • 对象外部看，客户只能看到对象的行为；对象内部看，方法通过修改对象的状态，以及和其他对象的相互作用，提供了适当的行为

内存划分：对象创建之初

public class ClassDemo02 {
	public static void main(String args[]){
		Person per = new Person() ;
	}
}

在这里插入图片描述

public class ClassDemo03 {
	public static void main(String args[]){
		Person per = new Person() ;
		per.name = "张三" ; 		// 为属性赋值
		per.age = 30 ;
		per.tell() ; 			// 调用类中的方法
	}
}

在这里插入图片描述
声明多个变量的情况：

public class ClassDemo04 {
	public static void main(String args[]) {
	 Person per1 = null;	// 声明per1对象
	 Person per2 = null;	// 声明per2对象
	 per1 = new Person();	// 实例化per1对象
	 per2 = new Person();	// 实例化per2对象
	 per1.name = "张三";	// 设置per1对象的name属性内容
	 per1.age = 30;	// 设置per1对象的age属性内容
	 per2.name = "李四";	// 设置per2对象的name属性内容
	 per2.age = 33;	// 设置per2对象的age属性内容
		System.out.print("per1对象中的内容 --> ") ;
		per1.tell();		// per1调用方法
		System.out.print("per2对象中的内容 --> ") ;
		per2.tell();		// per2调用方法
	}
}

在这里插入图片描述

public class ClassDemo05 {
	public static void main(String args[]) {
	  Person per1 = null;	// 声明per1对象
	  Person per2 = null;	// 声明per2对象
	  per1 = new Person();	// 只实例化per1一个对象
	  per2 = per1 ;// 把per1的堆内存空间使用权给per2 
	  per1.name = "张三";// 设置per1对象的name属性内容
	  per1.age = 30;	// 设置per1对象的age属性内容
	// 设置per2对象的内容，实际上就是设置per1对象的内容
	  per2.age = 33;
	  System.out.print("per1对象中的内容 --> ") ;
	  per1.tell();		// 调用类中的方法
	  System.out.print("per2对象中的内容 --> ") ;
	  per2.tell();
	}
}

在这里插入图片描述

对象的创建

  1. 变量声明与初始化结合
PlayingCard aCard = new PlayingCard(Diamond, 3);
  1. 变量声明与创建分离
  • 变量的声明只是创建一个标识变量的名称。
  • 为了创建对象，程序员必须执行另外的操作。通常这一操作是由new 操作符来表示

对象数组的创建

  1. 数组的分配和创建
  2. 数组所包含对象的分配和创建

C++:结合
对象使用缺省构造函数来初始化。
数组由对象组成，每个对象则使用缺省（即无参数）构造函数来进行初始化

PlayingCard *cardArray[52];

Java:new仅创建数组。数组包含的对象必须独立创建。

PlayingCard cardArray[ ] = new PlayingCard[13];
for (int i = 0; i < 13; i++)
	cardArray[i] = new PlayingCard(Spade,i+1);

4.内存的分配与回收

指针和内存分配

Java无指针？

  • 所有面向对象语言在它们的底层表示中都使用指针，但不是所有的语言都把这种指针暴露程序员。
  • 有的时候人们把“Java 语言没有指针”作为Java 和C++语言相比较时的特点，其实更加确切的说法是Java 语言没有程序员可以看到的指针，因为所有的对象引用实际上就是存在于内部表示中的指针。
  • 对象引用实际是存在于内部表示中的指针。
  • Person x = new Person();//这里就含有一个变量x，没错，这个引用型变量，实质上就是指针

指针问题

  • 指针引用堆分配内存。指针变量生存期？

对于堆分配的变量值，只要存在对它的引用，就会一直存在，因此，变量值的生存期一般长于创建该变量过程的生存期。

  • 堆分配的内存必须通过某种方式回收。
  • 某些语言中，指针和传统变量有区别。

内存回收

  • 使用new创建——堆内存
  • 堆内存没有绑定在过程的入口和出口处。
  • 内存有限
public class ClassDemo06 {
	public static void main(String args[]) {
		Person per1 = null;	// 声明一个per1对象
		Person per2 = null;	// 声明一个per2对象
		per1 = new Person();	// 实例化per1对象
		per2 = new Person() ;	// 实例化per2对象
		per1.name = "张三";	// 设置per1的name属性内容
		per1.age = 30;		// 设置per1的age属性内容
		per2.name = "李四" ;	// 设置per2的name属性内容
		per2.age = 33 ;	// 设置per2的age属性内容
		per2 = per1 ;		// 将per1的引用传递给per2
		System.out.print("per1对象中的内容 --> ") ;
		per1.tell();		// 调用类中的方法
		System.out.print("per2对象中的内容 --> ") ;
		per2.tell();
	}
}

在这里插入图片描述

内存回收——回收策略

  1. 在程序中不再使用的对象，将其使用内存回收。

C++:delete
Object Pascal:free

  1. 垃圾回收机制(Java,C#,Smalltalk)
  • 时刻监控对象的操作，对象不再使用时，自动回收其所占内存。
  • 通常在内存将要耗尽时工作。

比较

付出额外代价：

  • 需要将正在执行的应用程序挂起，回收完成后，程序恢复执行
  • 避免释放多次；避免使用已被释放内存；避免耗尽内存。

静态数据字段/静态数据成员

被一个类的所有实例共享的公共数据字段。

Java和C++使用修饰符static创建共享数据字段。
Java:静态数据字段的初始化是在加载类时，执行静态块来完成。

static关键字

1.用static修饰数据成员

利用static关键字修饰的数据成员称为静态数据成员/静态数据字段/静态变量/类成员，也称为静态成员（全局成员)。

static 数据类型 数据成员名;

类名.静态成员;

static不能修饰局部变量！

2.用static修饰成员方法

利用static关键字修饰的成员方法为类方法/静态成员方法，类方法可以由类直接调用。

静态方法与非静态方法、静态数据成员与非静态数据成员之间的调用关系：
在这里插入图片描述

结论：静态成员不需要实例化就存在，而非静态成员是实例化后才有的成员，在没有实例化之前非静态成员并不存在。因此可以利用仅仅在某一时刻存在的对象访问普遍存在的对象；而不能用一个普遍存在的对象访问仅仅在某一时刻存在的对象。

类的数据字段（静态数据字段）

对象本身不对共享字段初始化。内存管理器自动将共享数据初始化为某特定值，每个实例去测试该特定值。第一个进行测试的做初始化。

  • Java中，静态数据字段的初始化是在加载类时，执行静态块来完成。
  1. 静态数据字段（静态变量）与静态方法都是在类从磁盘加载至内存后被创建的，与类同时存在，同时消亡。
  2. 静态变量又称类变量，在类中是全局变量，可以被类中的所有方法调用。
  3. 只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。 以下是各类型变量初始化值列表：

在类内可以访问所有的static数据成员，采用直接访问方式。

静态成员函数（类方法）

  • 成员函数。不能访问非静态成员。
  • 无this
  • 构造和析构函数不能为静态成员。

静态方法和实例方法

  • 使用static修饰的方法称为静态方法
  • 使用实例对象调用的方法叫做实例方法

在这里插入图片描述

5.构造函数

在这里插入图片描述
初始化新创建对象。

  • 优点:确保初始化之前不会被使用，防多次调用

当创建和初始化分离时（当使用没有构造函数的编程语言时），程序员在创建新对象之后，很容易忘记调用初始化例程，这样通常会导致不良后果

  • Java/C++:名称，返回值
  • Java和C#中数据字段可以初始化为特定的数值。
  • 构造函数与普通方法的另外一个细微的差异就是构造函数不声明返回值的数据类型
  • 构造函数重载：只要每个函数参数的数目、类型或次序不同，就允许多个函数使用相同的名称定义
class Complex { // complex numbers
	public Complex (double rv) { realPart = rv; }
	public double realPart = 0.0; // initialize data areas
	public double imagPart = 0.0; // to zero
}

在构造函数的声明中一定要牢记以下几点：

  • 构造方法的名称必须与类名称一致
  • 构造方法的声明处不能有任何返回值类型的声明
  • 不能在构造方法中使用return返回一个值
class Person {
	public Person(){			// 声明构造方法
	System.out.println("一个新的Person对象产生。") ;
	}
}
public class ConsDemo01 {
	public static void main(String args[]) {
    System.out.println("声明对象：Person per = null ;") ;
	Person per = null ;// 声明对象时不调用构造方法
 System.out.println("实例化对象：per = new Person() ;") ;
	per = new Person();// 实例化对象时调用构造方法
	}
}

运行结果：
在这里插入图片描述

构造函数/方法

  • 构造方法是隐式调用的。

每次在创建新的对象实例时，会强制执行一次来构造方法

  • 构造方法也可以由程序员显式地调用

在子类中调用父类的构造方法

  • 构造方法会有的：

缺省构造方法：没有参数的构造方法。如果程序员不提供任何来构造方法，则编译程序自动提供一个构造方法；只要程序员提供了一个构造方法，系统不再提供缺省构造方法
编译程序提供的缺省构造方法只做一件事：调用父类的缺省构造方法

New 语法

Java：

PlayingCard cardSeven = new PlayingCard(); // Java

C++：

PlayingCard *cardEight = new PlayingCard; // C++

final关键字

  • 根据程序上下文环境，Java关键字final有“无法改变”或者“终态”的含义
  • 它可以修饰非抽象类、非抽象类成员方法和变量
  • final类不能被继承，没有子类，final类中的方法默认是final的
  • final方法不能被子类的方法覆盖，但可以被继承
  • final成员变量表示常量，只能被赋值一次，赋值后值不再改变
  • final不能用于修饰构造方法。
final类
  • 在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会被扩展，那么就设计为final类。
  • 这种类通常我们称为完美类
final方法
  • 如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。
  • 使用final方法的原因有二：
    1. 把方法锁定，防止任何继承类修改它的意义和实现。
    2. 高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。
final变量（常量）
  • 用final修饰的成员变量表示常量，值一旦给定就无法改变
  • final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。
  • 一旦给final变量初值后，值就不能再改变了。
static final int i2 = 99;
  • final变量定义的时候，可以先声明，而不给初值，这种变量也称为空白final，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，空白final在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同， 却有保持其恒定不变的特征。
class BlankFinal { 
  final int i = 0; // Initialized final 
  final int j; // Blank final 
// Blank finals MUST be initialized   // in the constructor:   
	BlankFinal() { 
    		j = 1; // Initialize blank final     
		p = new Poppet();   
	} 
  	BlankFinal(int x) { 
    		j = x; // Initialize blank final     
		p = new Poppet();   
	} 
  	public static void main(String[] args) {     
		BlankFinal bf = new BlankFinal();   
	} 
}

final仅断言相关变量不会赋予新值，并不能阻止在对象内部对变量值进行改变。如对消息的响应。

class Box {
public void setValue (int v);
public int getValue () { return v; }
private int v = 0;
}

final Box aBox = new Box(); // can be assigned only once
aBox.setValue(8); // but can change
aBox.setValue(12); // as often as you like

END

皓哥好运来
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
消息推送实例
05-25
消息推送
面向对象中的发消息是什么
guoyp2126的博客
03-11 732
高层模块：指的是调用方，如A类中调用B类实例的方法，则称A所在的类为高层模块 发消息：实际就是方法调用，如：A的实例中调用B实例的方法，就是A给B发送消息，消息名就是B中方法名，消息参数就是方法参数 抽象：指的是接口或抽象类 抽象方法：只定义了名称和参数，但没有实现的方法 具体类：能够创建程序运行中实例对象的类 ...
面向对象技术
我有满天星辰的博客
05-14 808
抽象工厂模式。提供一个接口，可以创建一系列相关或相互依赖的对象，而无需指定它们具体的类抽象接口Builder构建器模式将一个复杂类的表示与其构造相分离,使得相同的构建过程能够得出不同的表示。类和构造分离工厂方法模式。定义一个创建对象的接口，但由子类决定需要实例化哪一个类。使得子类实例化过程推迟。子类决定实例化。Prototype原型模式用原型实例指定创建对象的类型，并且通过拷贝这个原型来创建新的对象。原型实例，拷贝Singleton单例模式。
面向对象
AMw123456en的专栏
09-02 374
面向对象其实是现实世界模型的自然延伸。现实世界中任何实体都可以看做是对象。对象之间通过消息相互作用。另外，现实世界中任何实体都可归属于某类事物，任何对象都是某一类事物的实例。如果说传统的过程式编程语言是以过程为中心、以算法为驱动的话，面向对象的编程语言则是以对象为中心，以消息为驱动。用公式表示，过程式编程语言为：程序=算法+数据；面向对象编程语言为：程序=对象+消息。所有面向对象编程语言都支持
《UML面向对象设计基础》—第1章1.5节消息
weixin_33889665的博客
05-02 245
本节书摘来自异步社区《UML面向对象设计基础》一书中的第1章1.5节消息，作者【美】Meliir Page-Jones，更多章节内容可以访问云栖社区“异步社区”公众号查看。 1.5　消息UML面向对象设计基础对象通过消息请求另一个对象执行活动。许多消息还具有将信息从一个对象传送给另一个对象的作用。大多数老前辈都将消息列为重要的面向对象特性。 消息(mes...
面向对象——基本概念
wxh0417的专栏
06-19 666
<br />面向对象=对象(Object)+分类(Classification)+继承(inheritance)+通过消息的通信(communication witch message)<br /> <br />1.对象：<br />即指现实世界中各种各样的实体。它可以指具体的事物也可以指抽象的事物。包括数据(属性)，及作用于数据的操作(行为)。<br />2.消息：<br />消息是指对象间相互联系和相互作用的方式。一个消息主要由5部分组成：发送消息的对象、接收消息的对象、消息传递办法、消息内容（参数）、
发布 python-message，一个面向消息编程的程序库
赖勇浩的编程私伙局
12-09 9922
前段时间，我发过一篇文章（见：http://blog.csdn.net/lanphaday/archive/2010/11/29 /6043605.aspx），讲了几个我希望能够在 Python 看到的几个特性，其中第三个 message-oriented programming 是很容易实现的，所以我就尝试着把它做出来了，今天在这里公布一下。
4-5 类和方法，消息、实例、初始化
qq_60987997的博客
06-17 203
这就是内部类。Java内部类被连接到外部类的具体实例上，并且允许。
类初始化和实例初始化
xiaomengqy的博客
03-27 304
类初始化和实例初始化 类初始化过程： 一个类要创建实例需要先加载并初始化该类 - main方法所在的类需要先加载和初始化 一个子类要初始化需要先初始化父类 一个类初始化就是执行clinit()方法 - clinit()方法由静态类变量显式赋值代码和静态代码块组成 - 类变量显式赋值代码和静态代码块代码从上到下顺序执行 - clinit()方法只执行一次 /* 父类的初始化<clini...
消息处理实例解说
行者
02-19 1127
Message处理消息，Folder存放Message消息，一个Message消息可以放入多个文件夹Folder，一个Folder可以存放多个Message 按照此种方式设置了Message类插入消息，移除消息，将消息放入所有文件夹，移除所有文件夹中的消息，Folder类存放消息，移除消息 class Folder; class Message { public: Message(const
Python语言面向对象概念之实例、类对象、类属性、类方法、静态方法
01-21
使用面向对象方式进行程序开发，首先是设计类； 其次是使用**类名()**创建对象，而创建对象又分为两步： （1）使用__new__()方法在内存中为对象分配空间； （2）调用初始化方法__init__()为对象初始化； 对象创建后...
python面向对象之类属性和类方法案例分析
12-23
本文实例讲述了python面向对象之类属性和类方法。分享给大家供大家参考，具体如下： 目标 类的结构 类属性和实例属性 类方法和静态方法 01. 类的结构 1.1 术语 —— 实例 使用面相对象开发，第 1 步 是设计 类 使用 ...
(第18讲) PHP面向对象开发的学习（二）
11-14
1、创建一个和多个对象 2、对象中的$this关键字 3、初始化对象 __construct() 4、析构函数 __destruct()
PHP 面向对象技术(全面讲解).txt
04-21
分为4 段，栈空间段、堆空间段、代码段、初始化静态段，程序里面不同的声明放在不同的内存段 里面，栈空间段是存储占用相同空间长度并且占用空间小的数据类型的地方，比如说整型1，10， 100，1000，10000，100000 ...
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 875
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 858
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
最新发布
yajunjiao的专栏
04-30 261
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 360
待更新。
pycharm面向对象
10-18
PyCharm是一款非常流行的Python集成开发环境（IDE），它支持面向对象编程。在PyCharm中，你可以使用类和对象来实现面向对象编程。 类是一种抽象的数据类型，它定义了一组属性和方法，用于描述某个对象的特征和行为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值