JavaScript 面向对象编程

JavaScript 面向对象编程, 第一部分: 继承

我们将向你展示 JavaScript 如何实现面向对象的语言中的: 继承 . 同时, 这些例子将向你展示如何实现类的封装. 在此, 我们不会讨论多态实现.

虽然 JavaScript 是脚本语言, 但它所支持的面向对象编程也是非常强大的. 虽然它没有类和实例, 但它有对象, 原型和隐式的继承. 我们将会解释如何模拟继承及其超类与子类之间关系的形式. 原型是理解继承概念的关键, 我们将会教你如何建立原型, 如何检测一个对象是否是另外一个对象的原型, 及其 JavaScript 的模型与 Java 面向对象编程之间的区别. 我们同样会向你展示如何检测对象所包含的各种属性的方法. 在另外一篇文章里, 我还会详细地讲解有关 "原型链 (prototype chain) " 的知识.

本文大量地参考了 Webreference.com 中 "Object-Oriented Programming with JavaScript, Part I: Inheritance " 的内容, 许多内容我进行了详细的测试和再探讨, 以保证内容不会有太大的失误.
原文地址: http://www.webreference.com/js/column79/

面向对象语言的特点

面向对象设计是基于以下 3 个主要原理的: 封装, 继承和多态. 说某种程序语言是支持 OO (面向对象) 设计的, 只有在它的语法中支持以上 3 个概念才可以这么说. 这种语言应该为你提供某些方法, 以使你能很轻松地定义和使用这些范例. 封装涉及到了将某个对象变成一个 "黑盒子"的概念. 当你使用某个对象时, 你不用知道它内部是如何工作的, 你也不必理解对象是如何工作的. 这个对象只需将它绝对有用的信息以接口方式提供出来. 此对象应该给你提供友好的接口, 来让你可以使用其有限的属性集和方法集. 封装还有一层意思, 那就是说某个对象包含了它需要的每一样东西, 这包括数据和对于它的操作. 封装的概念非常的强大, 因为它允许将一个大的软件项目有效地分配给每个开发人员, 对于团队中的每个人, 他们只需要关注自己所实现的对象, 而不需要太多地关注于别人的实现. 开发项目中的开销使得开发团队中成员与接口的数量按指数级别增长. 封装是自 "软件危机" 以来最受欢迎的 OO 设计理念.

软件的复用是 OO 设计思想中另外一个重要的特点. 在软件体系中实现此思想的主要方法就是继承. 类就是定义对象的功能. 超类是某个新类, 或者说是子类被建立的来源类. 一个子类从它的超类中继承了所的方法和属性. 实际上, 所有的子类都是被自动地生成的, 因此节省了大量的工作. 你不需要一个一个地定义这些子类. 当然, 你可以重载那些继承下来的方法和属性. 事实上, 谁也没有指出哪个子类要建立得和其超类一模一样, 除非你没有重载任何的属性和方法.

多态可能是这个 3 个概念中最复杂的一个了. 其本质上是说, 每个对象都可以处理各种不同的数据类型. 你不必为处理不同的数据类型而建立不同的类. 其典型的例子就是画图的类, 你不必为实现画圆, 画矩形, 画椭圆而编写不同的类. 你可以建立一个足够聪明的类来调用特定的方法来操作特定的形状.

通过函数实现继承

虽然 JavaScript 不支持显示继承操作符, 但你可以通过其实方式实现隐式继承. 对于实现类的继承, 有 2 种比较常用的方式. 第一种将某个类定义成子类的方法是, 通过在负责定义子类函数的内部调用超类的构造函数. 看下面的示例:

// 超类构造函数
function superClass() {
  this.bye = superBye;
  this.hello = superHello;
}

// 子类构造函数
function subClass() {
  this.inheritFrom = superClass;
  this.inheritFrom();
  this.bye = subBye;
}

function superHello() {
  return "Hello from superClass";
}
 
function superBye() {
  return "Bye from superClass";
}

function subBye() {
  return "Bye from subClass";
}

// 测试构造特性的函数
function printSub() {
  var newClass = new subClass();
  alert(newClass.bye());
  alert(newClass.hello());
}

当你运行上面的 printSub 函数时, 它会依次执行 subBuy 和 superHello 函数. 我们可以看到, bye 和 hello 方法最先在 superClass 中被定义了. 然而, 在 subClass 中, bye 方法又被重载了, subClass 构造函数头两行的功能只是做了一个简单的原始的继承操作, 但它是通过显示执行 inheritFrom 方法来完成的继承操作. 继承的过程先是将 superClass 的对象原型赋给 subClass 下的 inheritFrom 方法, 然后在执行完 superClass 的构造函数后, superClass 的属性就被自动地加到了 subClass 的属性列表中.这主要是由于在 subClass 中通过 this 来调用的 inheritFrom (也就是 superClass) 构造函数造成的, 通过此种方式调用 superClass 构造函数时, JavaScript 解释器会把 superClass 中的 this 与 subClass 中的 this 理解成位于同一个作用域下的 this 关键字, 所以就产生了继承的效果.

另外, 需要说明的是, 对于任何一个实例化的对象, 你任意地为它添加属性或方法, 如下所示:

  var newClass = new subClass();
  newClass.addprop = "added property to instance object";

很明显, 通过此种方式添加的属性和方法只对当前实例化对象有效, 不会影响所有的同类型对象实例. 无疑, 它是你创造的一个独一无二的对象实例.

通过原型实现继承

第二种, 也是更强大的方法是通过建立一个超类对象, 然后将其赋值给子类对象的 prototype 属性, 以此方式来建立子类的继承. 假设我们的超类是 superClass, 子类是 subClass. 其 prototype 的赋值格式如下:

subClass.prototype = new superClass;

对于原型继承的实现方式, 让我们刚前面的代码改写一下, 示例如下:

// 超类构造函数
function superClass() {
  this.bye = superBye;
  this.hello = superHello;
}

// 子类构造函数
function subClass() {
  this.bye = subBye;
}
subClass.prototype = new superClass;

function superHello() {
  return "Hello from superClass";
}
 
function superBye() {
  return "Bye from superClass";
}

function subBye() {
  return "Bye from subClass";
}

// 测试构造特性的函数
function printSub() {
  var newClass = new subClass();
  alert(newClass.bye());
  alert(newClass.hello());
}

我们可以看到, 除了将前面第一种继承方式中 subClass 中的前 2 行内容, 换成函数外的 prototype 赋值语句之外, 没有其它任何的变化, 但代码的执行效果和前面是一样的.

为已经建立的对象添加属性

通过原型实现的继承比通过函数实现的继承更好, 因为它支持动态继承. 你可以在构造函数已经完成之后, 再通过 prototype 属性定义超类的其它方法和属性, 并且其下的子类对象会自动地获得新的方法和属性. 下面是示例, 你可以看到它的效果.

function superClass() {
  this.bye = superBye;
  this.hello = superHello;
}

function subClass() {
  this.bye = subBye;
}
subClass.prototype = new superClass;

function superHello() {
  return "Hello from superClass";
}
 
function superBye() {
  return "Bye from superClass";
}

function subBye() {
  return "Bye from subClass";
}

var newClass = new subClass();

/*****************************/
// 动态添加的 blessyou 属性
superClass.prototype.blessyou = superBlessyou;

function superBlessyou() {
  return "Bless You from SuperClass";
}
/*****************************/

function printSub() {
  alert(newClass.bye());
  alert(newClass.hello());
  alert(newClass.blessyou());
}

这就是我们经常看到的为内部对象, 如 String, Math 等再添加其它属性和方法的技巧. 对于任何的内部对象和自定义对象, 你都也可以通过 prototype 来重载其下的属性和方法. 那么在调用执行时, 它将调用你所定义的方法和属性. 下面是示例:

// 为内部 String 对象添加方法
String.prototype.myMethod = function(){
  return "my define method";
}

// 为内部 String 对象重载方法
String.prototype.toString = function(){
  return "my define toString method";
}

var myObj = new String("foo");

alert(myObj.myMethod());
alert(myObj);
alert("foo".toString());

另外需要注意的是, 所有 JavaScript 内部对的 prototype 属性都是只读的. 你可以像上面那样为内部对象的原型添加或重载属性和方法,但不能更改该内部对象的 prototype 原型. 然而, 自定义对象可以被赋给新的原型. 也就是说, 像下面这样做是没有意思的.

function Employee() {
  this.dept = "HR";
  this.manager = "John Johnson";
}

String.prototype = new Employee;

var myString = new String("foo");

上面的程序在运行之后不会报错, 但显然, 如果你调用 myString.dept 将会得到一个非定义的值.

另外, 一个经常使用的是 prototype 下的 isPrototypeOf() 方法, 它主要用来判断指定对象是否存在于另一个对象的原型链中. 语法如下:

object1.prototype.isPrototypeOf(0bject2);

上面的格式是用来判断 Object2 是否出现 Object1 的原型链中. 示例如下:

function Person() {
  this.name = "Rob Roberson";
  this.age = 31;
}

function Employee() {
  this.dept = "HR";
  this.manager = "John Johnson";
}

Employee.prototype = new Person();

var Ken = new Employee();

当执行 Employee.prototype.isPrototypeOf(Ken), Person.prototype.isPrototypeOf(Ken) 和 Object.prototype.isPrototypeOf(Ken) 时, 结果都会返回 true.

用于 Netscape 下的特定继承检测

在 Netscape 浏览器 4.x 到 6, 及其 Mozilla 系列浏览中, JavaScript 将对象间的原型关系存储在一个特殊的内部属性对象中, __proto__ (前后是 2 个下划线). 下面是一个示例:

function Shape() {
  this.borderWidth = 5;
}

function Square() {
  this.edge = 12;
}

Square.prototype = new Shape;

myPicture = new Square;

alert(myPicture.__proto__);
alert(myPicture.borderWidth);

由于脚本执行过 Square.prototype = new Shape 语句, 所以 myPicture 具有了一个指向 Shape 对象的内部属性 __proto__. 在脚本的执行过程中, 当要获取对象的某个属性值, 并且此对象是通过原型赋值而建立的某个对象, 在自身并没有对某个属性进行定义时, JavaScript 解析器会查看它的 __proto__ 属性对象, 也就它的原型对象, 然后枚举其原型中的所有属性, 而得出的结果要么是有这个属性, 要么是没有这个属性. 如果没有此属性, 再枚举原型对象下面的原型对象, 直到此过程真正的结束. 而所有的这些 JavaScript 引擎内部的操作, 我们是不会知道的, 下面的内容就是对这个问题的解释.

其实, 对于所有的自定义对象, 无论它有没有使用过 prototype 赋值操作, 它都具有一个 __proto__ 内部对象. 而如果某个对象是通过多层 prototype "继承" 来的, 所有的 "继承" 而来的属性却可以通过简单的一层循环遍历出来, 而不需要使用什么递归算法, 因为 JavaScript 引擎自动给我们做了. 示例如下:

function Shape() {
  this.borderWidth = 5;
}

function Square() {
  this.edge = 12;
}

function RoundSquare()
{
  this.radio = 0.5;
}

Square.prototype = new Shape;
RoundSquare.prototype = new Square;

var myPicture = new RoundSquare;

for (property in myPicture.__proto__) {
alert(property);
}

我们或者还可以通过更改后面的循环, 来遍历某个子类对象继承来的所有属性, 如下:

for (property in RoundSquare.prototype) {
alert(property);
}

如果你不怕麻烦, 我们甚至还可以通过级连的方式, 取出其构造函数中定义的原始属性值.

alert(myPicture.__proto__.__proto__.borderWidth);

无论你是否修改过此属性值, 通过上面语句所取出的属性值都是原始定义值. 让我们沿着这个思路再往下看, 下面的代码涉及到另外一个问题, 这个问题和原型链 (prototype chain) 有关. 代码如下:

function State() {
}

function City() {
}
City.prototype = new State;

function Street() {
}

Street.prototype = new City;

var UniversityAvenue = new Street();

function tryIt() {
  alert(UniversityAvenue.__proto__== Street.prototype);
  alert(UniversityAvenue.__proto__.__proto__==
   City.prototype);
  alert(UniversityAvenue.__proto__.__proto__.__proto__
   == State.prototype);
  alert(UniversityAvenue.__proto__.__proto__.__proto__.
   __proto__== Object.prototype);
  alert(UniversityAvenue.__proto__.__proto__.__proto__.
   __proto__.__proto__== null);
}

当执行 tryIt 函数时, 所有的显示均为 true. 也就是说, 子类对象的 prototype.__proto__ 总是等于超类对象的 prototype 属性; 超类对象的 prototype.__proto__ 总是等于 Object.prototype; Object.prototype.__proto__ 总是为 null; 而实例对象的 __proto__ 总是等于其类对象的 prototype, 这就是为什么任何自定义对象都具有 __proto__ 属性的原因. 对于上面的叙述, 其对应的代码如下:

Street.prototype.__proto__ == City.prototype     // true
State.prototype.__proto__ == Object.prototype    // true
Object.prototype.__proto__ == null               // true
UniversityAvenue.__proto__ == Street.prototype    // true

模拟实现 instanceOf 函数

根据上一节的内容, 我们了解了有关 Netscape 所支持的 __proto__ 特性的内容. 这一节, 我们将利用此特性来创建自己的实例对象检测函数.

许多时候, 我们都需要判断某个对象是否是由某个类来定义的, 在其它的语言里, 你可以通过 instanceOf 函数来实现此判断. 在 JavaScript 中同样提供了一个 instanceof 运行符, 而在 __proto__ 的基础上, 我们完全可以自己定义一个同样的函数, 虽然这看上去是在重复劳动, 但有助于我们更深刻地了解有关 __proto__ 的知识. 下面的代码只是用来说明功能, 在实际的应用中, 你不需要重复定义 instanceOf 函数, 使用 instanceof 运算符即可.

function instanceOf(object, constructorFunction) {
  while (object != null) {
    if (object == constructorFunction.prototype)
     {return true}
    object = object.__proto__;
  }
  return false;
}
function State() {
}

function City() {
}
City.prototype = new State;

function Street() {
}

Street.prototype = new City;

var UniversityAvenue = new Street();
function demo() {
  alert("instanceOf(UniversityAvenue, Street) is " +
   instanceOf(UniversityAvenue, Street));
  alert("instanceOf(UniversityAvenue, City) is " +
   instanceOf(UniversityAvenue, City));
  alert("instanceOf(UniversityAvenue, State) is " +
   instanceOf(UniversityAvenue, State));
}

你会看到所有的运行结果全部为 true, 其原理和上一节的级连判断相等如出一辙. 实际证明, 它的运行结果和 instanceof 运行符的运行结果是一致的.

你可以通过 constructor 属性来检测任意对象的超类, 此属性返回通过 new 运算符创建新对象时所调用的构造函数, 返回值是 Function 对象类型. 因为 Object 内部对象是支持 constructor 属性的, 并且有的对象 (包括内部对象和自定义对象) 都是由 Object 继承而来的, 所以所有的对象都支持此属性. 让我们再看一下下面的例子:

function Employee() {
  this.dept = "HR";
  this.manager = "John Johnson";
}

function printProp() {
  var Ken = new Employee();
  alert(Ken.constructor);
}

调用完 printProp 函数之后, 你会看到弹出框中显示的是 Employee 函数的定义文本, 其实 Ken.constructor 的返回值本身是 Function 对象类型, 而在 alert 时被隐含地调用了 toString 方法. 对于类对象本身, 你同样可以调用 prototype.constructor 来取出其构造函数.

对象的分类和打印

JavaScript 支持 3 种主要类型的对象: 内部对象, 宿主对象, 自定义对象, 可能还有特殊的外部对象, 如: ActiveX 对象或 XPCOM 对象. 内部对象被 JavaScript 语言本身所支持, 如: Object, Math, Number 对象等. 所有的内部对象的共同特点是以大写字母开头, 并且它们是大小写敏感的. 如果你想使用数学常量 PI, 必须写成 Math.PI, 你如果写成 math.PI, JavaScript 会显示错误. 宿主对象是被浏览器支持的, 目的是为了能和被浏览的文档可以交互, 如: document, window 和 frames. 宿主对象的特点是所有对象全部以小写字母开头. 因为 JavaScript 本身就是大小写敏感的, 所以你同样不能将大小写搞混. 剩下要说的就只是自定义对象了, 你可以随便将你的对象定义成小写或大小写, 但是一定要符合基本的命名规范. 如下所示, 这就是一个自定义对象:

function employee() {
  this.dept = "HR";
  this.manager = "John Johnson";
}

function printProp() {
  var ken = new Employee();
  for (property in ken) {
    alert(property);
  }
}

前面我们已经提到过, 所有的内部对象和自定义对象都是从 Object 对象继承而来的, 它是所有对象的超类对象. 你可建立一个 Object 对象的实例. 如下:

var myObject = new Object();

Object 类型的对象有许多的属性和方法, 你可以查看相关的手册. 上面只是定义了一个最简单的空对象, 你还可以为 Object 构造函数传入参数, 它会返回相应类型值的实例化对象. 记住, 返回值的类型是某种对象类型的 (如: String, Number 或 Object). 这种方式和直接通过赋值字符串或数值常量不同, 主要表示在类型方面. 如下所示:

var myObject = new Object("foo"); // 返回值类型为 object
var myObject = new String("foo"); // 返回值类型为 object, 效果同上
与
var myObject = "foo";             // 返回值类型为 string

你可以从调试器的 type 列中看出这个细微的差别, 它是简单类型与对象类型之间的区别. 但是, 你通过 alert 调用是看出不这些内部差别的, 因为在调用 alert 的过程中, 所有的对象类型值都会被自动调用 toString 方法进行字符串类型转换, 转换规则在 JavaScript 手册中有说明. 如果你 alert 的是某个自定义对象, 并且它没有定义 toString 方法, 那么它的返回值将为 "[object Object]". 对于 Math 对象, 当你查看其 Math.constructor 属性时, 你会得到一个不同于其它内部对象的内容为 "function Object()..." 的对象构造函数, 这与其它对象返回 "function Function()..." 的构造函数很不相同. 原因很简单, 因为 Math 对象是不能通过 new 运算符进行创建的.

另外, 如果传入 Object 构造函数中的值是一个对象, 它将原封不动地将该对象返回. 记住, 此操作只是一个引用, 而不是复制.

请求对象的属性

在前面的示例代码中, 已经出现过以循环方式枚举对象属性的示例. 其实, 通过 for...in 语句, 无论是任何对象和数组, 其下的元素, 属性和方法都可以遍历出来. 示例如下:

function employee() {
  this.dept = "HR";
  this.manager = "John Johnson";
}

function printProp() {
  var ken = new employee();
  for (property in ken) {
    alert(property + " : " + ken[property]);
  }
}

在遍历测试过程中, 你会发现, 对于自定义对象和宿主对象一般都可以枚举出其下的属性, 而对于内部对象, 几乎没有什么属性可以遍历出来, 为什么要说几乎呢? 因为对于 Mozilla 内核的浏览和 IE 内核的浏览器, 其 JavaScript 引擎有不同, Mozilla 下可以枚举出部分内容, 而枚举的原则不得而知.

对于每一个对象, 你还可以使用 hasOwnProperty 方法来检测其是否具有某个属性或方法. 由于 hasOwnProperty 是 Object 对象下的方法, 因此所有的对象都具有此方法. 但是, 需要注意的是, 此方法只能检测通过 this 关键字定义的成员, 如果某个成员是通过原型链定义的, 那么此方法将返回 false. 也就是说, 通过 prototype 继承来的属性和方法, 及其通过 prototype 定义的属性和方法, 都是不能通过 hasOwnProperty 来进行检测的. 由此, 我们可以看出, 通过 this关键字定义的属性和方法是同对象本身处于同一个地址空间内的; 而通过 prototype 定义的属性和方法, 是通过所谓的 "原型链" 进行管理的, 其下的的属性和方法不位于同一个地址空间之间, 当其调用这种属性或方法时, 必须通过 "链表" 才能索引到其下的某个属性或方法. 也就说, 调用以原型方式定义的属性和方法会有一个类似于链表的 "回溯" 操作.

和 hasOwnProperty 差不多, 对于对象中的每个属性, 我们还可以通过 propertyIsEnumerable 来测试它是否可以被枚举出来. 如下所示:

function Employee1() {
  this.dept = "HR";
  this.manager = "John Johnson";
  this.month = new Array("jan", "feb", "mar");
}

var Ken = new Employee1();

Ken.month.propertyIsEnumerable(0);

我们可以看到, 其语法是 propertyIsEnumerable 后跟数组的元素索引或对象中的属性名称. 同样, 对于原型链中的属性或方法它是不予考虑的, 结果当然是返回 false.

对于 JavaScript 和 Java 的比较

与 Java 这种基于类的语言不同, JavaScript 是一种基于原型的语言. 这种特点影响着每一个方面. 如术语 instance 在基于类的语言中有着特殊的意义, 它表示某个实例是隶属于某个特殊类的独立个体, 是对类定义的真实实现; 而在 JavaScript 中, 术语 instance 没有这个意思, 因为在它的语法里面, 类和实例是没有区别的. 虽然, 实例可以用来说明某个对象是使用某个特殊的构造函数生成的. 如下所示:

function superClass() {
  this.bye = superBye;
  this.hello = superHello;
}

function subClass() {
  this.bye = subBye;
}
subClass.prototype = new superClass;

function superHello() {
  return "Hello from superClass";
}
 
function superBye() {
  return "Bye from superClass";
}

function subBye() {
  return "Bye from subClass";
}

var newClass = new subClass();

newClass 是 subClass 的实例, 它是通过 subClass 的构造函数生成的. 而如果使用基于类的语言呢, 如下所示是 Java 的等价实现.

public class superClass {
  public superClass () {
    this.bye = superBye;
    this.hello = superHello;
  }
}
public class subClass extends superClass {
  public subClass () {
    this.bye = subBye;
  }
}

结束语

我们在上面的几节中, 详细地说明了有关 JavaScipt 中的面向对象实现, 或者只能说是模拟实现. 在此期间向你展示了实现方法. 并且阐述了有关如何检测对象之间关系的方法, 如何打印属性和测试某个特定的属性, 还做了一个 JavaScript 和 Java 的简单比较. 但这显然是不够的, 因而, JavaScript 的面向对象编程是非常多样化的, 格式也非常繁杂. 我打算在后面的内容里, 再总结一下有问封装的格式问题, 着重说明与对象方法有关的内容和实现, 同时还有上面提到的原型链 (prototype chain) 问题.

论文潜搜,论文洗稿工具 立即下载

相关推荐

利用kettle进行数据库数据比对

Kettle是一款国外开源的ETL工具,纯java编写,可以在Windows、Linux、Unix上运行,数据抽取高效稳定。本人用的版本是6.1。 之前用kettle这个开源的ETL工具是用来做数据抽取的,这次测试有个需求,是做数据库数据的比对。验证源表到目标表的逻辑正确,从而利用源表自己写SQL逻辑,生成的结果和目标表去比对。这次想到了利用kettle的数据比较功能,来做这些数据校验。 ...

多米诺DU的专栏 1万+

今天一看,自己发的文章原来这么多了。openeim

在OpenEIM中每运行一个程序       作者:       i_like_cpp        -       日期:2011-09-29     浏览 123 次 在OpenEIM中每运行一个程序,系统资源就会减少。有的程序会消耗大量的系统资源,即使把资源关闭,在内存中还是有一些没有的DLL文件在运行,这样就便得系统的运行速度下降,甚至出现上述问题。我们可以通过修改注册表键的方法

小发猫 1952

VOWIFI--相关的协议文档

一、3GPP相关协议文档 3GPP 23.402 Architecture enhancements for non-3GPP accesse- //重要 整体框架结构和流程,3GPP和NON-3GPP切换 3GPP 36.304  User Equipment (UE) procedures in idle mode //重要,终端在空闲状态下3GPP与NON-3GPP之间的重选方法   3GP

时九博客 3582

面向对象语言三个特点

面向对象语言三个特点

G_SGold的博客 1118

Unity零基础到进阶 | Unity 探针系统深度解析:光照探针、反射探针与相关技术

在 Unity 渲染管线中,探针(Probe) 是一类通过预计算或实时采样来捕捉空间光照信息的核心组件。它们弥补了传统静态光照贴图和实时光源各自的局限性,是实现高质量、高性能全局光照效果的关键工具。 本文将系统介绍光照探针(Light Probe)和反射探针(Reflection Probe)的作用与用法,分析二者之间的协同关系,并延伸介绍自适应探针体积(APV)、光照探针代理体(LPPV)、探针体积等进阶技术。

努力前行,总会成为自己心中的那道光 1万+

【Dumper-7】入门指南 - 带你领略不一样的UE世界

摘要: Dumper-7是一款用于分析UE4/UE5游戏的逆向工具,可自动生成游戏内部结构的C++ SDK。支持Visual Studio、CMake和Xmake三种构建方式,通过DLL注入目标游戏后,自动识别引擎结构并输出C++ SDK文件(默认保存在C:\Dumper-7目录)。该工具适用于游戏Mod开发、安全研究和机制分析,提供完整的类层次映射、属性/函数识别功能。使用时需注意x64平台配置,生成SDK后可集成到自定义DLL项目中,通过示例代码展示如何查找游戏对象、访问世界状态和调用引擎函数。

kinghzking的专栏 440

面向对象编程:定义、特点、应用场景、优缺点及示例代码

编程范式的演进使得软件开发变得更加高效和灵活。面向对象编程(Object-Oriented Programming,简称OOP)是现代编程中最为流行的一种范式。它通过模拟现实世界中的对象和关系,使得程序设计更加自然和直观。本文将详细探讨面向对象编程的定义、特点、应用场景、优缺点以及代表性的编程语言,并通过示例代码帮助读者更好地理解这种编程范式。

cooldream2009的博客 3731

国密GmSSL v2版本命令行方式生成国密sm2私钥、公钥、签名和验证签名

GmSSL是国密算法的工具库(主要包含SM2、SM3、SM4和国密SSL证书生成等功能),项目本身是OpenSSL的分支,但是截至文章发布为止,OpenSSL主分支的国密算法并不完善,目前并不支持签名和解签,所以国密算法这块还是需要使用GmSSL工具库。网上现在并没有v2版本的GmSSL可用的命令行文章,本章用于记录这些命令。本文原创自csdn博客,其他网站看到这篇文章都是盗,版,爬。虫。网站,支持原创,远离盗版。

eguid音视频方向博客,分享经过实践检验的硬核音视频技术。FFmpeg、openCV和JavaCV音视频和图像处理系列教程发布十周年,众多开发者的严格验证。欢迎关注,一起交流探索学习最新音视频和图像处理技术 4607

面向对象语言的三大特征

封装 概念: 将类的某些信息隐藏起来(用访问权限来实现),不让外部直接对其访问,一般可以通过特定的方法来对其隐藏信息的访问,便于控制。 案例: 比如我们设计一个学生类,学生有学号,专业,班级,家庭地址,联系方式等属性,但一般家庭住址和联系方式一般不对外开放,需要对其封装,并设置特定的通道(方法)让其访问。 代码: public class Student { String id; //没有访问权限修饰符,默认为default String name; String g

m0_54666135的博客 1139

【毕设护航】从0构建YOLOv8犬类识别系统,120种犬类精准检测+可视化界面全流程指南

本文介绍了一个基于YOLOv8的120种犬类目标检测与可视化系统毕业设计项目。该项目使用Stanford Dogs数据集,将图像分类任务转化为目标检测任务。主要内容包括:数据预处理(XML标注转换为YOLO格式)、YOLOv8模型训练与测试(包含训练脚本编写和推理实现),以及基于Tkinter的图形界面开发。该项目技术链条完整,涵盖检测、分割等多任务支持,适合作为计算机视觉方向的毕业设计选题,兼具技术深度和展示效果。

LXY_LOVE36的博客 99

FC7300 Clock介绍

FC7300的时钟架构包括一个高级时钟图和内部时钟需求。它有5个CMU,使用SIRC监控FIRC/SOSC/FOSC,并使用FIRC监控SIRC。此外,CMU4还使用FOSC监Slow Clock。

舊梦的博客 329

JavaScript——面向对象编程

JavaScript的面向对象编程和大多数其他语言如Java、C#的面向对象编程都不太一样。如果你熟悉Java或C#,很好,你一定明白面向对象的两个基本概念: 类: 类是对象的类型模板,例如,定义Student类来表示学生,类本身是一种类型,Student表示学生类型,但不表示任何具体的某个学生 对象:实例是根据类创建的对象,例如,根据Student类可以创建出xiaoming、xiaohong、xiaojun等多个实例,每个实例表示一个具体的学生,他们全都属于Student类型。 在JavaScript

chenzoff的专栏 1118

Cadence画PCB的傻瓜式教程

1.原理图1)建立元件库2)建立原理图3)在原理图中画好电路图4)利用MENTOR-GRAPHICS-IPC-7351-LP-VIEWER查看元件的封装信息,用pad designer画焊盘,用pcb editor画元件的封装(对照LP_VIEWER),(也可以使用package wizard)5)在原理图中为元件添加封装信息(键入)6)Drc检查7)生成网表2.Pcb1)设置...

tianpu2320959696的博客 1万+

JS(四)--JavaScript 面向对象编程

JavaScript 面向对象编程一、JavaScript 面向对象编程1.1.、什么是面向对象编程1.2、面向过程和面向对象的对比1.3、JavaScript 中的对象?1.3.1、属性和方法是什么?二、面向对象编程案例三、JS面向对象的特征3.1、**封装性**3.2、**继承性** 一、JavaScript 面向对象编程 1.1.、什么是面向对象编程 面向对象是一种解决问题的思路,一种编程思...

-_^汪洸*的博客 711

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

[JavaScript] 面向对象编程

通过类与对象的概念,可以更好地模拟现实世界的实体,提升代码的可重用性、可维护性和扩展性。JavaScript 的面向对象编程非常灵活,类的引入让代码更加清晰和直观。多态是指不同的类在调用相同方法时,可以表现出不同的行为。静态方法是直接定义在类上的方法,而不是在实例上的方法。在 JavaScript 早期,使用函数和原型链实现面向对象的思想,语法复杂且容易出错。继承允许我们定义一个类,继承另一个类的属性和方法,从而实现代码复用。是用来定义对象蓝图的关键字,其中包含对象的属性和方法。调用父类的构造函数。

kevin_blog 2522

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

如何构建健壮的JavaScript代码:JS Raccoon的面向对象编程教程

在JavaScript开发中,面向对象编程(OOP)是构建健壮、可维护代码的核心技术之一。JS Raccoon项目提供了丰富的面向对象编程指南,帮助开发者理解从基础概念到实战应用的完整流程。本文将通过JS Raccoon的教程,带你掌握JavaScript面向对象编程的精髓,创建更加模块化和可扩展的代码结构。 ## 理解JavaScript中的数据类型:基础中的基础 🧱 JavaScript

gitblog_00558的博客 647

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

JS(JavaScript)中的面向对象编程——详细总结(附源码)

文章目录一,什么是面向对象二,JS面向对象的几种特征以及类和对象1,面向对象的几种特征2,面向对象中的类和对象三,JS中默认存在的类(常见的)1,Number类2,String类3,Boolean构造器(JS中构造器也叫类)4,Object构造器(存在语法糖)5,Data类6,Math类(不需要new)7,Array类四,JS中的对象1,证明:JS中的一切数据都是对象2,对象是属性的无序集合3,对象属性的增删改查(1)对象属性的遍历(for in)(2)对象属性的增删改4,对象中属性的四大特征(1)conf

qq_44830054的博客 1349

JS面向对象编程

面向对象编程思想 面向对象编程是一种编程思想,这种思想有几个主要的特性,分别体现在以下四方面: 抽象:提取现实世界中某事物的关键特性,为该事物构建模型的过程。对同一事物在不同的需求下,需要提取的特性可能不一样。得到的抽象模型中一般包含:属性(数据)和操作(行为)。这个抽象模型我们称之为类。对类进行实例化得到对象。 封装:封装可以使类具有独立性和隔离性;保证类的高内聚。只暴露给类外部或者子类必须的...

阳光下的冷静的博客 2173

什么是前端开发JavaScript面向对象编程

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <meta http-equiv="X-UA-Compat...

x1037490413的博客 582

JavaScript面向对象编程

继承是指一个对象(或类)可以获取另一个对象(或类)的属性和方法。子类(派生类)继承父类(基类)的特性,并可以扩展或修改这些特性。继承的目的是代码复用和建立对象之间的层次关系。

kelong的博客 1466

【JavaScript】JS高级-面向对象编程

《课前补充》 面向对象编程:Object Oriented Programming 一、单例设计模式 (Singleton Pattern) 1、单例模式(就是普通对象) 表现形式: 在单例模式中,person1不仅仅是对象名,它被称为“命名空间[NameSpace]”(给堆内存空间起个名字),把描述事务的属性存放到命名空间,多个命名空间是独立分开的,互不冲突。 var person1 = { name:"", xxx:xxx } 作用: 把描述同一件事务的属性和特征进行“分组、归类”(存储在同一堆

zhangankang的博客 316

JS的面向对象编程

这里是修真院前端小课堂,每篇分享文从背景介绍】【知识剖析】【常见问题】【解决方案】【编码实战】【扩展思考】【更多讨论】【参考文献】八个方面深度解析前端知识/技能。 本篇分享的是:【JS的面向对象编程 】 大家好,我是IT修真院一枚正直纯洁善良的web前端程序员 今天给大家分享一下官网js任务4深度思考中的知识点——JS的面向对象编程? 1.背景介绍 什么是面向对象编程? “面向对象编程...

IT修真院:初学者转行到互联网的聚集地 311

JavaScript强化教程-JS面向对象编程

本文为H5EDU机构官方HTML5培训教程,主要介绍:JavaScript强化教程——JS面向对象编程 对事物的抽象描述 描述这类事物的特征和行为 对象是类的实例代码实现:创建一个类 function peple(){ this.hp=0; this.act = 30; this.name = ""; thi...

avr35764的博客 128

OLED与PS5 Pro如何释放赛博朋克2077的真实光影

OLED显示技术凭借自发光像素实现了像素级独立控光,使得黑色更纯粹、高光更明亮,成为呈现HDR内容的关键。与依赖背光分区的LCD不同,OLED通过像素自身发光获得接近无限的对比度,能在保持暗部细节的同时让局部高光爆发,这正是赛博朋克2077夜之城霓虹灯光与潮湿街道光影交错的基础。配合PS5 Pro的PSSR图像重建技术与高帧率输出,OLED的低响应时间确保画面无拖影,VRR与HDMI 2.1则进一步保障流畅体验。从电视端的HGIG色调映射到游戏内的纸白亮度设置,合理的HDR调校能显著提升画面观感。从OLED

weixin_33831673的博客 422

Javascript进阶[面向对象编程]

构造函数是创建对象的函数。函数给这个新对象定义属性和行为。可将它们视为创建的新对象的蓝图。这个构造函数定义了一个 Bird 对象,其属性 name、color 和 numLegs 的值分别被设置为 Albert、blue 和 2。构造函数函数名的首字母大写,这是为了方便我们区分构造函数( constructors)和其他非构造函数。构造函数使用 this 关键字来给它将创建的这个对象设置新的属性。在构造函数里面,this 指向的就是它新创建的这个对象。构造函数定义了属性和行为就可创建对象。

20岁爱吃必胜客 823
上一篇: SEO需要掌握什么
下一篇: 如何使用索引优化表
webdev2008
博客等级 码龄19年 1粉丝 60原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值