面向对象在javascript中的三大特征之继承

javascript面向对象三大特征之封装实例详解 本文实例讲述了javascript面向对象三大特征之封装。分享给大家供大家参考,具体如下: 封装 封装(Encapsulation):就是把对象内部数据和操作细节进行隐藏。很多面向对象语言都支持封装特性,提供关键字如private来隐藏某些属性和方法。要想访问被封装对象中的数据,只能使用对象专门提供的对外接口,这个接口一般为方法。调用该方法能够获取对象内部数据。 在JavaScript语言中没有提供专门的信息封装关键字,不过可以使用闭包来创建,只允许从对象内部访问的方法和属性。另外,接口也是数据封装的一种工具,接口提供了外界访问方法的约定。在应用开发中,所有类都应定义接口,类只向外提供已实现 立即下载

继承


在JavaScript中的继承的实质就是子代可以拥有父代公开的一些属性和方法,在js编程时,我们一般将相同的属性放到父类中,然后在子类定义自己独特的属性,这样的好处是减少代码重复。继承是面向对象的基础,是代码重用的一种重要机制。
——此文整理自 《jQuery 开发从入门到精通》 ,这是本好书,讲的很详细,建议购买阅读。

继承的作用

实现继承的主要作用是:
① 子类实例可以共享超类属性和方法。
② 子类可以覆盖和扩展超类属性和方法。

继承的分类

在JavaScript中是不支持类的概念,使用构造器机制来实现类的特性。
JavaScript中类的继承不止一种,主要包括:类继承(构造函数继承),原型继承,实例继承,复制继承,克隆继承,混合继承,多重继承等。

类继承
类继承也叫构造函数继承,其表现形式是在子类中执行父类的构造函数。实现本质:比如把一个构造函数A的方法赋值为另一个构造函数B,然后调用该方法,使构造函数A在构造函数B内部执行,这是构造函数B就拥有了构造函数A中定义的属性和方法。这就是B类继承A类。示例如下:
  function A(x){
    this.x = x;
    this.say = function() {
      console.log(this.x + ' say');
    }
  }
  function B(x,y) {
    this.m = A; // 把构造函数A作为一个普通函数引给临时方法m()
    this.m(x); // 把当前参数作为值传给构造函数A,并且执行
    delete this.m; // 清除临时方法
    this.y = y;
    this.call = function(){
      console.log(this.y);
    }
  }

  // 测试类继承
  var a = new A(1);
  var b = new B(2,3);
  a.say(); // 1 say
  b.say(); // 2 say
  b.call(); // 3
上面的实现方式很巧妙对吧,但是这种设计方式太随意,缺乏严密性。严禁的设计模式应该考虑到各种可能存在的情况和类继承关系中的互相耦合性。所以一般我们尽可能把子类自身的方法放在原型里去实现。下面这种创建方式会更好:
function A(x){
  this.x = x;
  this.say = function() {
    console.log(this.x + ' say');
  }
}
function B(x,y){
  this.y = y;
  A.call(this,x); // 在构造函数B内调用超类A,实现绑定,用call来实现借用
}
B.prototype = new A(); // 设置原型链,建立继承关系
B.prototype.constructor = B; // 恢复B的原型对象的构造函数为B,如果不操作就会指向A
B.prototype.gety = function(){ // 给类B添加新的方法
  return this.y;
}

// 测试 类继承
var a = new A('A');
var b = new B('Bx','By');
a.say(); // A say
b.say(); // Bx say
console.log(b.gety()); // By
console.log(B.prototype.__proto__ === A.prototype); // true;
console.log(b.constructor === B); // true  这里也可以把B中的 B.prototype.constructor = B; 去除,结果为false
在js中实现类继承,需要设置3点:
① 在子类构造函数结构体内,使用函数call()调用父类构造函数,把子类的参数传递给调用函数如上面的例子:A.call(this,x) 这样子类可以继承父类的所有属性和方法。
② 在子类和父类之间建立原型链,如上例:B.prototype = new A() 为了实现类的继承必须保证他们原型链上的上下级关系。即设置子类的prototype 属性指向父类的一个实例即可。
③ 恢复子类原型对象的构造函数, 如上例:B.prototype.constructor = B 

在类继承中,call() 和 apply() 方法被频繁使用,它们之间的功能和用法都是相同的,唯一区别就是第2个参数类型不同。如果深入,请看我之前的博客:http://blog.youkuaiyun.com/tyro_java/article/details/51020720

此处需要提一下,就是类的构造函数中的成员,一般称之为本地成员,而类的原型成员就是类的原型中的成员,此处我们只考虑原型中的成员继承。本地成员继承可以用call 和 apply。下面我们来看下类继承的原型成员的继承封装函数:
在函数体内,首先定义一个空函数F(),用来实现功能中转,把它的原型指向父类的原型,把空函数的实例传递给子类的原型,这样就避免了直接实例化父类引发的内存问题,因为实际开发中,父类可能很大,实例化后,会占用很大一部分内存。
// 定义一个继承函数
function extend(Sub,Sup){ // 有两个入口参数,Sub是子类,Sup是父类
  var F = function(){}; // 建立一个临时的构造函数
  F.prototype = Sup.prototype; // 把临时构造函数的原型指向父类的原型
  Sub.prototype = new F(); // 实例化临时类,此处相当于把子类的原型指向父类的实例
  Sub.prototype.constructor = Sub; // 恢复子类的构造函数
  Sub.sup = Sup.prototype; // 在子类中定义一个本地属性存储超类原型,可避免子类和超类耦合
  if(Sup.prototype.constructor === Object.prototype.constructor) { // 检测超类构造器是否为Object构造器
    Sup.prototype.constructor = Sup;
  }
}
// 下面定义两个类用来测试上面的继承函数
function A(x,y) {
  this.x = x;
  this.y = y;
}
A.prototype.add = function() {
  return (this.x-0) + (this.y-0); // 此处-0 的目的是确保字符串类型可转成数值型
}
A.prototype.minus = function() {
  return this.x - this.y;
}
function B(x,y) {
  A.apply(this,[x,y]);
}
// 开始实现类继承中的原型成员继承
extend(B,A);
// 为了不与A类中的代码耦合可以单独为B定义一个同名的add
B.prototype.add = function() {
  return B.sup.add.call(this); // 避免代码耦合
}
// 测试继承
var b = new B(1,2);
console.log(b.minus()); // -1
console.log(b.add()); // 3

原型继承
原型继承是js中最通用的继承方式,不用实例化对象,通过直接定义对象,并被其他对象引用,这样形成的一种继承关系,其中引用对象被称为原型对象。
function A(){
  this.color = 'red';
}
function B(){}
function C(){}
B.prototype = new A();
C.prototype = new B();
// 测试原型继承
var c = new C();
console.log(c.color); // red
原型继承显得很简单,不需要每次构造都调用父类的构造函数,也不需要通过复制属性的方式就能快速实现继承。但它也存在一些缺点:
① 每个类型只有一个原型,所以不支持多重继承
② 不能很好的支持多参数或动态参数的父类,显得不够灵活。
③ 占用内存多,每次继承都需要实例化一个父类,这样会存在内存占用过多的问题。

实例继承
实例化类可创建新的实例对象,这个实例对象将继承类的所有特征。
function Arr() {
  var a = new Array();
  return a;
}
var arr = new Arr();
arr[0] = 1;
arr[1] = 2;
console.log(arr); // [1,2]
console.log(Array.isArray(arr)); // true
console.log(arr instanceof Array); // true
console.log(arr instanceof Arr); // false
通过构造函数中完成对类的实例化操作,然后返回实例对象,这就是实例继承的由来。实例继承可实现对所有对象的继承,包括自定义类,核心对象和DOM对象。但是也有一些缺点
① 实例继承无法传递动态参数,它是封闭在函数体内试下你,不能通过call和apply来实现动态传参。
② 实例继承只返回一个对象,不支持多重继承
③ 实例继承对象它仍然保持与原对象的实例关系,无法实现继承对象是封装类的实例。如:console.log(arr instanceof Arr); // false

复制继承
复制继承就是利用for in 遍历对象成员,逐一复制给另一个对象。通过这种方式来实现继承。

function A(){
  this.color = 'red';
}
A.prototype.say = function() {
  console.log(this.color);
}
var a = new A();
var b = {};
// 开始拷贝
for(var item in a) {
  b[item] = a[item];
}
// 开始测试
console.log(b.color); // red
b.say(); // red
我们把它封装一下:
Function.prototype.extend = function(obj){
  for(item in obj){
    this.constructor.prototype[item] = obj[item];
  }
}
function A(){
  this.color = 'green';
}
A.prototype.say = function(){
  console.log(this.color);
}
// 测试
var b = function(){};
b.extend(new A());
b.say(); // green
复制继承实际上是通过反射机制复制类对象中的可枚举属性和方法来模拟继承。这种可以实现多继承。但也有缺点:
① 由于是反射机制,不能继承非枚举类型的属性和方法。对于系统核心对象的只读方法和属性也无法继承。
② 执行效率差,这样的结构越庞大,低效就越明显。
③ 如果当前类型包含同名成员,这些成员会被父类的动态复制给覆盖。
④ 多重继承中,复制继承不能清晰描述父类和子类的相关性。
⑤ 在实例化后才能遍历成员,不够灵活,也不支持动态参数
⑥ 复制继承仅仅是简单的引用赋值,如果父类成员包含引用类型,那么也会带来很多副作用,如不安全,容易遭受污染等。

克隆继承
通过对象克隆方式继承,可以避免赋值对象成员带来的低效。
为Function对象扩展一个clone方法。该方法可把参数对象赋值给一个空的构造函数的原型对象,然后返回实例化后的对象,这样该对象就拥有构造哈数包含的所有成员了。
Function.prototype.clone = function(obj){
  function Temp(){};
  Temp.prototype = obj;
  return new Temp();
}
function A(){
  this.color = 'purple';
}
var o = Function.clone(new A());
console.log(o.color); // purple


混合继承
混合继承是把多种继承方式一起使用,发挥各个优势,来实现各种复杂的应用。最常见的就是把类继承和原型继承一起使用。
function A(x,y){
  this.x = x;
  this.y = y;
}
A.prototype.add = function(){
  return (this.x-0) + (this.y-0);
}
function B(x,y){
  A.call(this,x,y);
}
B.prototype = new A();

// 测试
var b = new B(2,1);
console.log(b.x); // 2
console.log(b.add()); // 3

多重继承
继承一般包括单向继承和多向继承,单向继承模式较为简单,每个子类有且仅有一个超类,多重继承是一个比较复杂的继承模式。一个子类可拥有多个超类。JavaScript原型继承不支持多重继承,但可通过混合模式来实现多重继承。下面让类C来继承类A和类B:
function A(x){
  this.x = x;
}
A.prototype.hi = function(){
  console.log('hi');
}
function B(y){
  this.y = y;
}
B.prototype.hello = function(){
  console.log('hello');
}
// 给Function增加extend方法
Function.prototype.extend = function(obj) {
  for(var item in obj) {
    this.constructor.prototype[item] = obj[item];
  }
}
// 在类C内部实现继承
function C(x,y){
  A.call(this,x);
  B.call(this,y);
};
C.extend(new A(1));
C.extend(new B(2));

// 通过复制继承后,C变成了一个对象,不再是构造函数了,可以直接调用
C.hi(); // hi
C.hello(); // hello
console.log(C.x); // 1
console.log(C.y); // 2
一个类继承另一个类会导致他们之间产生耦合,在js中提供多种途径来避免耦合的发生如 掺元类
掺元类是一种比较特殊的类,一般不会被实例化或者调用,定义掺元类的目的只是向其他类提供通用的方法。
// 定义一个掺元类
function F(x,y){
  this.x = x;
  this.y = y;
}
F.prototype = {
  getx:function(){
    return this.x;
  },
  gety:function(){
    return this.y;
  }
}

// 原型拷贝函数
function extend(Sub,Sup){ // Sub 子类 , Sup 掺元类
  for(var item in Sup.prototype){
    if(!Sub.prototype[item]){ // 如果子类没有存在同名成员
      Sub.prototype[item] = Sup.prototype[item]; // 那么复制掺元类成员到子类原型对象中
    }
  }
}

// 定义两个子类 A,B
function A(x,y){
  F.call(this,x,y);
}
function B(x,y){
  F.call(this,x,y);
}

// 调用extend函数实现原型属性,方法的拷贝
extend(A,F);
extend(B,F);
console.log(A.prototype);

// 测试继承结果
var a = new A(2,3);
console.log(a.x); // 2
console.log(a.getx()); // 2
console.log(a.gety()); // 3

var b = new B(1,2);
console.log(b.x); // 1
console.log(b.getx()); // 1
console.log(b.gety()); // 2
通过此种方式把多个子类合并到一个子类中,就实现了多重继承。
【Bug已解决】codex: rate limit 429 / Too many requests / RPM exceeded — CodeX CLI 速率限制解决方案 CodeX CLI 触发 429 速率限制(RPM/TPM/并发)的解决方案,含请求间隔、自动重试、便宜模型、Tier 升级与多 Key 轮换。 阅读详情

相关推荐

【自然语言处理(NLP)实战】LSTM网络实现中文文本情感分析(手把手与教学超详细)

在当今数字化时代,人们在社交媒体、评论平台以及各类在线交流中产生了海量的文本数据。这些数据蕴含着丰富的情感信息,从而成为了深入理解用户态度、市场趋势,甚至社会情绪的宝贵资源。自然语言处理(NLP)的发展为我们提供了强大的工具,使得对文本情感进行分析成为可能。在这个领域中,长短时记忆网络(LSTM)凭借其能够捕捉文本序列中长距离依赖关系的能力,成为了情感分析任务中的一项重要技术。通过详细的步骤和示例代码,深入了解如何处理中文文本数据、构建LSTM模型、进行训练和评估。

halo的博客 2万+

【JavaScript】面向对象之继承

重学JavaScript06----- 面向对象之继承 文章目录重学JavaScript06----- 面向对象之继承继承1、了解原型链2、Object的原型3、通过原型链实现继承原型链继承的弊端4、借用构造函数继承借用构造函数也是有弊端的5、通过原型式继承函数继承6、寄生式继承函数7、寄生组合式继承 继承 继承可以帮助我们将重复的代码和逻辑抽取到父类中,子类只需要直接继承过来使用即可。 1、了解原型链 在真正实现继承之前,我们先来理解一个非常重要的概念:原型链。 从一个对象上获取属性,如果在当前对象中

m0_68324632的博客 1332

Unity开发HoloLens应用:从打包到部署的完整指南

本文为Unity开发者提供了将应用部署到HoloLens设备的完整实战指南。详细讲解了从环境准备、Unity项目配置、生成Visual Studio工程,到最终构建APPX安装包并通过设备门户或Visual Studio进行部署的全流程,帮助开发者高效完成混合现实应用的打包与安装。

red88的博客 1022

js中面向对象的继承以及继承的几种写法(详解)

从运行结果可以看出,这个Student实例对象有自己的属性,Student类的prototype指向父类Person的一个实例对象,可以使用父类实例对象的属性,而父类的实例对象的prototype又指向父类的原型对象,故Student可以调用父类原型中的方法。=> for in 的遍历和属性不可改, 在书写构造函数的时候, 原型上写的是方法, 构造函数体内写的是属性。-> true, 表示该 key 在该对象的原型链上(可能是自己的属性, 也可能是原型上的属性)

m0_46667806的博客 663

set_data_check专题[使用,report_timing,setup/hold检查]

set_data_check用于约束『数据-对-数据』的『建立保持』时间检查,通常被称为非时序约束 ( non-sequential constraints ), 理论上set_data_check 可以设在任意的两个data pin 上,其中一个pin 称为 constrained pin 类似于寄存器的data pin, 另一个pin 称为related pin 类似于寄存器的clock pin.

cy413026的博客 1万+

浪潮服务器ESXI6.7部署实战:手动集成RAID驱动避坑指南

本文详细介绍了在浪潮服务器上部署ESXI6.7时手动集成RAID驱动的完整流程和避坑指南。从驱动获取、解压技巧到封装实战,逐步解决国产服务器常见的驱动缺失问题,特别针对PM8060 RAID卡提供具体解决方案,帮助IT运维人员顺利完成ESXI部署。

weixin_33725722的博客 463

JavaScript面向对象的三大特性

1、JavaScript面向对象的三大特性 JavaScript的三大特性:封装性、继承性、多态性。 2、JavaScript实现封装特性   在一些静态类型的语言如java中,本身语法就提供了这些功能。js当中只能依靠变量的作用域来实现封装的特性,并且只能模拟出public和private两种特性。封装实现就是是对象内部的变化对外界是透明的,不可见。这种做法使对象之间低耦合,便于维护升级,...

weixin_30621711的博客 269

利用PaddleOCR识别增值税发票平台验证码(开箱即用)

下面直接讲解利用paddleocr识别的思路,为什么使用paddleocr,因为paddle中集成了较好的ocr文字识别模型,开箱即用即可,废话不多说,剑指主题,识别思路步骤如下。

码王吴彦祖的博客 5545

JS面向对象高级-7种继承方法

JS面向对象高级-6种继承方法

SYQ15544423296的博客 699

Android 14安装的APK默认允许运行时权限

本文介绍了在Android系统中实现安装应用后自动授予运行时权限的方法。通过在安装完成广播中检测应用安装状态,调用新增的DefaultPermissionGrantPolicy.grantAppRuntimePermissions()函数来授予常规权限,并使用allowSpecialPermission()处理特殊权限(如安装未知应用和悬浮窗权限)。文章详细说明了如何修改DefaultPermissionGrantPolicy类,添加grantAppRuntimePermissions和grantRunti

热衷于Android Framework和系统APP的修改经验分享 686

【教程4>第5章>第28节】基于帧同步+相位同步+位同步的QPSK调制解调通信系统整体性能分析

综上所述:1.SNR<10db时,整体性能下降,当SNR=0db时,系统无法正常工作。2.gardner环性能达到2.5e-5时偏可以正常工作,增加之后无法正常工作。3.当相位偏差大于pi/4的时候,对最后的性能会有一定影响。

FPGA/MATLAB学习教程/源码/项目合作开发 558

JS面向对象及继承

创建对象的方法及对象继承的方式。像组合继承不共享引用类型属性,它结合原型链继承和构造函数继承的优点,通过在子构造函数中调用父构造函数来继承属性,同时将子构造函数的原型设置为父构造函数的实例......

qq_53911056的博客 917

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

韩顺平 javascript教学视频_学习笔记19_js面向对象三大特征(封装,继承,多态)

js面向对象编程------三大特征 封装继承多态 面向对象的三大特征对任意的面向对象语言都是具有的,只是表现形式不一样 面向对象的三大特征都是先从抽象这个概念出来的 封装:什么是封装 js提供有以下几种控制方法和属性的访问权限 公开级别:对外公开,在类的外部可以使用私有级别:类本身可以访问,不对外

郁孤台之魂 1939

NTscan扫描工具

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

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

JavaScript-day24------主要内容有this指向的改变;面向对象的三大特征;构造函数的继承等

1.this指向的改变 改变this指向 call() 用于改变this指向 第一次参数表示要改变成的那个this指向,后面的参数表示该函数的参数 fn() -> fn.call() bind() 用于改变this指向 bind 只会改变this指向,但不会调用函数 ---- 返回了这个函数 apply() ...

莫名的博客 373

IMSL CNL 7.0.0 (x86-64)Crack

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

Javascript 浅析面向对象

1、面向对象 面向对象的语言最基本的标志就是类的概念。什么是类?类是包含多个属性和方法的集合,类的实例即对象。 面向对象的三大特征是继承、封装、多态。JS可以模拟实现继承和封装,但是无法模拟实现多态,所以我们说JS是一门基于对象的语言,而非是面向对象的语言。 Javascript是一种基于对象(object-based)的语言,你遇到的所有东西几乎都是对象。但是,它又不是一种真正的面向对象...

hopefullman的博客 218

js-面向对象

面向对象 对象:现实中一切事物都叫做对象 面向对象的实体:包含属性和行为的集合 js没有类的概念,叫做对象,思想上是基于对象,js下定义对象还是用函数体定义。 基于对象和面向对象的区别: 面向对象:自己设置图纸,照着图纸盖房子 基于对象:别人有一个房子,我照着房子创建 面向对象的三大特征: 1.封装:每一个对象就是...

weixin_47775987的博客 140

原型的指向和继承

原型指向可以发生变化 实例对象中的原型__proto__指向的是创建这个对象的构造函数中的原型对象prototype 构造函数中的原型对象prototype的指向发生了改变,实例对象中的原型__proto__指向也会发生改变 构造函数中的原型对象prototype的指向发生了改变,实例对象中的原型__proto__指向也会发生改变 面向对象的三大特征:封装,继承,多态 封装:包装,把一个值放到...

weixin_44740410的博客 228

JavaScript学习总结(5)——Javascript面向(基于)对象编程

2019独角兽企业重金招聘Python工程师标准>>> ...

weixin_33682719的博客 152

面向对象、原型与原型链

是一种编程思想,它将程序中的数据和操作数据的方法封装在一起,形成“对象”,通过对象之间的交互来实现程序功能。

m0_72052793的博客 239

js面向对象及面向对象的三大特性

一:js面向对象编程 在es5中我们是这样去写面向对象的编程方式的: function Person(name) { //构造函数里面的方法和属性 this._name = name; this.getName = function () { console.log(this._name); }; this.setName = function (name) { this._name = name; }; }

m0_53592673的博客 183

面向对象的三大特征

面向对象的三大特征(11.29) 封装:在好书内部作用域中声明一个变量,只能内部访问到、 继承:1.对象冒充 代码实现 const Person = function (name, age) { this.name = name; this.age = age; } Person.prototype.test = "this is a test"...

weixin_44868597的博客 170
上一篇: 面向对象在javascript中的三大特征之封装
下一篇: 面向对象在javascript中的三大特征之多态
Wang's Blog
博客等级 码龄12年 7440粉丝 2427原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值