• 关于

    自定义函数()

    的搜索结果

回答

1、在js中,()本身是有执行一段表达式(对象、函数)的功能的,返回表达式或者表达式结果。譬如 (1)、(function(){return 1;})、(1+2)。2、function(){} 这叫做匿名函数。所以(function(){var test = 'Hello world';}) 会返回一个function,因为js一切皆对象,我们不妨var a = (function(){var test = 'Hello world';}); , a这是一个函数a(),也就是(function(){var test = 'Hello world';})(); 是函数调用,会执行 var test = 'Hello world'; 3、理解闭包,要先理解作用域、理解函数定义。函数定义时,会创建一个context的东西,把函数用到的,包括并不是函数内定义的变量,绑定到自身,这样就创建了一个闭包。单纯说某个函数是不是闭包,没有什么意义,因为闭包是语言层面的东西,应该说js函数支持闭包。用a123456678的例子:(function() { var test = 'Hello world'; // 定义,外层函数作用域,有自己的context return (function() {return test; // 引用,内层函数作用域,有自己的context});})()();

lrq1988 2019-12-02 03:10:20 0 浏览量 回答数 0

回答

struct David { var x = 0;//定义一个结构体,两个字段x,y var y = 0;//初始值 //定义结构体的构造函数 init(){ //定义一个空构造函数,真正的构造函数,调用时候不带参数调用这里 //构造函数是以init 开头的,自动调用 // [[oc alloc]init]不是构造函数 println("in init"); } init(x:Int,y:Int){ self.x = x;//定义带有2个参数的构造函数,带双参数的时候调用这里 self.y = y; println("in init(x:y:)") } //结构体有构造函数,没有析构函数 func getCenter()->Int{ return (x+y)/2; } //给现有的点x,y加偏移量 //obj.addOffset(100,deltaY:) mutating func addOffset (deltaX:Int,deltaY:Int){ //结构体是拷贝的对象,函数内部不能修改变量 //需要修改,加关键字mutating, //mutating,可以修改构造函数内部变量 x += deltaX; y += deltaY; } }; func testDavid(){ //定义一个结构体 //结构体的定义是 结构体的名字(参数名:参数值) var d = David();//调用构造函数init() var s = David(x: 100, y: 200);//调用构造函数init(x,y) println("s.x = \(s.x), s.y = \(s.y)") let c = s.getCenter();//调用析构函数getCenter println("c is \(c)"); s.addOffset(100, deltaY: 200);//因为析构函数没有返回值,所以不能赋值给变量 println("d is :\(s.x)"); } testDavid();//测试函数调用

杨冬芳 2019-12-02 03:00:21 0 浏览量 回答数 0

问题

expandablelistview中自定义的child无法点击

爵霸 2019-12-01 19:33:44 851 浏览量 回答数 1

阿里云试用中心,为您提供0门槛上云实践机会!

0元试用32+款产品,最高免费12个月!拨打95187-1,咨询专业上云建议!

回答

首先要理解几个概念: 【概念】 Tn :一个算法中的语句执行次数称为语句频度或时间频度,记为T(n)。n称为问题的规模,当n不断变化时,时间频度T(n)也会不断变化。 * 算法中基本操作重复执行的次数,是问题规模 n 的某个函数,用T(n)表示 O(f(n)):称算法的渐进时间复杂度。 * 若有某个辅助函数f(n),使得当n趋近于无穷大时,T(n)/f(n)的极限值为不等于零的常数,则称f(n)是T(n)的同数量级函数记作T(n)=O(f(n)) *T(n)=O(f(n)),这里的"O"是数学符号,它的严格定义是 "若T(n)和f(n)是定义在正整数集合上的两个函数,则T(n)=O(f(n))表示存在正常数C和n0 ,使得当n≥n0时都满足0≤T(n)≤C*f(n)。"(即书本中的定义)。通俗一点就是这两个函数当整型自变量n趋向于无穷大时,两者的比值是一个不等于0的常数。 【分析】 T(n)是某个算法的时间耗费,它是该算法所求解 问题规模 n的函数,而后者O(f(n))是指当问题规模趋向无穷大时,该算法时间复杂度的数量级。当我们评价一个算法的时间性能时,主要标准就是算法的渐近时间复杂度O(f(n)),因此,在算法分析时,往往对两者不予区分,经常是将渐近时间复杂度T(n)=O(f(n))简称为时间复杂度,其中的f(n)一般是算法中频度最大的语句频度。 【计算】 Tn=n+(n+1)+(n-4)(2n+1)+2n(n-1)=4n^2-2n-1 当n→∞时 , T(n),f(n^2) 两个函数的比值是一个常数。 所以这个关系成立:T(n)=O(n^2) 【常见的时间复杂度】 按数量级递增排列依次为: 常数阶O(1)、对数阶O(log2n)或O(lbn)、线性阶O(n)、线性对数阶O(n*log2n)、平方阶O(n^2)、立方阶O(n^3)、k次方阶O(n^k)、指数阶O(2^n)。

小哇 2019-12-02 01:22:23 0 浏览量 回答数 0

回答

ThinkPHP 自动验证定义的附加规则如下:regex:使用正则进行验证(默认)unique:验证唯一性confirm:验证表单中的两个字段是否相同equal:验证是否等于某个值in:验证是否在某个范围内function:使用函数验证callback:使用方法验证自动验证例子各种自动验证参考例子如下:// 默认情况下用正则进行验证 array('title','require','标题不能为空。'), array('order','number','排序必须是数字。',2), array('email','email','邮箱格式不符合要求。'), array('qq','qq','QQ号码不正确。'), // 在新增的时候验证标题title字段是否唯一 array('title','','标题已经存在!',0,'unique',1), // 验证确认密码是否和密码一致 array('repassword','password','确认密码不正确。',0,'confirm'), // 验证class填写的值为 一班 array('class','一班','班级必须填写一班。',0,'equal'), // 当值不为空的时候判断是否在一个范围内 array('value',array(1,2,3),'值的范围不正确。',2,'in'), // 自定义函数验证用户名格式 array('username','checkName','用户名格式不正确。',0,'function'), // 在注册或更改资料是调用 checkEmail 方法检查邮箱 array('email','checkEmail',1,'callback'), 使用正则表达式(regex)验证上述几类附加规则中,使用正则表达式是经常使用的,也是系统默认的验证附加规则。系统内置了如下正则检测规则:require(必须)、email(邮箱格式)、url(URL地址)、currency(货币)、number(数字)、qq(QQ号码)、english(英文字符)。这些附加规则可以直接使用,如果这些附加规则无法满足要求,可以使用自定义的正则规则:array('username','/^{3,15}$/','用户名不符合要求。'),该规则要求用户名只能为英文字符及下划线和数字组成,且长度为3-15个字节。要了解更多的正则表达式规则参见《PHP 常用正则表达式整理》。使用自定义函数(function)验证使用自定义函数验证附加规则,函数可以是 Common/common.php 里的自定义函数,也可以是 PHP 的内置函数: class UserModel extends Model{ protected $_validate = array( array('username','checkName','用户名不符合要求。',0,'function'), }; } 自定义 checkName 函数: function checkName($username){ if(!preg_match('/^{3,15}$/', $username)){ return false; }else{ return true; } } 提示:对于用户名的规则可以直接使用正则验证而无需函数,在此只是为了演示自定义函数的验证的用法而已。使用方法(callback)验证ThinkPHP 自动验证还支持调用当前 Model 类的一个方法来进行验证。 class UserModel extends Model{ protected $_validate = array( array('email','checkEmail','邮箱已经存在。',1,'callback'), }; // checkEmail方法 2 protected function checkEmail(){ $User=new Model('User'); // 新用户注册,验证唯一 if(empty($_POST<'uid'>)){ if($user->getByEmail($_POST<'email'>)){ return false; }else{ return true; } }else{ // 更改资料判断邮箱与其他人的邮箱是否相同 if($user->where("uid!={$_POST<'uid'>} and email='{$_POST<'email'>}'")->find()){ return false; }else{ return true; } } } } 当 checkEmail 方法返回 false 时,验证就不通过。可见 ThinkPHP 自动验证功能十分强大,能满足对表单的各种验证要求。

小旋风柴进 2019-12-02 02:02:35 0 浏览量 回答数 0

回答

/自定义拷贝构造函数classname(const classname &ob){//自定义拷贝构造函数的函数体} // 其中ob是用来初始另一个对象的对象的引用 class StringData{private: char *str;public:StringData(char *s){ str=new char[strlen(s)+1];strcpy(str,s);}StringData(const StringData &p){ str=new char[strlen(p.str)+1];strcpy(str,p.str);}~StringData() { delete str; }//…}; int main(){ StringData x(“abc”); StringData y(x);} 拷贝构造函数是一种特殊的构造函数。它用于依据已存在的对象建立一个新对象。如果一个对象里面有指针成员,并且这个指针已经动态分配空间了,同时,对象有析构函数对这个指针进行释放。如上面那个例子,如果我们通过这个对象创建一个新对象:A a("123");A b = a; // 调用拷贝构造函数 如果我们没有自定义拷贝构造函数,导致对象 a 和 b 的指针成员指向同一个地址空间,当对象生命周期结束时,a 和 b 都会调用析构函数,最后导致,这个指针会被释放 2 次,导致内存出问题。 所以,对象有指针成员,尽量自定义拷贝构造函数。

a123456678 2019-12-02 01:58:51 0 浏览量 回答数 0

回答

1)这个3个函数有可能会被重用吗?如果这3个函数只是某个功能模块的函数,那就没有必要放在全局中去声明,甚至直接写成匿名函数都可以2).fadeIn( [duration ] [, complete ] ) fadeIn可以在动画结束后调用执行的函数function readyCountStart(callback){ $('#countBox').fadeIn(1000,callback); } readyCountStart(function(){ panelActivate(); stopWatchStart(); });或function Game(){} Game.prototype.start=function(){ function panelActivate(){ } function stopWatchStart(){ } $('#countBox').fadeIn(1000,function(){ panelActivate(); stopWatchStart(); }); )3) 如像降低模块之间的耦合度,那么使用自定义事件监听机制是个好方法。模块之间可以完全不管对方是否存在,发事件消息的管发消息,监听消息的只关心想要的事件是否发生了。耦合度最低~~

小旋风柴进 2019-12-02 02:24:49 0 浏览量 回答数 0

问题

如何在Python中将函数参数作为键传递给字典?

养狐狸的猫 2019-12-01 19:57:57 9 浏览量 回答数 1

回答

隐式的基类——object Python是面向对象程序设计语言,有一个类似root的基础类object类。任何自定义的类,都会隐式继承object。 class X: pass print(X.__class__) print(X.__class__.__base__) 基类中的初始化方法 延迟赋值这是指先创建类模板,然后在实例中定义属性并赋值。在Python中,延迟赋值的合法的,但是会存在潜在问题,因此要尽量避免这样的用法。 在基类中实现__init__()方法 每当创建一个对象,Python会先创建一个空对象,然后调用该对象的__init__()函数。 一个常见的多态设计 class Card: def __init__(self,rank,suit): self.suit = suit self.rank = rank self.hard, self.soft = self._points() class NumberCard(Card): def _points(self): return int(self.rank), int(self.rank) class AceCard(Card): def _points(self): return 1, 11 class FaceCard(Card): def _points(self): return 10, 10 使用__init__()方法创建常量清单 可以把创建好的花色对象做缓存,构建一个常量池,使得在调用时对象可被重用,那么性能将得到显著的提升。 class Suit: def __init__(self, name, symbol): self.name = name self.symbol = symbol Club, Diamond, Heart, Spade = Suit('Club','♠'), Suit('Diamond','♦'), Suit('Heart','♥'), Suit('Spade','♣') Cards = [AceCard('A', Spade), NumberCard('2',Spade), NumberCard('3',Spade)]使用工厂函数调用__init__() 可以使用工厂函数来完成所有的Card对象的创建。在Python中实现工厂有两种途径 定义一个函数,返回不同类的对象定义一个类,包括了创建对象的方法一个用来生成Card子类对象的工厂函数例子 def card(rank, suit): if rank == 1: return AceCard('A',suit) elif 2 <= rank < 11: return NumberCard(str(rank),suit) elif 11 <= rank < 14: name = {11: 'J', 12: 'Q', 13: 'K'}[rank] return FaceCard(name, suit) else: raise Exception('Rank out of range.') deck = [card(rank,suit) for rank in range(1,14) for suit in (Club, Diamond, Heart, Spade)] 这里需要注意的是if语句的结构,else语句没有做一些其他步骤,而只是单纯地抛出了一个异常。像这样的catch-all else语句的使用方式是有争议的。 使用elif简化设计来获得一致性 工厂方法card()中包括了两个很常见的结构 if-elif序列映射这是一个没有使用映射Card工厂类的例子 def card3(rank, suit): if rank == 1: return AceCard('A',suit) elif 2 <= rank < 11: return NumberCard(str(rank),suit) elif rank == 11: return FaceCard('J', suit) elif rank == 12: return FaceCard('Q', suit) elif rank == 13: return FaceCard('K', suit) else: raise Exception('Rank out of range.') 相比上一个版本,这个函数在实现上获得了更好的一致性。 使用映射和类来简化设计 下面这个例子用映射来实现,把rank映射为对象,然后又把rank值和suit值作为参数传入Card构造函数来创建Card实例。 def card4(rank, suit): class_ = {1: AceCard, 11: FaceCard, 12: FaceCard, 13: FaceCard}.get(rank, NumberCard) return class_(rank, suit) 实现两部分映射 并行映射不推荐使用 映射到一个牌面值的元组 def card5(rank, suit): class_, rank_str = {1: (AceCard,'A'), 11: (FaceCard,'J'), 12: (FaceCard,'Q'), 13: (FaceCard,'K')}.get(rank,(NumberCard,str(rank))) return class_(rank_str, suit) partial函数设计partial()函数在面向对象编程中不是很常用。 工厂模式的流畅API设计class CardFactory: def rank(self, rank): self.class_, self.rank_str = {1: (AceCard,'A'), 11: (FaceCard,'J'), 12: (FaceCard,'Q'), 13: (FaceCard,'K')}.get(rank,(NumberCard,str(rank))) return self def suit(self, suit): return self.class_(self.rank_str, suit) card8 = CardFactory()deck8 = [card8.rank(r+1).suit(s) for r in range(13) for s in (Club, Diamond, Heart, Spade)] 这种方法并没有利用__init__()在Card类层次结构中的作用,改变的是调用者创建对象的方式。 在每个子类中实现__init__()方法 class Card: def __init__(self, rank, suit, hard, soft): self.suit = suit self.rank = rank self.hard = hard self.soft = soft class NumberCard(Card): def __init__(self, rank, suit): super().__init__(str(rank), suit, rank, rank) class AceCard(Card): def __init__(self, rank, suit): super().__init__('A', suit, 1, 11) class FaceCard(Card): def __init__(self, rank, suit): super().__init__({11: 'J', 12: 'Q', 13: 'K'}[rank], suit, 10, 10) 使用__init__()方法和工厂函数之间存在一些权衡。通常直接调用比“程序员友好”的__init__()函数并把复杂性分发给工厂函数更好。 简单的组合对象 一个组合对象也可以称作容器。 设计集合类,通常有如下3种策略: 封装扩展创建封装集合类 定义Deck类,内部实际调用的是list对象。Deck类的pop()方法只是对list对象响应函数的调用。 class Deck: def __init__(self): self._cards = [card8.rank(r+1).suit(s) for r in range(13) for s in (Club, Diamond, Heart, Spade)] random.shuffle(self._cards) def pop(self): return self._cards.pop() 扩展集合类 pop()函数只需继承自list集合就可以很好地工作,其他函数也一样。 class Deck2(list): def __init__(self): super().__init__(card8.rank(r+1).suit(s) for r in range(13) for s in (Club, Diamond, Heart, Spade)) random.shuffle(self) 完成组合对象的初始化 __init__()初始化方法应当返回一个完整的对象,这是理想的情况。 不带__init__()方法的无状态对象 对于策略模式的对象来说这是常见的设计。一个策略对象以插件的形式符合在主对象上来完成一种算法或逻辑,例如GameStrategy类。 作者:plutoese链接:https://www.jianshu.com/p/a5cb4070e733來源:简书著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

xuning715 2019-12-02 01:10:28 0 浏览量 回答数 0

问题

我可以使用group by的自定义分区程序吗?

flink小助手 2019-12-01 19:23:57 562 浏览量 回答数 1

回答

在 /pages 目录的 .js 文件中,定义 Page(),用于注册一个小程序页面,接受 一个 object 作为属性,用来指定页面的初始数据、生命周期回调、事件处理等。 以下为一个基本的页面代码: Page({ data: { title: "Alipay", }, onLoad(query) { // 页面加载 }, onShow() { // 页面显示 }, onReady() { // 页面加载完成 }, onHide() { // 页面隐藏 }, onUnload() { // 页面被关闭 }, onTitleClick() { // 标题被点击 }, onPullDownRefresh() { // 页面被下拉 }, onReachBottom() { // 页面被拉到底部 }, onShareAppMessage() { // 返回自定义分享信息 }, // 事件处理函数对象 events: { onBack() { console.log('onBack'); }, }, // 自定义事件处理函数 viewTap() { this.setData({ text: 'Set data for update.', }); }, // 自定义事件处理函数 go() { // 带参数的跳转,从 page/ui/index 的 onLoad 函数的 query 中读取 type my.navigateTo({url:'/page/ui/index?type=mini'}); }, // 自定义数据对象 customData: { name: 'alipay', }, }); 内容来源:https://developer.aliyun.com/article/756818?spm=a2c6h.12873581.0.dArticle756818.26162b70Su1GZy&groupCode=tech_library

KaFei 2020-04-27 14:09:39 0 浏览量 回答数 0

回答

首先out是System类的静态变量,其类型是PrintStream, println()是PrintStream的一个静态函数,如果其参数为对象,则调用该对象的toString()函数, 你程序里days[0]是个你自定义的Date对象,该对象没定义toString()这个函数,但Java中所有的类最终都继承自java.lang.Object对象,所以此时调用的是java.lang.Object.toString()这个函数, 根据java API中的这个函数的说明,其输出的是:getClass().getName() + '@' + Integer.toHexString(hashCode()),也就是:类名@16进制形式的hashCode。 同样Date没定义hashCode()这个函数,所以调用的是 java.lang.Object.hashCode(),这个函数输出的是该对象在内存中的地址。 所以结果就是:Date@20f0691c 详情请参考Java API文档,地址:http://docs.oracle.com/javase/7/docs/api/

爵霸 2019-12-02 02:40:03 0 浏览量 回答数 0

回答

详细解答可以参考3. 自定义样式通知(V2.3.3及以上版本开始支持)">官方帮助文档Android Push SDK支持用户自定义通知样式,用户可以设定自己的通知样式,涉及的内容包括通知的提醒方式(声音、震动、静默),通知在状态栏的显示图标,推送消息应用内到达时是否创建通知以及自定义通知布局文件等。自定义样式通知的设置包括两部分: 3.1 客户端设置通知样式 用户利用SDK提供的自定义通知样式接口创建自定义样式通知。SDK中有两个自定义样式通知类:1)BasicCustomPushNotification;2)AdvancedCustomPushNotification。其中BasicCustomPushNotification用户设置基础样式,包括提醒方式、状态栏图标以及当推送消息到达时应用正处于前台情况下是否创建该通知等。AdvancedCustomPushNotification是BasicCustomPushNotification的子类,继承了BasicCustomPushNotification的所有方法,同时还可以设置通知样式布局文件每个样式都需要对应一个特定的整数类型id,如果多个样式设置为同一个id,则最后设置的样式有效。如果SDK没有找到对应id的样式则会创建默认样式的通知样式只需设置一次,SDK会记住这个设置,在需要使用时加载对应样式具体使用例子请参考Demo 3.2 后端推送消息时添加自定义样式id 用户利用OpenApi推送消息时设定特定样式的id服务端不能设置样式,只能指定需要展现的样式id指定id的样式必须在客户端已经进行设置,否则SDK会创建默认样式的通知 3.3 Example BasicCustomPushNotification" class="reference-link">Example-BasicCustomPushNotificationBasicCustomPushNotification notification = new BasicCustomPushNotification();notification.setRemindType(BasicCustomPushNotification.REMIND_TYPE_SOUND);notification.setStatusBarDrawable(R.drawable.logo_yuanjiao_120);boolean res = CustomNotificationBuilder.getInstance().setCustomNotification(1, notification); AdvancedCustomPushNotification" class="reference-link">Example-AdvancedCustomPushNotificationAdvancedCustomPushNotification notification = new AdvancedCustomPushNotification(R.layout.notitfication_layout, R.id.m_icon, R.id.m_title, R.id.m_text);notification.setServerOptionFirst(true);notification.setBuildWhenAppInForeground(false);boolean res = CustomNotificationBuilder.getInstance().setCustomNotification(2, notification); OpenApi" class="reference-link">Example-OpenApi客户端设置完成后,服务端在推送通知时需要利用OpenApi指明对应的自定义样式ID final SimpleDateFormat dateFormat = new SimpleDateFormat("MM-dd HH:mm:ss");final String date = dateFormat.format(new Date());PushRequest pushRequest = new PushRequest();// 推送目标pushRequest.setAppKey(appKey);pushRequest.setTarget("device"); //推送目标: device:推送给设备; account:推送给指定帐号,tag:推送给自定义标签; all: 推送给全部pushRequest.setTargetValue("deviceId"); // 推送配置pushRequest.setType(1); // 0:表示消息(默认为0), 1:表示通知pushRequest.setTitle(date); // 消息的标题pushRequest.setBody("PushRequest body"); // 消息的内容pushRequest.setSummary("PushRequest summary"); // 通知的摘要pushRequest.setAndroidNotificationBarType(2);//设置的通知样式ID,通知栏自定义样式范围0-100// 推送配置: AndroidpushRequest.setAndroidOpenType("1"); // 点击通知后动作,1:打开应用 2: 打开应用Activity 3:打开 urlpushRequest.setAndroidExtParameters("{\"_NOTIFICATION_BAR_STYLE_\":\"2\"}"); 3.4 BasicCustomPushNotification API 默认构造函数 BasicCustomPushNotification的默认构造函数,所有配置采用默认设置:通知方式采用震动+通知;NotificationFlag采用Notification.FLAG_AUTO_CANCEL,状态栏图标用的是android.R.drawable.stat_notify_chat。 public BasicCustomPushNotification(); 构造函数参数 drawable 状态栏图标flags NotificationFlags,支持系统Notification下的Flag参数remindType 提醒类型,有BasicCustomPushNotification.REMIND_TYPE_SILENT:静默;BasicCustomPushNotification.REMIND_TYPE_VIBRATE:震动;BasicCustomPushNotification.REMIND_TYPE_SOUND:声音;BasicCustomPushNotification.REMIND_TYPE_VIBRATE_AND_SOUND:声音+震动 public BasicCustomPushNotification(int drawable, int flags, int remindType); 获取状态栏图标 获取已设置的状态栏图标 public int getStatusBarDrawable() 设置状态栏图标 更改状态栏图标设置 参数 statusBarDrawable 状态栏图标资源id public void setStatusBarDrawable(int statusBarDrawable); 获取提醒方式 获取已经设置的提醒方式 public int getRemindType(); 设置提醒方式 更改自定义通知的提醒方式 参数 remindType 提醒方式,提供的参数有:BasicCustomPushNotification.REMIND_TYPE_SILENT:静默;BasicCustomPushNotification.REMIND_TYPE_VIBRATE:震动;BasicCustomPushNotification.REMIND_TYPE_SOUND:声音;BasicCustomPushNotification.REMIND_TYPE_VIBRATE_AND_SOUND:声音+震动 public void setRemindType(int remindType); 获取Notification Flags参数 获取已经设置的notification flag参数 public int getNotificationFlags(); 设置Notification Flags参数 更改自定义通知的flags参数 参数 notificationFlags 支持系统自带的Notification Flag参数 public void setNotificationFlags(int notificationFlags); 获取是否服务端设置优先 利用OpenApi或者阿里云推送控制台推送消息都可以设置提醒方式,当后端设置的提醒方式和自定义样式提醒方式冲突时,SDK根据serverOptionFirst参数来判断提醒方式策略。如果该参数为true,则采用后端设定的提醒方式;如果该参数为false,则采用自定义样式指定的提醒方式。默认为false public boolean isServerOptionFirst(); 设置是否服务端优先 更改自定义通知的serverOptionFirst参数 参数 serverOptionFirst 是否服务器配置优先 public void setServerOptionFirst(boolean serverOptionFirst); 获取推送前台到达否创建通知参数 当推送到达时,如果应用处在前台,用户可以通过自定义样式决定是否创建通知。默认是创建通知 public boolean isBuildWhenAppInForeground(); 设置推送前台到达否创建通知参数 更改当推送到达时应用处在前台情况下是否创建通知的设置 参数 buildWhenAppInForeground 是否创建通知 public void setBuildWhenAppInForeground(boolean buildWhenAppInForeground); 3.5 AdvancedCustomPushNotification API AdvancedCustomPushNotification是BasicCustomPushNotification的子类,继承了上文中BasicCustomPushNotification的所有方法。 AdvancedCustomPushNotification构造函数 AdvancedCustomPushNotification类的构造函数,AdvancedCustomPushNotification没有默认构造函数 参数 view 自定义通知布局文件id。注:Notification的自定义布局是RemoteViews,和其他RemoteViews一样,在自定义视图布局文件中,仅支持FrameLayout、LinearLayout、RelativeLayout三种布局。iconViewId 自定义布局文件中icon的viewIdtitleViewId 自定义布局文件中title的viewIdcontentViewId 自定义布局文件中显示通知正文的viewId public AdvancedCustomPushNotification( int view, int iconViewId, int titleViewId, int contentViewId); 设置通知图标 设置通知栏中显示的图标,该图标显示在iconViewId所指定的控件中。 参数 icon icon图标资源id public void setIcon(int icon); 获取通知图标 获取设置的通知图标 public int getIcon(); 3.6 CustomNotificationBuilder API CustomNotificationBuilder用于注册用户设定好的自定义样式通知 获取CustomNotificationBuilder实例 CustomNotificationBuilder是单例类,必须通过指定接口来获取实例 public static CustomNotificationBuilder getInstance(); 注册自定义样式通知 用户创建好自定义样式通知后需要将其注册,并赋予其一个特定的id 参数 customNotificationId 所注册的自定义样式通知的id,id必须大于0。如果将多个不同的自定义样式通知赋予同一个id,则最后注册的通知有效,其他的通知将会被覆盖notification 创建的通知,该通知可以是BasicCustomPushNotification对象也可以是AdvancedCustomPushNotification对象,但是不能为null 返回 该方法会返回一个boolean类型的结果,如果返回true,则注册成功;反之则失败。 public boolean setCustomNotification(int customNotificationId, BasicCustomPushNotification notification);

2019-12-01 23:11:48 0 浏览量 回答数 0

问题

SQL 兼容性怎么样?

猫饭先生 2019-12-01 21:19:24 905 浏览量 回答数 0

问题

请问如何才能将本地时间保存成txt文件的文件名

a123456678 2019-12-01 20:28:15 1054 浏览量 回答数 1

回答

非模板友元 声明一个常规友元 template class HasFriend { public:   friend void counts(); } 上边的声明使counts()函数成为模板所有实例化的友元 counts()函数不是通过对象调用的(它是友元,不是成员函数),也没有对象参数,那么它如何访问HasFriend对象的呢 有很多种可能性。它可以访问全局对象;可以使用全局指针访问非全局对象;可以创建自己的对象;可以访问独立对象的模板类 的静态数据成员。 如果要为友元函数提供械板类参数,可以如下所示来进行友元声明。要提供模板类参数,必须指明基体化 template class HasFriend {   friend void report(HasFriend &); } report()本身并不是模板函数,而只是使用一个模板作参数。这意味着必须要使用的友元定义显式基体化: void report(HasFriend &){....} void report(HasFriend &){...}; 也就是说report(HasFriend &)将成为HasFriend类的友元。 复制代码 includeusing std::cout;using std::cin;using std::endl; templateclass HasFriendT{private: TT item;static int ct;public: HasFriendT(const TT & i):item(i){ct++;};~HasFriendT(){ct--;};friend void counts();friend void report(HasFriendT &);}; template int HasFriendT::ct = 0; void counts(){ cout<<"int count: "<::ct<<";";cout<<"double count:"<::ct<} void report(HasFriendT & hf){ cout<} void report(HasFriendT & hf){ cout<}int main(){ counts();HasFriendT hfi1(10);counts(); HasFriendT hfdb(10.5);report(hfi1);HasFriendT hfi2(20); report(hfi2);report(hfdb); counts();cin.get();} //int count: 0;double count:0//int count: 1;double count:0//10//20//10.5//int count: 2;double count:1复制代码 约束模板友元函数友元的类型取决于类被实例化时的类型 可以修改上边的示例,使友元函数本身成为模板。具体的说,为约束模板友元作准备,要使类的每一个基体 化都获得与友元匹配的基体化。这需要3部 1首先,在类定义的前面声明每个模板函数 template void counts() template void report(T &); 2然后,在函数中再次将模板声明为友元。这些语句根据类模板参数的类型声明具体化: template class HasFriendT {   friend void counts();   friend void report<>(HasFriendT &); }; 声明中的<>指出这是模板具体化。对于report(),<>可以为空,因为可以从函数参数推断出如下模板类型参数: HasFriendT 然而也可以使用: report>(HasFriendT &) 但是counts()函数没有参数,因此必须使用模板参数语法()来指明其基体化。还需要注意的是, TT是HasFriendT类的参数类型。   同样,理解这些声明的最佳方式也是设想声明一个特定具体化的对象时,它们将变成什么样子。例如, 假设声明了这样一个对象 HasFriendT squack; 编译器将用int替换TT,并生成下面的类定义 class HasFriendT {   friend void counts();   friend void report<>(HasFriendT &); } 3第三个条件是为友元提供模板定义 看例子: 复制代码 includeusing std::cout;using std::cin;using std::endl;template void counts();template void report(T &); templateclass HasFriendT{private: TT item;static int ct;public: HasFriendT(const TT & i):item(i){ct++;};~HasFriendT(){ct--;};friend void counts();friend void report<>(HasFriendT &);}; template int HasFriendT::ct = 0; templatevoid counts(){ cout<<"template size: "<)<<";";cout<<"template counts():"<::ct<}templatevoid report(T & hf){ cout<}int main(){ counts();HasFriendT hfi1(10);HasFriendT hfi2(20);HasFriendT hfdb(10.5);report(hfi1);report(hfi2);report(hfdb);cout<<"counts output:n";counts();cout<<"counts() output:n";counts();cin.get();} //template size: 4;template counts():0//10//20//10.5//counts output://template size: 4;template counts():2//counts() output://template size: 8;template counts():1复制代码counts 和couts 报告的模板大小不同,这样每种T类型都有自己的友元函数count(); 非约束模板友元 友元的所有具体化都是类的每一个具体化的友元 上边说的约束模板友元函数是在类外面声明的模板的具体化。int类型具体化获得int函数具体化, 依此类推。通过在类内部声明模板,可以创建非约束友元函数,即每个函数具体化都是每个类具体化的友元。 对于非约束友元,友元模板类型参数与模板类类型参数是不同的: template {   template   friend void Show2(C &,D &) } 上边是一个使用非约束友元函数的例子,其中,函数调用show2(hfi1,hfi2)与下面的具体化匹配: void Show2 &,ManyFriend &>(ManyFriend & c,ManyFriend & d); 因为它是所有ManyFriend 具体化的友元,所以能够访问所有具体化的item成员,但它只访问了ManyFriend对象。 同样Show2(hfd,hfd2)与下面具体化匹配: void Show2(ManyFirend &,ManyFirend &>(ManyFirend & c,ManyFirend & d); 它也是所有ManyFriend具体化的友元,并访问了ManyFirend 对象的item成员和ManyFriend对象的item成员 复制代码 includeusing std::count;using std::cout;using std::endl; templateclass ManyFriend{private: T item;public: ManyFriend(const T & i):item(i){};templatefriend void Show2(C &,D &);}; templatevoid Show2(C & c,D & d){ cout<} int main(){ ManyFriend hfi1(10);ManyFriend hfi2(20);ManyFriend hfdb(10.5); cout<<"hfi1, hfi2";Show2(hfi1,hfi2);cout<<"hfdb,hfi2: "; Show2(hfdb,hfi2);std::cin.get();} //hfi1, hfi210,20//hfdb,hfi2: 10.5,20

nothingfinal 2019-12-02 01:58:40 0 浏览量 回答数 0

回答

非模板友元 声明一个常规友元 template class HasFriend { public:   friend void counts(); } 上边的声明使counts()函数成为模板所有实例化的友元 counts()函数不是通过对象调用的(它是友元,不是成员函数),也没有对象参数,那么它如何访问HasFriend对象的呢 有很多种可能性。它可以访问全局对象;可以使用全局指针访问非全局对象;可以创建自己的对象;可以访问独立对象的模板类 的静态数据成员。 如果要为友元函数提供械板类参数,可以如下所示来进行友元声明。要提供模板类参数,必须指明基体化 template class HasFriend {   friend void report(HasFriend &); } report()本身并不是模板函数,而只是使用一个模板作参数。这意味着必须要使用的友元定义显式基体化: void report(HasFriend &){....} void report(HasFriend &){...}; 也就是说report(HasFriend &)将成为HasFriend类的友元。 复制代码 includeusing std::cout;using std::cin;using std::endl; templateclass HasFriendT{private: TT item;static int ct;public: HasFriendT(const TT & i):item(i){ct++;};~HasFriendT(){ct--;};friend void counts();friend void report(HasFriendT &);}; template int HasFriendT::ct = 0; void counts(){ cout<<"int count: "<::ct<<";";cout<<"double count:"<::ct<} void report(HasFriendT & hf){ cout<} void report(HasFriendT & hf){ cout<}int main(){ counts();HasFriendT hfi1(10);counts(); HasFriendT hfdb(10.5);report(hfi1);HasFriendT hfi2(20); report(hfi2);report(hfdb); counts();cin.get();} //int count: 0;double count:0//int count: 1;double count:0//10//20//10.5//int count: 2;double count:1复制代码 约束模板友元函数友元的类型取决于类被实例化时的类型 可以修改上边的示例,使友元函数本身成为模板。具体的说,为约束模板友元作准备,要使类的每一个基体 化都获得与友元匹配的基体化。这需要3部 1首先,在类定义的前面声明每个模板函数 template void counts() template void report(T &); 2然后,在函数中再次将模板声明为友元。这些语句根据类模板参数的类型声明具体化: template class HasFriendT {   friend void counts();   friend void report<>(HasFriendT &); }; 声明中的<>指出这是模板具体化。对于report(),<>可以为空,因为可以从函数参数推断出如下模板类型参数: HasFriendT 然而也可以使用: report>(HasFriendT &) 但是counts()函数没有参数,因此必须使用模板参数语法()来指明其基体化。还需要注意的是, TT是HasFriendT类的参数类型。   同样,理解这些声明的最佳方式也是设想声明一个特定具体化的对象时,它们将变成什么样子。例如, 假设声明了这样一个对象 HasFriendT squack; 编译器将用int替换TT,并生成下面的类定义 class HasFriendT {   friend void counts();   friend void report<>(HasFriendT &); } 3第三个条件是为友元提供模板定义 看例子: 复制代码 includeusing std::cout;using std::cin;using std::endl;template void counts();template void report(T &); templateclass HasFriendT{private: TT item;static int ct;public: HasFriendT(const TT & i):item(i){ct++;};~HasFriendT(){ct--;};friend void counts();friend void report<>(HasFriendT &);}; template int HasFriendT::ct = 0; templatevoid counts(){ cout<<"template size: "<)<<";";cout<<"template counts():"<::ct<}templatevoid report(T & hf){ cout<}int main(){ counts();HasFriendT hfi1(10);HasFriendT hfi2(20);HasFriendT hfdb(10.5);report(hfi1);report(hfi2);report(hfdb);cout<<"counts output:n";counts();cout<<"counts() output:n";counts();cin.get();} //template size: 4;template counts():0//10//20//10.5//counts output://template size: 4;template counts():2//counts() output://template size: 8;template counts():1复制代码counts 和couts 报告的模板大小不同,这样每种T类型都有自己的友元函数count(); 非约束模板友元 友元的所有具体化都是类的每一个具体化的友元 上边说的约束模板友元函数是在类外面声明的模板的具体化。int类型具体化获得int函数具体化, 依此类推。通过在类内部声明模板,可以创建非约束友元函数,即每个函数具体化都是每个类具体化的友元。 对于非约束友元,友元模板类型参数与模板类类型参数是不同的: template {   template   friend void Show2(C &,D &) } 上边是一个使用非约束友元函数的例子,其中,函数调用show2(hfi1,hfi2)与下面的具体化匹配: void Show2 &,ManyFriend &>(ManyFriend & c,ManyFriend & d); 因为它是所有ManyFriend 具体化的友元,所以能够访问所有具体化的item成员,但它只访问了ManyFriend对象。 同样Show2(hfd,hfd2)与下面具体化匹配: void Show2(ManyFirend &,ManyFirend &>(ManyFirend & c,ManyFirend & d); 它也是所有ManyFriend具体化的友元,并访问了ManyFirend 对象的item成员和ManyFriend对象的item成员 复制代码 includeusing std::count;using std::cout;using std::endl; templateclass ManyFriend{private: T item;public: ManyFriend(const T & i):item(i){};templatefriend void Show2(C &,D &);}; templatevoid Show2(C & c,D & d){ cout<} int main(){ ManyFriend hfi1(10);ManyFriend hfi2(20);ManyFriend hfdb(10.5); cout<<"hfi1, hfi2";Show2(hfi1,hfi2);cout<<"hfdb,hfi2: "; Show2(hfdb,hfi2);std::cin.get();} //hfi1, hfi210,20//hfdb,hfi2: 10.5,20

xumaojun 2019-12-02 01:58:41 0 浏览量 回答数 0

回答

phpinfo(), 不是php_info()######不知道你之前的php_info()是如何显示的###### 引用来自“$_$”的答案 phpinfo(), 不是php_info() 玩晕了,是phpinfo(),我写错了。 ###### 引用来自“流风回雪”的答案 不知道你之前的php_info()是如何显示的 是我写错了,玩晕了,习惯加个下划线了。 ###### 如果一定要用php_info(), 可以做自定义函数 function php_info() { phpinfo(); } ###### ###### ###### ###### 引用来自“Jerry524”的答案 如果一定要用php_info(), 可以做自定义函数 function php_info() { phpinfo(); } thank u

montos 2020-05-29 23:38:44 0 浏览量 回答数 0

回答

phpinfo(), 不是php_info()######不知道你之前的php_info()是如何显示的###### 引用来自“$_$”的答案 phpinfo(), 不是php_info() 玩晕了,是phpinfo(),我写错了。 ###### 引用来自“流风回雪”的答案 不知道你之前的php_info()是如何显示的 是我写错了,玩晕了,习惯加个下划线了。 ###### 如果一定要用php_info(), 可以做自定义函数 function php_info() { phpinfo(); } ###### ###### ###### ###### 引用来自“Jerry524”的答案 如果一定要用php_info(), 可以做自定义函数 function php_info() { phpinfo(); } thank u

kun坤 2020-06-05 23:43:45 0 浏览量 回答数 0

回答

file_operation是Linux内核驱动中一个非常重要的结构体,它建立了用户空间与内核空间之间的联系。file_operation结构体定义在linux内核的includelinuxfs.h文件中,定义是这样的:struct module owner; loff_t (*llseek) (struct file *, loff_t, int); ssize_t (*read) (struct file *, char __user *, size_t, loff_t *); ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *); ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t); ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t); int (*readdir) (struct file *, void *, filldir_t); unsigned int (*poll) (struct file *, struct poll_table_struct *); / remove by cym 20130408 support for MT660.ko / #if 0 //#ifdef CONFIG_SMM6260_MODEM #if 1// liang, Pixtree also need to use ioctl interface... int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long); #endif #endif / end remove / long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long); long (*compat_ioctl) (struct file *, unsigned int, unsigned long); int (*mmap) (struct file *, struct vm_area_struct *); int (*open) (struct inode *, struct file *); int (*flush) (struct file *, fl_owner_t id); int (*release) (struct inode *, struct file *); int (*fsync) (struct file *, int datasync); int (*aio_fsync) (struct kiocb *, int datasync); int (*fasync) (int, struct file *, int); int (*lock) (struct file *, int, struct file_lock *); ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int); unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long); int (*check_flags)(int); int (*flock) (struct file *, int, struct file_lock *); ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int); ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int); int (*setlease)(struct file *, long, struct file_lock *); long (*fallocate)(struct file file, int mode, loff_t offset, loff_t len); / add by cym 20130408 support for MT6260 and Pixtree / #if defined(CONFIG_SMM6260_MODEM) || defined(CONFIG_USE_GPIO_AS_I2C) int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long); #endif / end add */ }; 由定义可以看出,该结构体里面定义了许多的函数指针,例如我们在写驱动程序时经常会用到的open、ioctl、read、write等。同时也指明了函数指针里面的参数,这也是为什么我们在写Linux驱动程序的open等函数时,里面的参数都是固定的,不能自己额外添加。当我们在驱动程序中完成open、close等函数之后,就必须在file_operation里面进行映射,使file_operation里面的函数指针一一对应你自己编写的open、colse等方法。这样我们在用户空间中就可以通过调用close、open等函数来调用Linux内核你自己编写的驱动程序啦,不过要成功调用这些函数,你还必须include<fcntl.h>头文件,关于这部分的内容,你可以详细阅读linux的VFS,里面会有详细介绍哦。 可以参考《Linux设备驱动开发详解_宋宝华》这本书里面的 struct file _ operations { struct module owner; // 拥有该结构的模块的指针,一般为 THIS _ MODULES loff _ t(*llseek)(struct file *, loff _ t, int); // 用来修改文件当前的读写位置 ssize _ t(*read)(struct file *, char _ _ user *, size _ t, loff _ t); // 从设备中同步读取数据 ssize _ t(*aio _ read)(struct kiocb , char _ _ user *, size _ t, loff _ t); // 初始化一个异步的读取操作 ssize _ t(*write)(struct file *, const char _ _ user *, size _ t, loff _ t); // 向设备发送数据 ssize _ t(*aio _ write)(struct kiocb , const char _ _ user *, size _ t, loff _ t); // 初始化一个异步的写入操作 int(*readdir)(struct file *, void *, filldir _ t); // 仅用于读取目录,对于设备文件,该字段为 NULL unsigned int(*poll)(struct file *, struct poll _ table _ struct); // 轮询函数,判断目前是否可以进行非阻塞的读取或写入 int(*ioctl)(struct inode , struct file *, unsigned int, unsigned long); // 执行设备 I/O 控制命令 long(*unlocked _ ioctl)(struct file *, unsigned int, unsigned long); // 不使用 BLK 文件系统,将使用此种函数指针代替 ioctl long(*compat _ ioctl)(struct file *, unsigned int, unsigned long); // 在 64 位系统上,32 位的 ioctl 调用将使用此函数指针代替 int(*mmap)(struct file *, struct vm _ area _ struct); // 用于请求将设备内存映射到进程地址空间 int(*open)(struct inode , struct file); // 打开 int(*flush)(struct file*); int(*release)(struct inode , struct file); // 关闭 int(*synch)(struct file , struct dentry *, int datasync); // 刷新待处理的数据 int(*aio _ fsync)(struct kiocb *, int datasync); // 异步 fsync int(*fasync)(int, struct file *, int); // 通知设备 FASYNC 标志发生变化 int(*lock)(struct file *, int, struct file _ lock); ssize _ t(*readv)(struct file , const struct iovec *, unsigned long, loff _ t); ssize _ t(*writev)(struct file , const struct iovec *, unsigned long, loff _ t); // readv 和 writev:分散/聚集型的读写操作 ssize _ t(*sendfile)(struct file , loff _ t *, size _ t, read _ actor _ t, void); // 通常为 NULL ssize _ t(*sendpage)(struct file , struct page *, int, size _ t, loff _ t *, int); // 通常为 NULL unsigned long(*get _ unmapped _ area)(struct file *,unsigned long, unsigned long, unsigned long, unsigned long); // 在进程地址空间找到一个将底层设备中的内存段映射的位置 int(*check _ flags)(int); // 允许模块检查传递给 fcntl(F _ SETEL...)调用的标志 int(*dir _ notify)(struct file *filp, unsigned long arg); // 仅对文件系统有效,驱动程序不必实现 int(*flock)(struct file *, int, struct file _ lock); };

杨冬芳 2019-12-02 03:08:15 0 浏览量 回答数 0

回答

php规定以两个下划线(__)开头的方法都保留为魔术方法,所以建议大家函数名最好不用__开头,除非是为了重载已有的魔术方法。 __construct() 实例化类时自动调用。 __destruct() 类对象使用结束时自动调用。 __set() 在给未定义的属性赋值的时候调用。 __get() 调用未定义的属性时候调用。 __isset() 使用isset()或empty()函数时候会调用。 __unset() 使用unset()时候会调用。 __sleep() 使用serialize序列化时候调用。 __wakeup() 使用unserialize反序列化的时候调用。 __call() 调用一个不存在的方法的时候调用。 __callStatic()调用一个不存在的静态方法是调用。 __toString() 把对象转换成字符串的时候会调用。比如 echo。 __invoke() 当尝试把对象当方法调用时调用。 __set_state() 当使用var_export()函数时候调用。接受一个数组参数。 __clone() 当使用clone复制一个对象时候调用。

珍宝珠 2019-12-02 03:16:31 0 浏览量 回答数 0

问题

PhpSDK的搜索如何操作?(20)

轩墨 2019-12-01 20:59:02 1114 浏览量 回答数 0

回答

jQuery 1.8之后就不支持事件的切换,仅用来元素的隐藏与显示。不过,可以通过自己写代码实现。1.通过flag来控制执行执行哪个函数。比如执行fn1时,flag置为true;执行fn2时,flag置为false.2.通过给元素加减class来控制那个函数。和方法1类型。3.代码实现toggle,避免方法1和方法2中添加变量和操作dom,毕竟这两个都需要开销,原理类似于递归调用,代码如下。$('#btn').one('click', function(){ handler1();//第一次已经是click了,所以需要先执行一次handler1 setTimeout(fn1, 200);//防止后面定义的事件被触发。 }); function fn1(){ var obj = $(this); obj.one('click',function(){ handler2(); fn2(obj); }); } function fn2(obj){ obj.one('click',function(){ handler1(); fn1(obj); }); } function handler1(){ console.log('11'); } function handler2(){ console.log('22'); }当然为了使用方便,也可以封装成jQuery插件的模式。 $.fn.toggleEx = function(handler1, handler2){ $(this).one('click', function(){ handler1(); setTimeout(fn1, 200);//防止后面定义的事件被触发。 }); function fn1(){ var obj = $(this); obj.one('click',function(){ handler2(); fn2(obj); }); } function fn2(obj){ obj.one('click',function(){ handler1(); fn1(obj); }); } } //使用方式和之前一样。 $('#btn').toggleEx(function(){ console.log('11'); }, function(){ console.log('22');

小旋风柴进 2019-12-02 02:28:33 0 浏览量 回答数 0

回答

可以直接作用于for循环的对象统称为可迭代对象(Iterable)。 可以被next()函数调用并不断返回下一个值的对象称为迭代器(Iterator)。 所有的Iterable均可以通过内置函数iter()来转变为Iterator。 对迭代器来讲,有一个__next()就够了。在你使用for 和 in 语句时,程序就会自动调用即将被处理的对象的迭代器对象,然后使用它的next__()方法,直到监测到一个StopIteration异常。 Python L = [1,2,3][x**2 for x in L][1, 4, 9]next(L) Traceback (most recent call last): File "", line 1, in TypeError: 'list' object is not an iterator I=iter(L)next(I) 1 next(I) 2 next(I) 3 next(I) Traceback (most recent call last): File "", line 1, in StopIteration123456789101112131415161718 L = [1,2,3][x**2 for x in L] [1, 4, 9] next(L) Traceback (most recent call last): File "", line 1, in TypeError: 'list' object is not an iterator I=iter(L)next(I) 1 next(I) 2 next(I) 3 next(I) Traceback (most recent call last): File "", line 1, in StopIteration上面例子中,列表L可以被for进行循环但是不能被内置函数next()用来查找下一个值,所以L是Iterable。 L通过iter进行包装后设为I,I可以被next()用来查找下一个值,所以I是Iterator。 题外话: 内置函数iter()仅仅是调用了对象的__iter()方法,所以list对象内部一定存在方法iter__()内置函数next()仅仅是调用了对象的__next()方法,所以list对象内部一定不存在方法next__(),但是Itrator中一定存在这个方法。for循环内部事实上就是先调用iter()把Iterable变成Iterator在进行循环迭代的。Python L = [4,5,6]I = L.__iter__()L.__next__() Traceback (most recent call last): File "", line 1, in AttributeError: 'list' object has no attribute '__next__' I.__next__() 4 from collections import Iterator, Iterableisinstance(L, Iterable) True isinstance(L, Iterator) False isinstance(I, Iterable) True isinstance(I, Iterator) True [x**2 for x in I] [25, 36]12345678910111213141516171819 L = [4,5,6]I = L.__iter__()L.__next__() Traceback (most recent call last): File "", line 1, in AttributeError: 'list' object has no attribute '__next__' I.__next__() 4 from collections import Iterator, Iterableisinstance(L, Iterable) True isinstance(L, Iterator) False isinstance(I, Iterable) True isinstance(I, Iterator) True [x**2 for x in I] [25, 36]4.Iterator继承自Iterable,从下面的测试中可以很方便的看到Iterator包含__iter()和next()方法,而Iteratble仅仅包含iter__()。 Python from collections import Iterator, Iterablehelp(Iterator) Help on class Iterator: class Iterator(Iterable) | Method resolution order: | Iterator | Iterable | builtins.object |**注解:从这里可以看出Iterable继承自object, Iterator继承自Iterable。 | Methods defined here: | | __iter__(self) | | __next__(self) | Return the next item from the iterator. When exhausted, raise StopIteration...... help(Iterable) Help on class Iterable: class Iterable(builtins.object) | Methods defined here: | | __iter__(self)......12345678910111213141516171819202122232425 from collections import Iterator, Iterablehelp(Iterator) Help on class Iterator: class Iterator(Iterable) | Method resolution order: | Iterator | Iterable | builtins.object |**注解:从这里可以看出Iterable继承自object, Iterator继承自Iterable。 | Methods defined here: | | __iter__(self) | | __next__(self) | Return the next item from the iterator. When exhausted, raise StopIteration...... help(Iterable) Help on class Iterable: class Iterable(builtins.object) | Methods defined here: | | __iter__(self)...... iterable需要包含有__iter()方法用来返回iterator,而iterator需要包含有next__()方法用来被循环 如果我们自己定义迭代器,只要在类里面定义一个 iter() 函数,用它来返回一个带 next() 方法的对象就够了。 直接上代码 Python class Iterable: def __iter__(self): return Iterator() class Iterator: def __init__(self): self.start=-1 def __next__(self): self.start +=2 if self.start >10: raise StopIteration return self.start I = Iterable()for i in I: print(i) 12345678910111213141516class Iterable: def __iter__(self): return Iterator() class Iterator: def __init__(self): self.start=-1 def __next__(self): self.start +=2 if self.start >10: raise StopIteration return self.start I = Iterable()for i in I: print(i) 上面的代码实现的是找到10以内的奇数,代码中的类名可以随便取,不是一定需要使用我上面提供的类名的。 如果在Iterator的__next__方法中没有实现StopIteration异常,那么则是表示的全部奇数,那么需要在调用的时候设置退出循环的条件。 Python class Iterable: def __iter__(self): return Iterator() class Iterator: def __init__(self): self.start=-1 def __next__(self): self.start +=2 return self.start I = Iterable()for count, i in zip(range(5),I): #也可以用内置函数enumerate来实现计数工作。 print(i) 1234567891011121314class Iterable: def __iter__(self): return Iterator() class Iterator: def __init__(self): self.start=-1 def __next__(self): self.start +=2 return self.start I = Iterable()for count, i in zip(range(5),I): #也可以用内置函数enumerate来实现计数工作。 print(i) 我们通过range来实现打印多少个元素,这里表示打印5个元素,返回结果和上面一致。 当然,我们可以把这两个类合并在一起,这样实现程序的简练。最终版本如下 Python class Iterable: def __iter__(self): return self def __init__(self): self.start=-1 def __next__(self): self.start +=2 if self.start >10: raise StopIteration return self.start I = Iterable()for i in I: print(i) 1234567891011121314class Iterable: def __iter__(self): return self def __init__(self): self.start=-1 def __next__(self): self.start +=2 if self.start >10: raise StopIteration return self.start I = Iterable()for i in I: print(i) 复制迭代器 迭代器是一次性消耗品,使用完了以后就空了,请看。 Python L=[1,2,3]I=iter(L)for i in I: ... print(i, end='-')...1-2-3- next(I) Traceback (most recent call last): File "", line 1, in StopIteration12345678910 L=[1,2,3]I=iter(L)for i in I: ... print(i, end='-')...1-2-3- next(I) Traceback (most recent call last): File "", line 1, in StopIteration当循环以后就殆尽了,再次使用调用时会引发StopIteration异常。 我们想通过直接赋值的形式把迭代器保存起来,可以下次使用。但是通过下面的范例可以看出来,根本不管用。 Python I=iter(L)J=Inext(I) 1 next(J) 2 next(I) 3 next(J) Traceback (most recent call last): File "", line 1, in StopIteration123456789101112 I=iter(L)J=Inext(I) 1 next(J) 2 next(I) 3 next(J) Traceback (most recent call last): File "", line 1, in StopIteration那怎么样才能达到我们要的效果呢? 我们需要使用copy包中的deepcopy了,请看下面: Python import copyI=iter(L)J=copy.deepcopy(I)next(I) 1 next(I) 2 next(J) 1123456789 import copyI=iter(L)J=copy.deepcopy(I)next(I) 1 next(I) 2 next(J) 1补充:迭代器不能向后移动, 不能回到开始。 所以需要做一些特殊的事情才能实现向后移动等功能。 以上代码均在Python 3.4 中测试通过。 日志: 8月13日完成8月14日添加关于Iterator, Iterable的更多解释在题外话的第4点。

xuning715 2019-12-02 01:10:08 0 浏览量 回答数 0

回答

触及 multiple inheritance (MI)(多继承)的时候,C++ 社区就会鲜明地分裂为两个基本的阵营。一个阵营认为如果 single inheritance (SI)(单继承)是有好处的,multiple inheritance(多继承)一定更有好处。另一个阵营认为 single inheritance(单继承)有好处,但是多继承引起的麻烦使它得不偿失。在本文中,我们的主要目的是理解在 MI 问题上的这两种看法。   首要的事情之一是要承认当将 MI 引入设计领域时,就有可能从多于一个的 base class(基类)中继承相同的名字(例如,函数,typedef,等等)。这就为歧义性提供了新的时机。例如: class BorrowableItem { // something a library lets you borrowpublic: void checkOut(); // check the item out from the library ..}; class ElectronicGadget {private: bool checkOut() const; // perform self-test, return whether ... // test succeeds}; class MP3Player: // note MI herepublic BorrowableItem, // (some libraries loan MP3 players)public ElectronicGadget{ ... }; // class definition is unimportant MP3Player mp; mp.checkOut(); // ambiguous! which checkOut?    注意这个例子,即使两个函数中只有一个是可访问的,对 checkOut 的调用也是有歧义的。(checkOut 在 BorrowableItem 中是 public(公有)的,但在 ElectronicGadget 中是 private(私有)的。)这与 C++ 解析 overloaded functions(重载函数)调用的规则是一致的:在看到一个函数的是否可访问之前,C++ 首先确定与调用匹配最好的那个函数。只有在确定了 best-match function(最佳匹配函数)之后,才检查可访问性。这目前的情况下,两个 checkOuts 具有相同的匹配程度,所以就不存在最佳匹配。因此永远也不会检查到 ElectronicGadget::checkOut 的可访问性。   为了消除歧义性,你必须指定哪一个 base class(基类)的函数被调用: mp.BorrowableItem::checkOut(); // ah, that checkOut...   当然,你也可以尝试显式调用 ElectronicGadget::checkOut,但这样做会有一个 "you're trying to call a private member function"(你试图调用一个私有成员函数)错误代替歧义性错误。    multiple inheritance(多继承)仅仅意味着从多于一个的 base class(基类)继承,但是在还有 higher-level base classes(更高层次基类)的 hierarchies(继承体系)中出现 MI 也并不罕见。这会导致有时被称为 "deadly MI diamond"(致命的多继承菱形)的后果。 class File { ... };class InputFile: public File { ... };class OutputFile: public File { ... };class IOFile: public InputFile,public OutputFile{ ... };    在一个“在一个 base class(基类)和一个 derived class(派生类)之间有多于一条路径的 inheritance hierarchy(继承体系)”(就像上面在 File 和 IOFile 之间,有通过 InputFile 和 OutputFile 的两条路径)的任何时候,你都必须面对是否需要为每一条路径复制 base class(基类)中的 data members(数据成员)的问题。例如,假设 File class 有一个 data members(数据成员)fileName。IOFile 中应该有这个 field(字段)的多少个拷贝呢?一方面,它从它的每一个 base classes(基类)继承一个拷贝,这就暗示 IOFile 应该有两个 fileName data members(数据成员)。另一方面,简单的逻辑告诉我们一个 IOFile object(对象)应该仅有一个 file name(文件名),所以通过它的两个 base classes(基类)继承来的 fileName field(字段)不应该被复制。   C++ 在这个争议上没有自己的立场。它恰当地支持两种选项,虽然它的缺省方式是执行复制。如果那不是你想要的,你必须让这个 class(类)带有一个 virtual base class(虚拟基类)的数据(也就是 File)。为了做到这一点,你要让从它直接继承的所有的 classes(类)使用 virtual inheritance(虚拟继承): class File { ... };class InputFile: virtual public File { ... };class OutputFile: virtual public File { ... };class IOFile: public InputFile,public OutputFile{ ... };    标准 C++ 库包含一个和此类似的 MI hierarchy(继承体系),只是那个 classes(类)是 class templates(类模板),名字是 basic_ios,basic_istream,basic_ostream 和 basic_iostream,而不是 File,InputFile,OutputFile 和 IOFile。   从正确行为的观点 看,public inheritance(公有继承)应该总是 virtual(虚拟)的。如果这是唯一的观点,规则就变得简单了:你使用 public inheritance(公有继承)的任何时候,都使用 virtual public inheritance(虚拟公有继承)。唉,正确性不是唯一的视角。避免 inherited fields(继承来的字段)复制需要在编译器的一部分做一些 behind-the-scenes legerdemain(幕后的戏法),而结果是从使用 virtual inheritance(虚拟继承)的 classes(类)创建的 objects(对象)通常比不使用 virtual inheritance(虚拟继承)的要大。访问 virtual base classes(虚拟基类)中的 data members(数据成员)也比那些 non-virtual base classes(非虚拟基类)中的要慢。编译器与编译器之间有一些细节不同,但基本的要点很清楚:virtual inheritance costs(虚拟继承要付出成本)。   它也有一些其它方面的成本。支配 initialization of virtual base classes(虚拟基类初始化)的规则比 non-virtual bases(非虚拟基类)的更加复杂而且更不直观。初始化一个 virtual base(虚拟基)的职责由 hierarchy(继承体系)中 most derived class(层次最低的派生类)承担。这个规则中包括的含义:   (1) 从需要 initialization(初始化)的 virtual bases(虚拟基)派生的 classes(类)必须知道它们的 virtual bases(虚拟基),无论它距离那个 bases(基)有多远;   (2) 当一个新的 derived class(派生类)被加入继承体系时,它必须为它的 virtual bases(虚拟基)(包括直接的和间接的)承担 initialization responsibilities(初始化职责)。    我对于 virtual base classes(虚拟基类)(也就是 virtual inheritance(虚拟继承))的建议很简单。首先,除非必需,否则不要使用 virtual bases(虚拟基)。缺省情况下,使用 non-virtual inheritance(非虚拟继承)。第二,如果你必须使用 virtual base classes(虚拟基类),试着避免在其中放置数据。这样你就不必在意它的 initialization(初始化)(以及它的 turns out(清空),assignment(赋值))规则中的一些怪癖。值得一提的是 Java 和 .NET 中的 Interfaces(接口)不允许包含任何数据,它们在很多方面可以和 C++ 中的 virtual base classes(虚拟基类)相比照。   现在我们使用下面的 C++ Interface class(接口类)(参见《C++箴言:最小化文件之间的编译依赖》)来为 persons(人)建模: class IPerson {public: virtual ~IPerson();  virtual std::string name() const = 0; virtual std::string birthDate() const = 0;};    IPerson 的客户只能使用 IPerson 的 pointers(指针)和 references(引用)进行编程,因为 abstract classes(抽象类)不能被实例化。为了创建能被当作 IPerson objects(对象)使用的 objects(对象),IPerson 的客户使用 factory functions(工厂函数)(再次参见 Item 31)instantiate(实例化)从 IPerson 派生的 concrete classes(具体类): // factory function to create a Person object from a unique database ID;// see Item 18 for why the return type isn't a raw pointerstd::tr1::shared_ptr makePerson(DatabaseID personIdentifier); // function to get a database ID from the userDatabaseID askUserForDatabaseID(); DatabaseID id(askUserForDatabaseID());std::tr1::shared_ptr pp(makePerson(id)); // create an object// supporting the// IPerson interface ... // manipulate *pp via// IPerson's member// functions   但是 makePerson 怎样创建它返回的 pointers(指针)所指向的 objects(对象)呢?显然,必须有一些 makePerson 可以实例化的从 IPerson 派生的 concrete class(具体类)。    假设这个 class(类)叫做 CPerson。作为一个 concrete class(具体类),CPerson 必须提供它从 IPerson 继承来的 pure virtual functions(纯虚拟函数)的 implementations(实现)。它可以从头开始写,但利用包含大多数或全部必需品的现有组件更好一些。例如,假设一个老式的 database-specific class(老式的数据库专用类)PersonInfo 提供了 CPerson 所需要的基本要素: class PersonInfo {public: explicit PersonInfo(DatabaseID pid); virtual ~PersonInfo();  virtual const char * theName() const; virtual const char * theBirthDate() const; ... private: virtual const char * valueDelimOpen() const; // see virtual const char * valueDelimClose() const; // below ...};    你可以看出这是一个老式的 class(类),因为 member functions(成员函数)返回 const char*s 而不是 string objects(对象)。尽管如此,如果鞋子合适,为什么不穿呢?这个 class(类)的 member functions(成员函数)的名字暗示结果很可能会非常合适。   你突然发现 PersonInfo 是设计用来帮助以不同的格式打印 database fields(数据库字段)的,每一个字段的值的开始和结尾通过指定的字符串定界。缺省情况下,字段值开始和结尾定界符是方括号,所以字段值 "Ring-tailed Lemur" 很可能被安排成这种格式: [Ring-tailed Lemur]   根据方括号并非满足 PersonInfo 的全体客户的期望的事实,virtual functions(虚拟函数)valueDelimOpen 和 valueDelimClose 允许 derived classes(派生类)指定它们自己的开始和结尾定界字符串。PersonInfo 的 member functions(成员函数)的 implementations(实现)调用这些 virtual functions(虚拟函数)在它们返回的值上加上适当的定界符。作为一个例子使用 PersonInfo::theName,代码如下: const char * PersonInfo::valueDelimOpen() const{ return "["; // default opening delimiter} const char * PersonInfo::valueDelimClose() const{ return "]"; // default closing delimiter} const char * PersonInfo::theName() const{ // reserve buffer for return value; because this is // static, it's automatically initialized to all zeros static char value[Max_Formatted_Field_Value_Length];  // write opening delimiter std::strcpy(value, valueDelimOpen());  append to the string in value this object's name field (being careful to avoid buffer overruns!)  // write closing delimiter std::strcat(value, valueDelimClose());  return value;}    有人可能会质疑 PersonInfo::theName 的陈旧的设计(特别是一个 fixed-size static buffer(固定大小静态缓冲区)的使用,这样的东西发生 overrun(越界)和 threading(线程)问题是比较普遍的——参见《C++箴言:必须返回对象时别返回引用》),但是请把这样的问题放到一边而注意这里:theName 调用 valueDelimOpen 生成它要返回的 string(字符串)的开始定界符,然后它生成名字值本身,然后它调用 valueDelimClose。   因为 valueDelimOpen 和 valueDelimClose 是 virtual functions(虚拟函数),theName 返回的结果不仅依赖于 PersonInfo,也依赖于从 PersonInfo 派生的 classes(类)。    对于 CPerson 的实现者,这是好消息,因为当细读 IPerson documentation(文档)中的 fine print(晦涩的条文)时,你发现 name 和 birthDate 需要返回未经修饰的值,也就是,不允许有定界符。换句话说,如果一个人的名字叫 Homer,对那个人的 name 函数的一次调用应该返回 "Homer",而不是 "[Homer]"。   CPerson 和 PersonInfo 之间的关系是 PersonInfo 碰巧有一些函数使得 CPerson 更容易实现。这就是全部。因而它们的关系就是 is-implemented-in-terms-of,而我们知道有两种方法可以表现这一点:经由 composition(复合)(参见《C++箴言:通过composition模拟“has-a”》)和经由 private inheritance(私有继承)(参见《C++箴言:谨慎使用私有继承》)。《C++箴言:谨慎使用私有继承》 指出 composition(复合)是通常的首选方法,但如果 virtual functions(虚拟函数)要被重定义,inheritance(继承)就是必不可少的。在当前情况下,CPerson 需要重定义 valueDelimOpen 和 valueDelimClose,所以简单的 composition(复合)做不到。最直截了当的解决方案是让 CPerson 从 PersonInfo privately inherit(私有继承),虽然 《C++箴言:谨慎使用私有继承》 说过只要多做一点工作,则 CPerson 也能用 composition(复合)和 inheritance(继承)的组合有效地重定义 PersonInfo 的 virtuals(虚拟函数)。这里,我们用 private inheritance(私有继承)。   但 是 CPerson 还必须实现 IPerson interface(接口),而这被称为 public inheritance(公有继承)。这就引出一个 multiple inheritance(多继承)的合理应用:组合 public inheritance of an interface(一个接口的公有继承)和 private inheritance of an implementation(一个实现的私有继承): class IPerson { // this class specifies thepublic: // interface to be implemented virtual ~IPerson();  virtual std::string name() const = 0; virtual std::string birthDate() const = 0;}; class DatabaseID { ... }; // used below; details are// unimportant class PersonInfo { // this class has functionspublic: // useful in implementing explicit PersonInfo(DatabaseID pid); // the IPerson interface virtual ~PersonInfo();  virtual const char * theName() const; virtual const char * theBirthDate() const;  virtual const char * valueDelimOpen() const; virtual const char * valueDelimClose() const; ...}; class CPerson: public IPerson, private PersonInfo { // note use of MIpublic: explicit CPerson( DatabaseID pid): PersonInfo(pid) {} virtual std::string name() const // implementations { return PersonInfo::theName(); } // of the required // IPerson member virtual std::string birthDate() const // functions { return PersonInfo::theBirthDate(); }private: // redefinitions of const char * valueDelimOpen() const { return ""; } // inherited virtual const char * valueDelimClose() const { return ""; } // delimiter}; // functions   在 UML 中,这个设计看起来像这样:   这个例子证明 MI 既是有用的,也是可理解的。    时至今日,multiple inheritance(多继承)不过是 object-oriented toolbox(面向对象工具箱)里的又一种工具而已,典型情况下,它的使用和理解更加复杂,所以如果你得到一个或多或少等同于一个 MI 设计的 SI 设计,则 SI 设计总是更加可取。如果你能拿出来的仅有的设计包含 MI,你应该更加用心地考虑一下——总会有一些方法使得 SI 也能做到。但同时,MI 有时是最清晰的,最易于维护的,最合理的完成工作的方法。在这种情况下,毫不畏惧地使用它。只是要确保谨慎地使用它。   Things to Remember   ·multiple inheritance(多继承)比 single inheritance(单继承)更复杂。它能导致新的歧义问题和对 virtual inheritance(虚拟继承)的需要。    ·virtual inheritance(虚拟继承)增加了 size(大小)和 speed(速度)成本,以及 initialization(初始化)和 assignment(赋值)的复杂度。当 virtual base classes(虚拟基类)没有数据时它是最适用的。   ·multiple inheritance(多继承)有合理的用途。一种方案涉及组合从一个 Interface class(接口类)的 public inheritance(公有继承)和从一个有助于实现的 class(类)的 private inheritance(私有继承)。 关于虚拟继承的思考虚拟继承在一般的应用中很少用到,所以也往往被忽视,这也主要是因为在C++中,多重继承是不推荐的,而一旦离开了多重继承,虚拟继承就完全失去了存在的必要(因为这样只会降低效率和占用更多的空间,实在是一无是处)。  以下面的一个例子为例:  #include   #include   class CA  {   int k; //为了便于说明后面的内存结构特别添加  public:   void f() {cout << "CA::f" << endl;}  };  class CB : public CA  {  };  class CC : public CA  {  };  class CD : public CB, public CC  {  };  void main()  {   CD d;   d.f();  }  当编译上述代码时,我们会收到如下的错误提示:  error C2385: 'CD::f' is ambiguous  即编译器无法确定你在d.f()中要调用的函数f到底是哪一个。这里可能会让人觉得有些奇怪,命名只定义了一个CA::f,既然大家都派生自CA,那自然就是调用的CA::f,为什么还无法确定呢?  这是因为编译器在进行编译的时候,需要确定子类的函数定义,如CA::f是确定的,那么在编译CB、CC时还需要在编译器的语法树中生成CB::f,CC::f等标识,那么,在编译CD的时候,由于CB、CC都有一个函数f,此时,编译器将试图生成两个CD::f标识,显然这时就要报错了。(当我们不使用CD::f的时候,以上标识都不会生成,所以,如果去掉d.f()一句,程序将顺利通过编译)  要解决这个问题,有两个方法:  1、重载函数f():此时由于我们明确定义了CD::f,编译器检查到CD::f()调用时就无需再像上面一样去逐级生成CD::f标识了;  此时CD的元素结构如下:  --------  |CB(CA)|  |CC(CA)|  --------  故此时的sizeof(CD) = 8;(CB、CC各有一个元素k)  2、使用虚拟继承:虚拟继承又称作共享继承,这种共享其实也是编译期间实现的,当使用虚拟继承时,上面的程序将变成下面的形式:  #include   #include   class CA  {   int k;  public:   void f() {cout << "CA::f" << endl;}  };  class CB : virtual public CA  {  };  class CC : virtual public CA  {  };  class CD : public CB, public CC  {  };  void main()  {   CD d;   d.f();  }  此时,当编译器确定d.f()调用的具体含义时,将生成如下的CD结构:  ----  |CB|  |CC|  |CA|  ----  同时,在CB、CC中都分别包含了一个指向CA的vbptr(virtual base table pointer),其中记录的是从CB、CC的元素到CA的元素之间的偏移量。此时,不会生成各子类的函数f标识,除非子类重载了该函数,从而达到“共享”的目的。  也正因此,此时的sizeof(CD) = 12(两个vbptr + sizoef(int));

a123456678 2019-12-02 01:58:07 0 浏览量 回答数 0

回答

phpinfo(), 不是php_info()######不知道你之前的php_info()是如何显示的######<div class=""ref""> 引用来自“$_$”的答案 phpinfo(), 不是php_info() 玩晕了,是phpinfo(),我写错了。 ###### 引用来自“流风回雪”的答案 不知道你之前的php_info()是如何显示的 是我写错了,玩晕了,习惯加个下划线了。 ###### 如果一定要用php_info(), 可以做自定义函数 function php_info() { phpinfo(); } ###### ###### ###### ###### 引用来自“Jerry524”的答案 如果一定要用php_info(), 可以做自定义函数 function php_info() { phpinfo(); }

kun坤 2020-05-26 21:18:11 0 浏览量 回答数 0

回答

从https://docs.oracle.com/javase/tutorial/java/IandI/super.html检查以下几行 注意:如果构造函数未明确调用超类构造函数,则Java编译器会自动将调用插入到超类的无参数构造函数中。如果超类没有无参数构造函数,则将出现编译时错误。对象确实具有这样的构造函数,因此如果对象是唯一的超类,就没有问题。 如果子类构造函数显式或隐式调用其超类的构造函数,则您可能会认为将调用整个构造函数链,一直返回到Object的构造函数。实际上就是这种情况。这称为构造函数链接,当类下降很长时,您需要意识到这一点。 希望能消除您的疑虑。 [更新] 发布此更新可以消除OP在下面的评论中提到的疑虑。 以下代码将不会编译,因为A()尚未定义隐式超级构造函数,我们也未明确定义它。注意,A()当没有其他带参数的构造函数被定义时,隐式的超级构造函数会自动定义。 class A { int i; A(int x,int y){ } } class B extends A { int i; B(int a, int b) { super.i = a; i = b; } void show() { System.out.println(super.i); System.out.println(i); } } public class UseSuper { public static void main(String[] args) { B b = new B(1, 2); b.show(); } } [另一个更新] 发布此更新以清除OP在他的以下评论中提到的另一个疑问。 以下代码也不会编译,因为A()已将超级构造函数声明为private阻止子类构造函数调用它。 class A { int i; private A() { System.out.println("A's constructor"); } } class B extends A { int i; B(int a, int b) { super.i = a; i = b; } void show() { System.out.println(super.i); System.out.println(i); } } class UseSuper { public static void main(String[] args) { B b = new B(1, 2); b.show(); } } 回答来源:Stack Overflow

montos 2020-03-26 11:14:38 0 浏览量 回答数 0

问题

php自定义框架类文件载入的疑问,报错

一枚小鲜肉帅哥 2020-06-20 21:14:48 0 浏览量 回答数 1

回答

"phpinfo(), 不是php_info()######不知道你之前的php_info()是如何显示的######<div class=""ref""> 引用来自“$_$”的答案 phpinfo(), 不是php_info() 玩晕了,是phpinfo(),我写错了。 ###### 引用来自“流风回雪”的答案 不知道你之前的php_info()是如何显示的 是我写错了,玩晕了,习惯加个下划线了。 ###### 如果一定要用php_info(), 可以做自定义函数 function php_info() { phpinfo(); } ###### ###### ###### ###### 引用来自“Jerry524”的答案 如果一定要用php_info(), 可以做自定义函数 function php_info() { phpinfo(); } thank u "

一枚小鲜肉帅哥 2020-05-27 14:03:00 0 浏览量 回答数 0

回答

  1 、递归函数的定义:   答:递归函数即自调用函数,在函数体内直接或间接的调用自己,即函数的嵌套是函数本身。   2 、递归方式:递归调用有直接递归和间接递归两种方式。   A :直接递归:在函数中出现调用函数本身。   示例 1 :下面代码求斐波那契数列第 n 项,斐波那契数列第一和第二项是 1 ,后面每一项是前两项之和,即 1 、 1 、 2 、 3 、 5 、 8 、 13  ...。   程序代码:   public class Test {   public static void main(String args[]) {   int x1 = 1;   int sum = 0;   int n = 7;   for (int i = 1; i <= n; i++) {   x1 = func(i);   sum = sum + x1;   }   System.out.println("sum=" + sum);   }   public static int func(int x) {   if (x >2)   return (func(x - 1) + func(x - 2));   else   return 1;   }   }   B :间接递归:指函数中调用了其他函数,而该其他函数有调用了本函数。   示例 2 :用间接递归来计算上述斐波那契数列。   3 、为什么要用递归函数。递归函数的缺点是什么。   答:递归的目的是简化程序设计,使程序易读。   示例 3 :下面不用递归函数继续来计算上述斐波那契数列。   程序代码:   public class Test {   public static void main(String args[]) {   int n=7;   int a=1, b=1, temp;   int sum=2;   for(int i=3; i<=n; i++){   temp=a+b; a=b; b=temp;   sum=sum+temp;   }   System.out.println("sum=" + sum);   }   }   从上面例子我们可以发现虽然非递归函数效率高,但较难编程,可读性较差。递归函数的缺点是增加了系统开销,也就是说,每递归一次,栈内存就多占用一截。   4 、递归的条件:   答:需有完成任务的语句,需满足递归的要求(减小而不是发散)。   5 、递归进阶:   示例 4 :   编程求解:若一头小母牛,从出生起第四个年头开始每年生一头母牛,按次规律,第 n 年时有多少头母牛。   程序代码:   public class Test3 {   public static void main(String args[]) {   int n=10; // 要查看的年数   System.out.println(" 共有 "+cattle(n)+" 头小母牛! ");   }   public static int cattle(int n){   if(n<=0)   return 0;   if(n<=3)   return 1;   return cattle(n-1)+ cattle(n-3);// 此处是递归要好好理解。   }   }   规律:此类问题的递归函数为:   如果要求的是从出生起第四个年头,则递归函数为 cattle(n-1)+ cattle(n-3) ,   如果要求的是从出生起第五个年头,则递归函数为 cattle(n-1)+ cattle(n-4) ,   。。。。   依次类推。   (原代码全部在 JBuilderX 下调试通过)   

行者武松 2019-12-02 01:25:22 0 浏览量 回答数 0
阿里云大学 云服务器ECS com域名 网站域名whois查询 开发者平台 小程序定制 小程序开发 国内短信套餐包 开发者技术与产品 云数据库 图像识别 开发者问答 阿里云建站 阿里云备案 云市场 万网 阿里云帮助文档 免费套餐 开发者工具 企业信息查询 小程序开发制作 视频内容分析 企业网站制作 视频集锦 代理记账服务 2020阿里巴巴研发效能峰会 企业建站模板 云效成长地图 高端建站 阿里云双十一主会场 阿里云双十一新人会场 1024程序员加油包 阿里云双十一拼团会场 场景化解决方案 阿里云双十一直播大厅