JavaScript中的面向对象介绍_js面向对象
对象
创建
对象
构造函数
公有、私有、特权、静态成员
this、call和apply
异常处理
继承
原型
对象
在JavaScript,可以说everything is object,那么什么是对象?对象就是包含一组变量和函数的集合。在其它面向对象语言中对象是由类的实例化而来,JavaScript是基于原型的面向对象语言,没有类的概念,对象派生自现有对象的副本。JavaScript中对象可以分为两类:Function和Object。
创建对象
为了提高效率,JavaScript自带内置对象,例如:Object、Function、Array等,所有内置对象都可以通过new来创建。Function对象分为两类:实例和构造函数。例如alert('my name is X')是Function的实例;而作为构造函数的Function,必须通过new来实例化。创建的对象的语法分为以下几种:
var obj= new Object();var obj={};(Array等类似)
var myFunction=new Function(){//代码};function myFunction(){//代码}
需要注意的是,第一种Function声明必须在使用之前,而第二种可以在使用之后。
构造函数
Function是构造函数的起点,创建构造函数与上述创建对象Function类似
var myFunction=new Function('a',/*代码*/)
function myFunction(a){
/*代码*/
}
但是由于第一种有性能问题推荐使用第二种;Function对象的特点是:它的实例也能作为构造函数 。
静态成员
如下代码:
var myObj= new Object();
//添加name属性
myObj.name='LD';
//添加alertName方法
myObj.alertName=function(){
alert(this.name);
}
//执行alertName
myObj.alertName();
name和alertName仅仅存在于myObj实例中,不存在于构造函数。这个还好理解,但是对于既可以是构造函数也可以是实例的Function来说就不那么容易理解了,如下:
var myConstructor=new function(){
//添加静态属性
myConstructor.name='LD';
//添加静态方法
myConstructor.alertName=function(){
alert(this.nam);
}
}
myConstructor.alertName();
代码可以正常运行,因为myConstructor可以是实例,但是name和alertName不会应用到由myConstructor的任何新的实例中。
公有成员
能够跟随对象实例化的成员称之为公有成员,成为公有成员需要修改函数的原型,即prototype。公有方法可以随构造函数而被继承下去,方法如下:
function myConstructor(){
}
//添加公有属性
myConstructor.prototype.myName='LD';
//实例化
var myObj=new myConstructor();
alert(myObj.myName);
由myConstructor实例化的对象可以使用myName,但是myConstructor本身不可以,因为我们把公有成员加到了myConstructor的底层定义中,而非myConstructor实例本身。
私有成员
私有成员指的是在构造函数中定义的变量和方法,与其它语言的类中用private定义类似,例如:
function myConstructor(){
//添加私有属性
var myName='Ld'l
//添加私有方法
var alertName=function(){
alert('LD');
}
alertName();
特权成员
特权方法,指的是可以被公开访问,同时其能访问私有成员,在构造函数作用域总使用this定义的方法,类似其它语言中的公有方法,如下:
function myConstructor(){
//私有属性
var sex='male';
// 特权方法
this.alertSex=function(){
alert(sex);
}
}
对象字面量
前面我们使用的创建用的都是点,例如myConstructor.name=x;myConstructor.sex=x。我们也可以使用对象字面量来达到相同的目的,例如:
function myConstructor(){
}
//添加公有成员
myConstructor.prototype={
name:'LD',
sex:'male',
method:function(){}
}
注意,对象字面量中分隔符为逗号,且最后一个属性或方法最后没有逗号,以防解析错误。
this、call和apply
this,是一个依赖于执行环境的关键字,与创建位置无关,this关键字指向的的是使用包含它的函数的对象,学过C++和其它语言来说,这个不难理解。
call和applay,这两个的作用强制把方法附加到某个对象,例如:
//alertName是已经创建好的函数
//alertName不需要参数时
alertName.call('对象')
//alertName需要参数时
alertName.call('对象',‘参数1','参数2')
//alertName使用参数数组时
alertName.applay('对象',‘参数数组arguments')
异常处理
和c#类似,由try、catch组成,如下:
function myFunction(){
window.style.color='red';
}
try{
myFunction();
}
catch{
alert('异常信息:'+exception.name + exception.message)
}
继承和原型较多,放到下一篇博客《JavaScript中的继承和原型》

Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

AI Hentai Generator
Erstellen Sie kostenlos Ai Hentai.

Heißer Artikel

Heiße Werkzeuge

Notepad++7.3.1
Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version
Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Heiße Themen



So verwenden Sie die Go-Sprache zum Implementieren der objektorientierten ereignisgesteuerten Programmierung. Einführung: Das objektorientierte Programmierparadigma wird häufig in der Softwareentwicklung verwendet. Die ereignisgesteuerte Programmierung ist ein gängiges Programmiermodell, das den Programmfluss durch Auslösen und Verarbeiten von realisiert Ereignisse. In diesem Artikel wird die Verwendung der Go-Sprache zur Implementierung objektorientierter ereignisgesteuerter Programmierung vorgestellt und Codebeispiele bereitgestellt. 1. Das Konzept der ereignisgesteuerten Programmierung Die ereignisgesteuerte Programmierung ist ein auf Ereignissen und Nachrichten basierendes Programmiermodell, das die Ablaufsteuerung des Programms auf das Auslösen und Verarbeiten von Ereignissen überträgt. in ereignisgesteuert

Die Annotation @JsonIdentityInfo wird verwendet, wenn ein Objekt in der Jackson-Bibliothek eine Eltern-Kind-Beziehung hat. Die Annotation @JsonIdentityInfo wird verwendet, um die Objektidentität während der Serialisierung und Deserialisierung anzugeben. ObjectIdGenerators.PropertyGenerator ist eine abstrakte Platzhalterklasse, die zur Darstellung von Situationen verwendet wird, in denen der zu verwendende Objektbezeichner von einer POJO-Eigenschaft stammt. Syntax@Target(value={ANNOTATION_TYPE,TYPE,FIELD,METHOD,PARAMETER})@Retention(value=RUNTIME)public

Die Go-Sprache unterstützt die objektorientierte Programmierung durch Typdefinition und Methodenzuordnung. Es unterstützt keine traditionelle Vererbung, sondern wird durch Komposition implementiert. Schnittstellen sorgen für Konsistenz zwischen Typen und ermöglichen die Definition abstrakter Methoden. Praxisbeispiele zeigen, wie OOP zum Verwalten von Kundeninformationen verwendet wird, einschließlich Vorgängen zum Erstellen, Abrufen, Aktualisieren und Löschen von Kunden.

Analyse des Flyweight-Musters in der objektorientierten PHP-Programmierung In der objektorientierten Programmierung ist das Entwurfsmuster eine häufig verwendete Software-Designmethode, die die Lesbarkeit, Wartbarkeit und Skalierbarkeit des Codes verbessern kann. Das Flyweight-Muster ist eines der Entwurfsmuster, das den Speicheraufwand durch die gemeinsame Nutzung von Objekten reduziert. In diesem Artikel wird untersucht, wie Sie den Flyweight-Modus in PHP verwenden, um die Programmleistung zu verbessern. Was ist der Fliegengewichtsmodus? Das Fliegengewichtsmuster ist ein strukturelles Entwurfsmuster, dessen Zweck darin besteht, dasselbe Objekt zwischen verschiedenen Objekten zu teilen.

Die Go-Sprache unterstützt objektorientierte Programmierung, definiert Objekte über Strukturen, definiert Methoden mithilfe von Zeigerempfängern und implementiert Polymorphismus über Schnittstellen. Objektorientierte Funktionen ermöglichen die Wiederverwendung, Wartbarkeit und Kapselung von Code in der Go-Sprache, es gibt jedoch auch Einschränkungen wie das Fehlen traditioneller Konzepte von Klassen und Vererbung sowie Methodensignaturumwandlungen.

Zu den OOP-Best Practices in PHP gehören Namenskonventionen, Schnittstellen und abstrakte Klassen, Vererbung und Polymorphismus sowie Abhängigkeitsinjektion. Zu den praktischen Fällen gehören: Verwenden des Lagermodus zum Verwalten von Daten und Verwenden des Strategiemodus zum Implementieren der Sortierung.

In Golang (Go-Sprache) gibt es kein Konzept einer Klasse im herkömmlichen Sinne, es stellt jedoch einen Datentyp namens Struktur bereit, durch den objektorientierte Funktionen ähnlich wie Klassen erreicht werden können. In diesem Artikel erklären wir, wie Strukturen zur Implementierung objektorientierter Funktionen verwendet werden, und stellen konkrete Codebeispiele bereit. Definition und Verwendung von Strukturen Werfen wir zunächst einen Blick auf die Definition und Verwendung von Strukturen. In Golang können Strukturen über das Schlüsselwort type definiert und dann bei Bedarf verwendet werden. Strukturen können Attribute enthalten

Indem Sie das Verfolgen des Objektstatus, das Setzen von Haltepunkten, das Verfolgen von Ausnahmen und die Verwendung der xdebug-Erweiterung beherrschen, können Sie objektorientierten PHP-Programmiercode effektiv debuggen. 1. Objektstatus verfolgen: Verwenden Sie var_dump() und print_r(), um Objektattribute und Methodenwerte anzuzeigen. 2. Legen Sie einen Haltepunkt fest: Legen Sie einen Haltepunkt in der Entwicklungsumgebung fest. Wenn die Ausführung den Haltepunkt erreicht, wird der Debugger angehalten, sodass der Objektstatus einfacher überprüft werden kann. 3. Ausnahmen verfolgen: Verwenden Sie Try-Catch-Blöcke und getTraceAsString(), um den Stack-Trace und die Meldung abzurufen, wenn die Ausnahme auftritt. 4. Verwenden Sie den Debugger: Die Funktion xdebug_var_dump() kann den Inhalt von Variablen während der Codeausführung überprüfen.
