精华内容
下载资源
问答
  • “Python有什么好学的”这话可不是反问,而是问哦。主要煎鱼觉得太多的人觉得Python的语法较为简单,写出来的代码只要符合逻辑,不需要太多的学习即可,即可从一门其他语言跳来用Python写(当然这样好事,...

    “Python有什么好学的”这句话可不是反问句,而是问句哦。

    主要是煎鱼觉得太多的人觉得Python的语法较为简单,写出来的代码只要符合逻辑,不需要太多的学习即可,即可从一门其他语言跳来用Python写(当然这样是好事,谁都希望入门简单)。

    于是我便记录一下,如果要学Python的话,到底有什么好学的。记录一下Python有什么值得学的,对比其他语言有什么特别的地方,有什么样的代码写出来更Pythonic。一路回味,一路学习。

    什么是修饰器,为什么叫修饰器

    修饰器英文是Decorator,

    我们假设这样一种场景:古老的代码中有几个很是复杂的函数F1、F2、F3...,复杂到看都不想看,反正我们就是不想改这些函数,但是我们需要改造加功能,在这个函数的前后加功能,这个时候我们很容易就实现这个需求:

    def hi():

    """hi func,假装是很复杂的函数"""

    return 'hi'

    def aop(func):

    """aop func"""

    print('before func')

    print(func())

    print('after func')

    if __name__ == '__main__':

    aop(hi)

    以上是很是简单的实现,利用Python参数可以传函数引用的特性,就可以实现了这种类似AOP的效果。

    这段代码目前没有什么问题,接下来煎鱼加需求:需求为几十个函数都加上这样的前后的功能,而所有调用这些函数地方也要相应地升级。

    看起来这个需求比较扯,偏偏这个需求却是较为广泛:在调用函数的前后加上log输出、在调用函数的前后计算调用时间、在调用函数的前后占用和释放资源等等。

    一种比较笨的方法就是,为这几十个函数逐一添加一个入口函数,针对a函数添加一个a_aop函数,针对b函数添加一个b_aop函数...如此这样。问题也很明显:

    工作量大

    代码变得臃肿复杂

    原代码有多处调用了这些函数,可以会升级不完全

    于是接下来有请修饰器出场,修饰器可以统一地给这些函数加这样的功能:

    def aop(func):

    """aop func"""

    def wrapper():

    """wrapper func"""

    print('before func')

    func()

    print('after func')

    return wrapper

    @aop

    def hi():

    """hi func"""

    print('hi')

    @aop

    def hello():

    """hello func"""

    print('hello')

    if __name__ == '__main__':

    hi()

    hello()

    以上aop函数就是修饰器的函数,使用该修饰器时只要在待加函数上一行加@修饰器函数名即可,如实例代码中就是@aop。

    加上了@aop后,调用新功能的hi函数就喝原来的调用一样:就是hi()而不是aop(hi),也意味着所有调用这些函数的地方不需要修改就可以升级。

    简单地来说,大概修饰器就是以上的这样子。

    @是个什么

    对于新手来说,上面例子中,@就是一样奇怪的东西:为什么这样子用就可以实现煎鱼需求的功能了。

    其实我们还可以不用@,煎鱼换一种写法:

    def hi():

    """hi func"""

    print('hi')

    def aop(func):

    """aop func"""

    def wrapper():

    """wrapper func"""

    print('before func')

    func()

    print('after func')

    return wrapper

    if __name__ == '__main__':

    hi()

    print('')

    hi = aop(hi)

    hi()

    上面的例子中的aop函数就是之前说过的修饰器函数。

    如例子main函数中第一次调用hi函数时,由于hi函数没叫修饰器,因此我们可以从输出结果中看到程序只输出了一个hi而没有前后功能。

    然后煎鱼加了一个hi = aop(hi)后再调用hi函数,得到的输出结果和加修饰器的一样,换言之:

    @aop 等效于hi = aop(hi)

    因此,我们对于@,可以理解是,它通过闭包的方式把新函数的引用赋值给了原来函数的引用。

    有点拗口。aop(hi)是新函数的引用,至于返回了引用的原因是aop函数中运用闭包返回了函数引用。而hi这个函数的引用,本来是指向旧函数的,通过hi = aop(hi)赋值后,就指向新函数了。

    被调函数加参数

    以上的例子中,我们都假设被调函数是无参的,如hi、hello函数都是无参的,我们再看一眼煎鱼刚才的写的修饰器函数:

    def aop(func):

    """aop func"""

    def wrapper():

    """wrapper func"""

    print('before func')

    func()

    print('after func')

    return wrapper

    很明显,闭包函数wrapper中,调用被调函数用的是func(),是无参的。同时就意味着,如果func是一个带参数的函数,再用这个修饰器就会报错。

    @aop

    def hi_with_deco(a):

    """hi func"""

    print('hi' + str(a))

    if __name__ == '__main__':

    # hi()

    hi_with_deco(1)

    就是参数的问题。这个时候,我们把修饰器函数改得通用一点即可,其中import了一个函数(也是修饰器函数):

    from functools import wraps

    def aop(func):

    """aop func"""

    @wraps(func)

    def wrap(*args, **kwargs):

    print('before')

    func(*args, **kwargs)

    print('after')

    return wrap

    @aop

    def hi(a, b, c):

    """hi func"""

    print('test hi: %s, %s, %s' % (a, b, c))

    @aop

    def hello(a, b):

    """hello func"""

    print('test hello: %s, %s' % (a, b))

    if __name__ == '__main__':

    hi(1, 2, 3)

    hello('a', 'b')

    这是一种很奇妙的东西,就是在写修饰器函数的时候,还用了别的修饰器函数。那也没什么,毕竟修饰器函数也是函数啊,有什么所谓。

    带参数的修饰器

    思路到了这里,煎鱼不禁思考一个问题:修饰器函数也是函数,那函数也是应该能传参的。函数传参的话,不同的参数可以输出不同的结果,那么,修饰器函数传参的话,不同的参数会怎么样呢?

    其实很简单,修饰器函数不同的参数,能生成不同的修饰器啊。

    如,我这次用这个修饰器是把时间日志打到test.log,而下次用修饰器的时候煎鱼希望是能打到test2.log。这样的需求,除了写两个修饰器函数外,还可以给修饰器加参数选项:

    from functools import wraps

    def aop_with_param(aop_test_str):

    def aop(func):

    """aop func"""

    @wraps(func)

    def wrap(*args, **kwargs):

    print('before ' + str(aop_test_str))

    func(*args, **kwargs)

    print('after ' + str(aop_test_str))

    return wrap

    return aop

    @aop_with_param('abc')

    def hi(a, b, c):

    """hi func"""

    print('test hi: %s, %s, %s' % (a, b, c))

    @aop_with_param('pppppp')

    def hi2(a, b, c):

    """hi func"""

    print('test hi: %s, %s, %s' % (a, b, c))

    if __name__ == '__main__':

    hi(1, 2, 3)

    print('')

    hi2(2, 3, 4)

    同样的,可以加一个参数,也可以加多个参数,这里就不说了。

    修饰器类

    大道同归,逻辑复杂了之后,人们都喜欢将函数的思维层面抽象上升到对象的层面。原因往往是对象能拥有多个函数,对象往往能管理更复杂的业务逻辑。

    显然,修饰器函数也有对应的修饰器类。写起来也没什么难度,和之前的生成器一样简单:

    from functools import wraps

    class aop(object):

    def __init__(self, aop_test_str):

    self.aop_test_str = aop_test_str

    def __call__(self, func):

    @wraps(func)

    def wrapper(*args, **kwargs):

    print('before ' + self.aop_test_str)

    func()

    print('after ' + self.aop_test_str)

    return wrapper

    @aop('pppppp')

    def hi():

    print('hi')

    看得出来,这个修饰器类也不过是多了个__call__函数,而这个__call__函数的内容和之前写的修饰器函数一个样!而使用这个修饰器的方法,和之前也一样,一样的如例子中的@aop('pppppp')。

    甚至,煎鱼过于无聊,还试了一下继承的修饰器类:

    class sub_aop(aop):

    def __init__(self, sub_aop_str, *args, **kwargs):

    self.sub_aop_str = sub_aop_str

    super(sub_aop, self).__init__(*args, **kwargs)

    def __call__(self, func):

    @wraps(func)

    def wrapper(*args, **kwargs):

    print('before ' + self.sub_aop_str)

    super(sub_aop, self).__call__(func)()

    print('after ' + self.sub_aop_str)

    return wrapper

    @sub_aop('ssssss', 'pppppp')

    def hello():

    print('hello')

    if __name__ == '__main__':

    hello()

    你们猜猜结果怎么样?

    先这样吧

    若有错误之处请指出,更多地请关注造壳。

    展开全文
  • 探究的问题如题 文章涉及到NSString的三种创建方式 ...如果_teststrong修饰,那么这实现的就是str2指向的对象的引用计数加一。 而如果copy self.test2 = str2; 这话就等价于 _test2 = [str2 copy];

    写在前面

    test = str2
    以此为例,文中出现的赋值对象指str2, 被赋值对象指test。

    strong和copy的区别

    区别在与strong属性关键字实现原理是赋值的对象的引用计数加一

    _test = str2;

    如果_test是strong修饰,那么这句实现的就是str2指向的对象的引用计数加一。
    而如果是copy

    self.test2 = str2;

    这句话就等价于

    _test2 = [str2 copy];

    copy分为深浅复制,深复制是内容复制(新开辟一块内存地址,并复制原来的值), 浅复制是地址复制(不开辟新的地址,只是让_test2的指针指向str2指向的地址),这里不再细说。

    对于不可变对象,strong和copy的区别

    (只有不可变对象的不可变复制是浅复制,其余都是深复制)
    strong对赋值对象没什么区别,都是把指针指向赋值对象所指的地址,所以区别在与copy。
    copy对于不同的赋值对象有不同的实现方式(深浅复制),对于不可变对象都是浅复制,但是对于可变对象是深复制。所以当赋值对象是不可变对象时没什么区别,但如果是可变对象,copy方法是深复制,就与strong不同了。

    测试

    @property (nonatomic, strong)NSString *test1;
    @property (nonatomic,copy)NSString *test2;

    这是两个变量,test1是strong修饰的不可变字符串,test2是copy修饰的不可变字符串。
    定义一个可变字符串

     NSMutableString *pyr = [[NSMutableString alloc] initWithString:@"123"];
    
    • strong修饰的做以下赋值

    self.test1 = pyr

    强应用使test1指向pyr指向的对象地址。

    • copy修饰的做以下赋值

    self.test2 = pyr

    copy修饰,可变对象的复制是深复制,所以重新开辟了地址,复制了pyr所指向的对象,然后赋值给新开辟的地址上。

    tips

    我刚开始对于copy修饰的写的是

    _test2 = pyr;

    按理说是不可变对象的复制是深复制,_test2的地址应该和pyr的地址不一样才是,但几次测试都是一样的,是因为属性关键字是对属性而言的,属性的定义就是生成了set和get方法并生成一个成员变量,而调用_test2就是调用这个成员变量,点语法是会走set和get方法,成员变量不会。(他们说ARC属性关键字的实现是把实现代码动态添加在set方法中),所以copy没有实现。

    展开全文
  • public class InnerClassDemo { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated ... //如果成员内部类没有被static修饰,那么换话来说,它就是外部类的成员,就
    package com.itheima;
    
    public class InnerClassDemo {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		//如果成员内部类没有被static修饰,那么换句话来说,它就是外部类的成员,就是属于类级别,
    		//所以在访问它的时候,就必须创建一个外部类的引用。new InnerClass().new MemberClass();
    		InnerClass.MemberClass ms = new InnerClass.MemberClass("MemberClass");
    		ms.showName();
    		
    		/*
    		 * 内部类对象的生命周期会超过局部变量的生命期。
    		 * 局部变量的生命期:当该方法被调用时,该方法中的局部变量在栈中被创建,当方法调用结束时,退栈,这些局部变量全部死亡。
    		 * 而内部类对象生命期,与其它类一样,当创建一个局部内部类对象后,只有当没有其它人再引用它时,它才能死亡。
    		 * 所以完全可能一个方法已调用结束(局部变量已死亡),但该局部类的对象仍然活着。即:局部类的对象生命期会超过局部变量。
    		 * 方法内部类只能在定义该内部类的方法内实例化,不可以在此方法外对其实例化。此处用父类的对象访问方法。
    		 */
    		InnerClass inner = new InnerClass("InnerClass");
    		inner.showHelp();
    		
    	}
    }
    
    class InnerClass{
    	private String className;
    	public InnerClass(String className){
    		this.className = className;
    	}
    	
    	public String getClassName() {
    		return className;
    	}
    
    	public void setClassName(String className) {
    		this.className = className;
    	}
    
    	public void showName(){
    		System.out.println(this.className);
    	}
    	
    	/**
    	 * create innner class
    	 */
    	 public static class MemberClass{
    		private String className;
    		public MemberClass(String name){
    			this.className = name;
    		}
    		public void showName(){
    			System.out.println(this.className);
    		}
    	}
    	
    	public void showHelp(){
    		  class PartClass{
    			int age;
    			public void showLocation(){
    				System.out.println("局部内部类" + this.age + InnerClass.this.className);
    			}
    		}
    		  new PartClass().showLocation();
    	}
    }
    

    展开全文
  • “Python有什么好学的”这话可不是反问,而是问哦。主要煎鱼觉得太多的人觉得Python的语法较为简单,写出来的代码只要符合逻辑,不需要太多的学习即可,即可从一门其他语言跳来用Python写(当然这样好事,...

    “Python有什么好学的”这句话可不是反问句,而是问句哦。

    主要是煎鱼觉得太多的人觉得Python的语法较为简单,写出来的代码只要符合逻辑,不需要太多的学习即可,即可从一门其他语言跳来用Python写(当然这样是好事,谁都希望入门简单)。

    于是我便记录一下,如果要学Python的话,到底有什么好学的。记录一下Python有什么值得学的,对比其他语言有什么特别的地方,有什么样的代码写出来更Pythonic。一路回味,一路学习。

    什么是修饰器,为什么叫修饰器

    修饰器英文是Decorator,

    我们假设这样一种场景:古老的代码中有几个很是复杂的函数F1、F2、F3...,复杂到看都不想看,反正我们就是不想改这些函数,但是我们需要改造加功能,在这个函数的前后加功能,这个时候我们很容易就实现这个需求:

    def hi():

    """hi func,假装是很复杂的函数"""

    return 'hi'

    def aop(func):

    """aop func"""

    print('before func')

    print(func())

    print('after func')

    if __name__ == '__main__':

    aop(hi)

    485d3ecf288845e4f9f83ba3b0dda0bd.png

    以上是很是简单的实现,利用Python参数可以传函数引用的特性,就可以实现了这种类似AOP的效果。

    这段代码目前没有什么问题,接下来煎鱼加需求:需求为几十个函数都加上这样的前后的功能,而所有调用这些函数地方也要相应地升级。

    看起来这个需求比较扯,偏偏这个需求却是较为广泛:在调用函数的前后加上log输出、在调用函数的前后计算调用时间、在调用函数的前后占用和释放资源等等。

    一种比较笨的方法就是,为这几十个函数逐一添加一个入口函数,针对a函数添加一个a_aop函数,针对b函数添加一个b_aop函数...如此这样。问题也很明显:

    工作量大

    代码变得臃肿复杂

    原代码有多处调用了这些函数,可以会升级不完全

    于是接下来有请修饰器出场,修饰器可以统一地给这些函数加这样的功能:

    def aop(func):

    """aop func"""

    def wrapper():

    """wrapper func"""

    print('before func')

    func()

    print('after func')

    return wrapper

    @aop

    def hi():

    """hi func"""

    print('hi')

    @aop

    def hello():

    """hello func"""

    print('hello')

    if __name__ == '__main__':

    hi()

    hello()

    f3787be73f8230f10950fa6e400a43f4.png

    以上aop函数就是修饰器的函数,使用该修饰器时只要在待加函数上一行加@修饰器函数名即可,如实例代码中就是@aop。

    加上了@aop后,调用新功能的hi函数就喝原来的调用一样:就是hi()而不是aop(hi),也意味着所有调用这些函数的地方不需要修改就可以升级。

    简单地来说,大概修饰器就是以上的这样子。

    @是个什么

    对于新手来说,上面例子中,@就是一样奇怪的东西:为什么这样子用就可以实现煎鱼需求的功能了。

    其实我们还可以不用@,煎鱼换一种写法:

    def hi():

    """hi func"""

    print('hi')

    def aop(func):

    """aop func"""

    def wrapper():

    """wrapper func"""

    print('before func')

    func()

    print('after func')

    return wrapper

    if __name__ == '__main__':

    hi()

    print('')

    hi = aop(hi)

    hi()

    7d04364cd0bc09004fa873069a973fa6.png

    上面的例子中的aop函数就是之前说过的修饰器函数。

    如例子main函数中第一次调用hi函数时,由于hi函数没叫修饰器,因此我们可以从输出结果中看到程序只输出了一个hi而没有前后功能。

    然后煎鱼加了一个hi = aop(hi)后再调用hi函数,得到的输出结果和加修饰器的一样,换言之:

    @aop 等效于hi = aop(hi)

    因此,我们对于@,可以理解是,它通过闭包的方式把新函数的引用赋值给了原来函数的引用。

    有点拗口。aop(hi)是新函数的引用,至于返回了引用的原因是aop函数中运用闭包返回了函数引用。而hi这个函数的引用,本来是指向旧函数的,通过hi = aop(hi)赋值后,就指向新函数了。

    被调函数加参数

    以上的例子中,我们都假设被调函数是无参的,如hi、hello函数都是无参的,我们再看一眼煎鱼刚才的写的修饰器函数:

    def aop(func):

    """aop func"""

    def wrapper():

    """wrapper func"""

    print('before func')

    func()

    print('after func')

    return wrapper

    很明显,闭包函数wrapper中,调用被调函数用的是func(),是无参的。同时就意味着,如果func是一个带参数的函数,再用这个修饰器就会报错。

    @aop

    def hi_with_deco(a):

    """hi func"""

    print('hi' + str(a))

    if __name__ == '__main__':

    # hi()

    hi_with_deco(1)

    226dfcc34b6fb7b06ea5937f4c67aac7.png

    就是参数的问题。这个时候,我们把修饰器函数改得通用一点即可,其中import了一个函数(也是修饰器函数):

    from functools import wraps

    def aop(func):

    """aop func"""

    @wraps(func)

    def wrap(*args, **kwargs):

    print('before')

    func(*args, **kwargs)

    print('after')

    return wrap

    @aop

    def hi(a, b, c):

    """hi func"""

    print('test hi: %s, %s, %s' % (a, b, c))

    @aop

    def hello(a, b):

    """hello func"""

    print('test hello: %s, %s' % (a, b))

    if __name__ == '__main__':

    hi(1, 2, 3)

    hello('a', 'b')

    e203b40f5e21f6f1583e3f33d233304a.png

    这是一种很奇妙的东西,就是在写修饰器函数的时候,还用了别的修饰器函数。那也没什么,毕竟修饰器函数也是函数啊,有什么所谓。

    带参数的修饰器

    思路到了这里,煎鱼不禁思考一个问题:修饰器函数也是函数,那函数也是应该能传参的。函数传参的话,不同的参数可以输出不同的结果,那么,修饰器函数传参的话,不同的参数会怎么样呢?

    其实很简单,修饰器函数不同的参数,能生成不同的修饰器啊。

    如,我这次用这个修饰器是把时间日志打到test.log,而下次用修饰器的时候煎鱼希望是能打到test2.log。这样的需求,除了写两个修饰器函数外,还可以给修饰器加参数选项:

    from functools import wraps

    def aop_with_param(aop_test_str):

    def aop(func):

    """aop func"""

    @wraps(func)

    def wrap(*args, **kwargs):

    print('before ' + str(aop_test_str))

    func(*args, **kwargs)

    print('after ' + str(aop_test_str))

    return wrap

    return aop

    @aop_with_param('abc')

    def hi(a, b, c):

    """hi func"""

    print('test hi: %s, %s, %s' % (a, b, c))

    @aop_with_param('pppppp')

    def hi2(a, b, c):

    """hi func"""

    print('test hi: %s, %s, %s' % (a, b, c))

    if __name__ == '__main__':

    hi(1, 2, 3)

    print('')

    hi2(2, 3, 4)

    bf2d207164747fad49e9fe4f6ff7ec2c.png

    同样的,可以加一个参数,也可以加多个参数,这里就不说了。

    修饰器类

    大道同归,逻辑复杂了之后,人们都喜欢将函数的思维层面抽象上升到对象的层面。原因往往是对象能拥有多个函数,对象往往能管理更复杂的业务逻辑。

    显然,修饰器函数也有对应的修饰器类。写起来也没什么难度,和之前的生成器一样简单:

    from functools import wraps

    class aop(object):

    def __init__(self, aop_test_str):

    self.aop_test_str = aop_test_str

    def __call__(self, func):

    @wraps(func)

    def wrapper(*args, **kwargs):

    print('before ' + self.aop_test_str)

    func()

    print('after ' + self.aop_test_str)

    return wrapper

    @aop('pppppp')

    def hi():

    print('hi')

    看得出来,这个修饰器类也不过是多了个__call__函数,而这个__call__函数的内容和之前写的修饰器函数一个样!而使用这个修饰器的方法,和之前也一样,一样的如例子中的@aop('pppppp')。

    甚至,煎鱼过于无聊,还试了一下继承的修饰器类:

    class sub_aop(aop):

    def __init__(self, sub_aop_str, *args, **kwargs):

    self.sub_aop_str = sub_aop_str

    super(sub_aop, self).__init__(*args, **kwargs)

    def __call__(self, func):

    @wraps(func)

    def wrapper(*args, **kwargs):

    print('before ' + self.sub_aop_str)

    super(sub_aop, self).__call__(func)()

    print('after ' + self.sub_aop_str)

    return wrapper

    @sub_aop('ssssss', 'pppppp')

    def hello():

    print('hello')

    if __name__ == '__main__':

    hello()

    你们猜猜结果怎么样?

    先这样吧

    若有错误之处请指出,更多地请关注造壳。

    展开全文
  • Python有什么好学的”这话可不是反问,而是问哦。主要煎鱼觉得太多的人觉得Python的语法较为简单,写出来的代码只要符合逻辑,不需要太多的学习即可,即可从一门其他语言跳来用Python写(当然这样好事,谁...
  • 接口其实相当于更严格的一种公共类: ①接口中的数据对所有实现类只有一份,所以static ②要使实现类为了向上转型成功(即:拿到的属性数据都一样的),...假如代码中有一: A a= null; a = new A1()或A2...
  • “Python有什么好学的”这话可不是反问,而是问哦。 主要煎鱼觉得太多的人觉得Python的语法较为简单,写出来的代码只要符合逻辑,不需要太多的学习即可,即可从一门其他语言跳来用Python写(当然这样好事...
  • 很多人都知道需要加final,但是这什么呢? 原因 一话解释:保持数据的一致性。 基本数据类型:保持值的一致性 引用类型:保持引用的一致性 匿名内部类访问局部变量,编译器会拷贝一份使用的值通过匿名内部...
  • 权限修饰符的理解

    2020-09-24 03:29:03
    接口的抽象方法默认 public 访问修饰符,并且不能使用其他访问修饰符 ”,我就纳闷了同样抽象方法为什么支持的访问修饰符却不一样呢? 网上说这思想,这规定,一时之间让人无法理解。 我首先想到的,...
  • 什么是修饰器 一话概括:接受一个类作为参数的函数,用来修改类的行为。 参考阮一峰老师es6语法介绍 @testable class MyTestableClass { // ... } function testable(target) { target.isTestable = true; } ...
  • 话说的简单,但是涉及到真正的理解的话,还需要好好思考:说穿了,就是说,一定要明白到底引用不可变还是引用指向的对象不可变。  例如,当时去面试Oracle实习生的时候,给了一个例子,就是常用的swap函数,...
  • 关于修饰符static

    2012-03-30 21:57:53
    static在C#中静态声明的关键字,然而它与普通的非静态有什么区别呢? 通常咱们说的一在类中,静态的成员属于类,非静态的成员属于对象(或实例)。但是怎么理解呢? 这样的,静态的成员在编译时,首先...
  • 话说的简单,但是涉及到真正的理解的话,还需要好好思考:说穿了,就是说,一定要明白到底引用不可变还是引用指向的对象不可变。 例如,当时去面试Oracle实习生的时候,给了一个例子,就是常用的swap函数,...
  • 1.Java中锁怎么用? Java中有两大类使用锁的方式,一种为使用synchronized关键字,另一种为利用JDK中的类例如ReentrantLock。...2.Java中的锁到底是什么? 一话来说,锁就是一个类似于队列的数据...
  • 话的意思栈顶的地址和栈的最大容量系统预先规定好的,windows下栈的大小2M(也有的说是1M),如果申请的空间超过栈的剩余空间时,将提示overflow。 在函数调用时,第一个进栈的主函数中后的下一条指令...
  • 朝花夕拾——Java的synthetic修饰

    千次阅读 2015-12-14 23:00:43
    来自于google官方的性能建议文档的这样一话: Consider Package Instead of Private Access with Private Inner Classes 考虑包内访问来取代访问私有内部类的私有修饰的方法或变量 为什么
  • 每日两英语

    2014-06-16 09:43:28
    09.04.26 whose is this pen? 这是谁的笔? whose is XX的语法结构 XX为代词,可以加上... 你的衣服是什么颜色的? what color's xx? XX为代词,可以加上修饰,比如your pen,that pen?   ======================
  • 前言在前面几个章节中我们经常使用到 System.out.println(),那么它是什么呢?println() 是一个方法。System 是系统类。out 是标准输出对象。这话的用法是调用系统类 System 中的标准输出对象 out 中的方法 ...
  • 这个题也什么可深入挖掘的,面试的时候遇到这样的问题,你直接了当用几话说清楚就完了。 演示面试 我来直接演示面试: 你好,面试官,抽象类不允许用final修饰的。 抽象类的定义目的类不允许直接...
  • 什么叫搞定:任意给一个类型声明语句,能够判断其是争取的还是错误的,如果是正确的,其是什么含义。 什么叫复杂类型声明:融合指针,引用,const,数组,函数声明,函数指针等各种元素的类型声明。 对象是一块...
  • 0.static修饰类中成员,表示类的共享数据 1.static类成员 ...这什么意思?就是static不会想普通类数据成员一样每一个类对象都有一份,全部类对象共享一个static类成员的,例如A类对象修改了st...
  • 从句是修饰主句的,从句分为宾语从句,定语从句,谓语从句,状语从句等。扩展资料:从句不能单独成,但它也有主语部分和谓语部分,一个特殊句子,就像一个句子一样。所不同在于,从句须由一个关联词(connective)...
  • 什么要设计私有的,阿里巴巴规范这么描述的:“难道你不希望自己的小孩能一直出现在自己视野中,而不是到处乱跑吗”,原话可能有差异。但大概意思就是这个,当时我读到这话,我感觉很新颖、很生动...
  • 首届中国IT架构大师高峰论坛——一言以蔽之,十年架构之路汇成一话 一话概括十年技术精华,你想了解吗? 一起来聊聊吧! 拒接注水,不要修饰 ...无论成功与失败10年的经验总结的那一话,您感觉会是什么,你...
  • 英语中how much 和 how many 分别是什么意思? 都是 提问 XX (某物) 多少个的意思,所修饰词的不同 how much + 不可数名词 有多少? how much用来修饰不可数名词,表示数量,也可单独使用。 how many + 可数名词复数...
  • 在进行面试时,我发现大多数应聘者都不知道Java中的private修饰符真正意味着什么。 他们知道一些足以进行日常编码的事情,但还远远不够。 这不成问题。 足够了解就足够了。 但是,了解Java的一些内部工作仍然很有趣...

空空如也

空空如也

1 2 3 4 5 ... 16
收藏数 305
精华内容 122
关键字:

修饰句是什么句