Objective-C代码学习大纲(4)

2011-05-11 14:06 佚名 otierney  字号：T | T
一键收藏，随时查看，分享好友！

本文为台湾出版的《Objective-C学习大纲》的翻译文档，系统介绍了Objective-C代码，很多名词为台湾同胞特指词汇，在学习时仔细研读才能体会。

AD：干货来了,不要等！WOT2015 北京站演讲PPT开放下载！

 

继承、多型(Inheritance, Polymorphism)以及其他物件导向功能

id 型别

Objective-C 有种叫做 id 的型别，它的运作有时候像是 void*，不过它却严格规定只能用在物件。Objective-C 与 Java 跟 C++ 不一样，你在唿叫一个物件的 method 时，并不需要知道这个物件的型别。当然这个 method 一定要存在，这称为 Objective-C 的讯息传递。

 

  1. Fraction.h 
  2.  
  3. #import 
  4.  
  5. @interface Fraction: NSObject { 
  6.  
  7. int numerator; 
  8.  
  9. int denominator; 
  10.  
  11. } 
  12.  
  13. -(Fraction*) initWithNumerator: (int) n denominator: (int) d; 
  14.  
  15. -(void) print; 
  16.  
  17. -(void) setNumerator: (int) d; 
  18.  
  19. -(void) setDenominator: (int) d; 
  20.  
  21. -(void) setNumerator: (int) n andDenominator: (int) d; 
  22.  
  23. -(int) numerator; 
  24.  
  25. -(int) denominator; 
  26.  
  27. @end 
  28.  
  29. Fraction.m 
  30.  
  31. #import "Fraction.h" 
  32.  
  33. #import 
  34.  
  35. @implementation Fraction 
  36.  
  37. -(Fraction*) initWithNumerator: (int) n denominator: (int) d { 
  38.  
  39. self = [super init]; 
  40.  
  41. if ( self ) { 
  42.  
  43. [self setNumerator: n andDenominator: d]; 
  44.  
  45. } 
  46.  
  47. return self; 
  48.  
  49. } 
  50.  
  51. -(void) print { 
  52.  
  53. printf( "%i / %i", numerator, denominator ); 
  54.  
  55. } 
  56.  
  57. -(void) setNumerator: (int) n { 
  58.  
  59. nnumerator = n; 
  60.  
  61. } 
  62.  
  63. -(void) setDenominator: (int) d { 
  64.  
  65. ddenominator = d; 
  66.  
  67. } 
  68.  
  69. -(void) setNumerator: (int) n andDenominator: (int) d { 
  70.  
  71. nnumerator = n; 
  72.  
  73. ddenominator = d; 
  74.  
  75. } 
  76.  
  77. -(int) denominator { 
  78.  
  79. return denominator; 
  80.  
  81. } 
  82.  
  83. -(int) numerator { 
  84.  
  85. return numerator; 
  86.  
  87. } 
  88.  
  89. @end 
  90.  
  91. Complex.h 
  92.  
  93. #import 
  94.  
  95. @interface Complex: NSObject { 
  96.  
  97. double real; 
  98.  
  99. double imaginary; 
  100.  
  101. } 
  102.  
  103. -(Complex*) initWithReal: (double) r andImaginary: (double) i; 
  104.  
  105. -(void) setReal: (double) r; 
  106.  
  107. -(void) setImaginary: (double) i; 
  108.  
  109. -(void) setReal: (double) r andImaginary: (double) i; 
  110.  
  111. -(double) real; 
  112.  
  113. -(double) imaginary; 
  114.  
  115. -(void) print; 
  116.  
  117. @end 
  118.  
  119. Complex.m 
  120.  
  121. #import "Complex.h" 
  122.  
  123. #import 
  124.  
  125. @implementation Complex 
  126.  
  127. -(Complex*) initWithReal: (double) r andImaginary: (double) i { 
  128.  
  129. self = [super init]; 
  130.  
  131. if ( self ) { 
  132.  
  133. [self setReal: r andImaginary: i]; 
  134.  
  135. } 
  136.  
  137. return self; 
  138.  
  139. } 
  140.  
  141. -(void) setReal: (double) r { 
  142.  
  143. rreal = r; 
  144.  
  145. } 
  146.  
  147. -(void) setImaginary: (double) i { 
  148.  
  149. iimaginary = i; 
  150.  
  151. } 
  152.  
  153. -(void) setReal: (double) r andImaginary: (double) i { 
  154.  
  155. rreal = r; 
  156.  
  157. iimaginary = i; 
  158.  
  159. } 
  160.  
  161. -(double) real { 
  162.  
  163. return real; 
  164.  
  165. } 
  166.  
  167. -(double) imaginary { 
  168.  
  169. return imaginary; 
  170.  
  171. } 
  172.  
  173. -(void) print { 
  174.  
  175. printf( "%_f + %_fi", real, imaginary ); 
  176.  
  177. } 
  178.  
  179. @end 
  180.  
  181. main.m 
  182.  
  183. #import 
  184.  
  185. #import "Fraction.h" 
  186.  
  187. #import "Complex.h" 
  188.  
  189. int main( int argc, const char *argv[] ) { 
  190.  
  191. // create a new instance 
  192.  
  193. Fraction *frac = [[Fraction alloc] initWithNumerator: 1 denominator: 10]; 
  194.  
  195. Complex *comp = [[Complex alloc] initWithReal: 10 andImaginary: 15]; 
  196.  
  197. id number; 
  198.  
  199. // print fraction 
  200.  
  201. number = frac; 
  202.  
  203. printf( "The fraction is: " ); 
  204.  
  205. [number print]; 
  206.  
  207. printf( "\n" ); 
  208.  
  209. // print complex 
  210.  
  211. number = comp; 
  212.  
  213. printf( "The complex number is: " ); 
  214.  
  215. [number print]; 
  216.  
  217. printf( "\n" ); 
  218.  
  219. // free memory 
  220.  
  221. [frac release]; 
  222.  
  223. [comp release]; 
  224.  
  225. return 0; 
  226.  
  227. } 

 

output

  1. The fraction is: 1 / 10 
  2.  
  3. The complex number is: 10.000000 + 15.000000i 

这种动态连结有显而易见的好处。你不需要知道你唿叫 method 的那个东西是什么型别，如果这个物件对这个讯息有反应，那就会唤起这个 method。这也不会牵涉到一堆繁琐的转型动作，比如在 Java 裡唿叫一个整数物件的 .intValue() 就得先转型，然后才能唿叫这个 method。

继承(Inheritance)

 

  1. Rectangle.h 
  2.  
  3. #import 
  4.  
  5. @interface Rectangle: NSObject { 
  6.  
  7. int width; 
  8.  
  9. int height; 
  10.  
  11. } 
  12.  
  13. -(Rectangle*) initWithWidth: (int) w height: (int) h; 
  14.  
  15. -(void) setWidth: (int) w; 
  16.  
  17. -(void) setHeight: (int) h; 
  18.  
  19. -(void) setWidth: (int) w height: (int) h; 
  20.  
  21. -(int) width; 
  22.  
  23. -(int) height; 
  24.  
  25. -(void) print; 
  26.  
  27. @end 
  28.  
  29. Rectangle.m 
  30.  
  31. #import "Rectangle.h" 
  32.  
  33. #import 
  34.  
  35. @implementation Rectangle 
  36.  
  37. -(Rectangle*) initWithWidth: (int) w height: (int) h { 
  38.  
  39. self = [super init]; 
  40.  
  41. if ( self ) { 
  42.  
  43. [self setWidth: w height: h]; 
  44.  
  45. } 
  46.  
  47. return self; 
  48.  
  49. } 
  50.  
  51. -(void) setWidth: (int) w { 
  52.  
  53. wwidth = w; 
  54.  
  55. } 
  56.  
  57. -(void) setHeight: (int) h { 
  58.  
  59. hheight = h; 
  60.  
  61. } 
  62.  
  63. -(void) setWidth: (int) w height: (int) h { 
  64.  
  65. wwidth = w; 
  66.  
  67. hheight = h; 
  68.  
  69. } 
  70.  
  71. -(int) width { 
  72.  
  73. return width; 
  74.  
  75. } 
  76.  
  77. -(int) height { 
  78.  
  79. return height; 
  80.  
  81. } 
  82.  
  83. -(void) print { 
  84.  
  85. printf( "width = %i, height = %i", width, height ); 
  86.  
  87. } 
  88.  
  89. @end 
  90.  
  91. Square.h 
  92.  
  93. #import "Rectangle.h" 
  94.  
  95. @interface Square: Rectangle 
  96.  
  97. -(Square*) initWithSize: (int) s; 
  98.  
  99. -(void) setSize: (int) s; 
  100.  
  101. -(int) size; 
  102.  
  103. @end 
  104.  
  105. Square.m 
  106.  
  107. #import "Square.h" 
  108.  
  109. @implementation Square 
  110.  
  111. -(Square*) initWithSize: (int) s { 
  112.  
  113. self = [super init]; 
  114.  
  115. if ( self ) { 
  116.  
  117. [self setSize: s]; 
  118.  
  119. } 
  120.  
  121. return self; 
  122.  
  123. } 
  124.  
  125. -(void) setSize: (int) s { 
  126.  
  127. width = s; 
  128.  
  129. height = s; 
  130.  
  131. } 
  132.  
  133. -(int) size { 
  134.  
  135. return width; 
  136.  
  137. } 
  138.  
  139. -(void) setWidth: (int) w { 
  140.  
  141. [self setSize: w]; 
  142.  
  143. } 
  144.  
  145. -(void) setHeight: (int) h { 
  146.  
  147. [self setSize: h]; 
  148.  
  149. } 
  150.  
  151. @end 
  152.  
  153. main.m 
  154.  
  155. #import "Square.h" 
  156.  
  157. #import "Rectangle.h" 
  158.  
  159. #import 
  160.  
  161. int main( int argc, const char *argv[] ) { 
  162.  
  163. Rectangle *rec = [[Rectangle alloc] initWithWidth: 10 height: 20]; 
  164.  
  165. Square *sq = [[Square alloc] initWithSize: 15]; 
  166.  
  167. // print em 
  168.  
  169. printf( "Rectangle: " ); 
  170.  
  171. [rec print]; 
  172.  
  173. printf( "\n" ); 
  174.  
  175. printf( "Square: " ); 
  176.  
  177. [sq print]; 
  178.  
  179. printf( "\n" ); 
  180.  
  181. // update square 
  182.  
  183. [sq setWidth: 20]; 
  184.  
  185. printf( "Square after change: " ); 
  186.  
  187. [sq print]; 
  188.  
  189. printf( "\n" ); 
  190.  
  191. // free memory 
  192.  
  193. [rec release]; 
  194.  
  195. [sq release]; 
  196.  
  197. return 0; 
  198.  
  199. } 

 

output

  1. Rectangle: width = 10, height = 20 
  2.  
  3. Square: width = 15, height = 15 
  4.  
  5. Square after change: width = 20, height = 20 

继承在 Objective-C 裡比较像 Java。当你扩充你的 super class(所以只能有一个 parent)，你想自订这个 super class 的 method，只要简单的在你的 child class implementation 裡放上新的实作内容即可。而不需要 C++ 裡呆呆的 virtual table。

这裡还有一个值得玩味的地方，如果你企图像这样去唿叫 rectangle 的 constructor： Square *sq = [[Square alloc] initWithWidth: 10 height: 15]，会发生什么事?答案是会产生一个编译器错误。因为 rectangle constructor 回传的型别是 Rectangle*，而不是 Square*，所以这行不通。在某种情况下如果你真想这样用，使用 id 型别会是很好的选择。如果你想使用 parent 的 constructor，只要把 Rectangle* 回传型别改成 id 即可。

动态识别(Dynamic types)

这裡有一些用于 Objective-C 动态识别的 methods(说明部分採中英并列，因为我觉得英文比较传神，中文怎么译都怪)：

  1. -(BOOL) isKindOfClass: classObjis object a descendent or member of classObj 

此物件是否是 classObj 的子孙或一员

  1. -(BOOL) isMemberOfClass: classObjis object a member of classObj 

此物件是否是 classObj 的一员

  1. -(BOOL) respondsToSelector: selectordoes the object have a method named specifiec by the selector 

此物件是否有叫做 selector 的 method

  1. +(BOOL) instancesRespondToSelector: selectordoes an object created by this class have the ability to respond to the specified selector 

此物件是否是由有能力回应指定 selector 的物件所产生

  1. -(id) performSelector: selectorinvoke the specified selector on the object 

唤起此物件的指定 selector

所有继承自 NSObject 都有一个可回传一个 class 物件的 class method。这非常近似于 Java 的 getClass() method。这个 class 物件被使用于前述的 methods 中。

Selectors 在 Objective-C 用以表示讯息。下一个範例会秀出建立 selector 的语法。

 

  1. main.m 
  2.  
  3. #import "Square.h" 
  4.  
  5. #import "Rectangle.h" 
  6.  
  7. #import 
  8.  
  9. int main( int argc, const char *argv[] ) { 
  10.  
  11. Rectangle *rec = [[Rectangle alloc] initWithWidth: 10 height: 20]; 
  12.  
  13. Square *sq = [[Square alloc] initWithSize: 15]; 
  14.  
  15. // isMemberOfClass 
  16.  
  17. // true 
  18.  
  19. if ( [sq isMemberOfClass: [Square class]] == YES ) { 
  20.  
  21. printf( "square is a member of square class\n" ); 
  22.  
  23. } 
  24.  
  25. // false 
  26.  
  27. if ( [sq isMemberOfClass: [Rectangle class]] == YES ) { 
  28.  
  29. printf( "square is a member of rectangle class\n" ); 
  30.  
  31. } 
  32.  
  33. // false 
  34.  
  35. if ( [sq isMemberOfClass: [NSObject class]] == YES ) { 
  36.  
  37. printf( "square is a member of object class\n" ); 
  38.  
  39. } 
  40.  
  41. // isKindOfClass 
  42.  
  43. // true 
  44.  
  45. if ( [sq isKindOfClass: [Square class]] == YES ) { 
  46.  
  47. printf( "square is a kind of square class\n" ); 
  48.  
  49. } 
  50.  
  51. // true 
  52.  
  53. if ( [sq isKindOfClass: [Rectangle class]] == YES ) { 
  54.  
  55. printf( "square is a kind of rectangle class\n" ); 
  56.  
  57. } 
  58.  
  59. // true 
  60.  
  61. if ( [sq isKindOfClass: [NSObject class]] == YES ) { 
  62.  
  63. printf( "square is a kind of object class\n" ); 
  64.  
  65. } 
  66.  
  67. // respondsToSelector 
  68.  
  69. // true 
  70.  
  71. if ( [sq respondsToSelector: @selector( setSize: )] == YES ) { 
  72.  
  73. printf( "square responds to setSize: method\n" ); 
  74.  
  75. } 
  76.  
  77. // false 
  78.  
  79. if ( [sq respondsToSelector: @selector( nonExistant )] == YES ) { 
  80.  
  81. printf( "square responds to nonExistant method\n" ); 
  82.  
  83. } 
  84.  
  85. // true 
  86.  
  87. if ( [Square respondsToSelector: @selector( alloc )] == YES ) { 
  88.  
  89. printf( "square class responds to alloc method\n" ); 
  90.  
  91. } 
  92.  
  93. // instancesRespondToSelector 
  94.  
  95. // false 
  96.  
  97. if ( [Rectangle instancesRespondToSelector: @selector( setSize: )] == YES ) { 
  98.  
  99. printf( "rectangle instance responds to setSize: method\n" ); 
  100.  
  101. } 
  102.  
  103. // true 
  104.  
  105. if ( [Square instancesRespondToSelector: @selector( setSize: )] == YES ) { 
  106.  
  107. printf( "square instance responds to setSize: method\n" ); 
  108.  
  109. } 
  110.  
  111. // free memory 
  112.  
  113. [rec release]; 
  114.  
  115. [sq release]; 
  116.  
  117. return 0; 
  118.  
  119. } 

 

output

  1. square is a member of square class 
  2.  
  3. square is a kind of square class 
  4.  
  5. square is a kind of rectangle class 
  6.  
  7. square is a kind of object class 
  8.  
  9. square responds to setSize: method 
  10.  
  11. square class responds to alloc method 
  12.  
  13. square instance responds to setSize: method 
  14.  
  15. Categories 

当你想要为某个 class 新增 methods，你通常会扩充(extend，即继承)它。然而这不一定是个完美解法，特别是你想要重写一个 class 的某个功能，但你却没有塬始码时。Categories 允许你在现有的 class 加入新功能，但不需要扩充它。Ruby 语言也有类似的功能。

 

  1. FractionMath.h 
  2.  
  3. #import "Fraction.h" 
  4.  
  5. @interface Fraction (Math) 
  6.  
  7. -(Fraction*) add: (Fraction*) f; 
  8.  
  9. -(Fraction*) mul: (Fraction*) f; 
  10.  
  11. -(Fraction*) div: (Fraction*) f; 
  12.  
  13. -(Fraction*) sub: (Fraction*) f; 
  14.  
  15. @end 
  16.  
  17. FractionMath.m 
  18.  
  19. #import "FractionMath.h" 
  20.  
  21. @implementation Fraction (Math) 
  22.  
  23. -(Fraction*) add: (Fraction*) f { 
  24.  
  25. return [[Fraction alloc] initWithNumerator: numerator * [f denominator] + 
  26.  
  27. denominator * [f numerator] 
  28.  
  29. denominator: denominator * [f denominator]]; 
  30.  
  31. } 
  32.  
  33. -(Fraction*) mul: (Fraction*) f { 
  34.  
  35. return [[Fraction alloc] initWithNumerator: numerator * [f numerator] 
  36.  
  37. denominator: denominator * [f denominator]]; 
  38.  
  39. } 
  40.  
  41. -(Fraction*) div: (Fraction*) f { 
  42.  
  43. return [[Fraction alloc] initWithNumerator: numerator * [f denominator] 
  44.  
  45. denominator: denominator * [f numerator]]; 
  46.  
  47. } 
  48.  
  49. -(Fraction*) sub: (Fraction*) f { 
  50.  
  51. return [[Fraction alloc] initWithNumerator: numerator * [f denominator] - 
  52.  
  53. denominator * [f numerator] 
  54.  
  55. denominator: denominator * [f denominator]]; 
  56.  
  57. } 
  58.  
  59. @end 
  60.  
  61. main.m 
  62.  
  63. #import 
  64.  
  65. #import "Fraction.h" 
  66.  
  67. #import "FractionMath.h" 
  68.  
  69. int main( int argc, const char *argv[] ) { 
  70.  
  71. // create a new instance 
  72.  
  73. Fraction *frac1 = [[Fraction alloc] initWithNumerator: 1 denominator: 3]; 
  74.  
  75. Fraction *frac2 = [[Fraction alloc] initWithNumerator: 2 denominator: 5]; 
  76.  
  77. Fraction *frac3 = [frac1 mul: frac2]; 
  78.  
  79. // print it 
  80.  
  81. [frac1 print]; 
  82.  
  83. printf( " * " ); 
  84.  
  85. [frac2 print]; 
  86.  
  87. printf( " = " ); 
  88.  
  89. [frac3 print]; 
  90.  
  91. printf( "\n" ); 
  92.  
  93. // free memory 
  94.  
  95. [frac1 release]; 
  96.  
  97. [frac2 release]; 
  98.  
  99. [frac3 release]; 
  100.  
  101. return 0; 
  102.  
  103. } 

 

output

  1. 1/3 * 2/5 = 2/15 

重点是 @implementation 跟 @interface 这两行：@interface Fraction (Math) 以及 @implementation Fraction (Math).

(同一个 class)只能有一个同名的 category，其他的 categories 得加上不同的、独一无二的名字。

Categories 在建立 private methods 时十分有用。因为 Objective-C 并没有像 Java 这种 private/protected/public methods 的概念，所以必须要使用 categories 来达成这种功能。作法是把 private method 从你的 class header (.h) 档案移到 implementation (.m) 档案。以下是此种作法一个简短的範例。

  1. MyClass.h 
  2.  
  3. #import 
  4.  
  5. @interface MyClass: NSObject 
  6.  
  7. -(void) publicMethod; 
  8.  
  9. @end 
  10.  
  11. MyClass.m 
  12.  
  13. #import "MyClass.h" 
  14.  
  15. #import 
  16.  
  17. @implementation MyClass 
  18.  
  19. -(void) publicMethod { 
  20.  
  21. printf( "public method\n" ); 
  22.  
  23. } 
  24.  
  25. @end 
  26.  
  27. // private methods 
  28.  
  29. @interface MyClass (Private) 
  30.  
  31. -(void) privateMethod; 
  32.  
  33. @end 
  34.  
  35. @implementation MyClass (Private) 
  36.  
  37. -(void) privateMethod { 
  38.  
  39. printf( "private method\n" ); 
  40.  
  41. } 
  42.  
  43. @end 
  44.  
  45. main.m 
  46.  
  47. #import "MyClass.h" 
  48.  
  49. int main( int argc, const char *argv[] ) { 
  50.  
  51. MyClass *obj = [[MyClass alloc] init]; 
  52.  
  53. // this compiles 
  54.  
  55. [obj publicMethod]; 
  56.  
  57. // this throws errors when compiling 
  58.  
  59. //[obj privateMethod]; 
  60.  
  61. // free memory 
  62.  
  63. [obj release]; 
  64.  
  65. return 0; 
  66.  
  67. } 

output

  1. public method 
  2.  
  3. Posing 

Posing 有点像 categories，但是不太一样。它允许你扩充一个 class，并且全面性地的扮演(pose)这个 super class。例如：你有一个扩充 NSArray 的 NSArrayChild 物件。如果你让 NSArrayChild 扮演 NSArray，则在你的程式码中所有的 NSArray 都会自动被替代为 NSArrayChild。

  1. FractionB.h 
  2.  
  3. #import "Fraction.h" 
  4.  
  5. @interface FractionB: Fraction 
  6.  
  7. -(void) print; 
  8.  
  9. @end 
  10.  
  11. FractionB.m 
  12.  
  13. #import "FractionB.h" 
  14.  
  15. #import 
  16.  
  17. @implementation FractionB 
  18.  
  19. -(void) print { 
  20.  
  21. printf( "(%i/%i)", numerator, denominator ); 
  22.  
  23. } 
  24.  
  25. @end 
  26.  
  27. main.m 
  28.  
  29. #import 
  30.  
  31. #import "Fraction.h" 
  32.  
  33. #import "FractionB.h" 
  34.  
  35. int main( int argc, const char *argv[] ) { 
  36.  
  37. Fraction *frac = [[Fraction alloc] initWithNumerator: 3 denominator: 10]; 
  38.  
  39. // print it 
  40.  
  41. printf( "The fraction is: " ); 
  42.  
  43. [frac print]; 
  44.  
  45. printf( "\n" ); 
  46.  
  47. // make FractionB pose as Fraction 
  48.  
  49. [FractionB poseAsClass: [Fraction class]]; 
  50.  
  51. Fraction *frac2 = [[Fraction alloc] initWithNumerator: 3 denominator: 10]; 
  52.  
  53. // print it 
  54.  
  55. printf( "The fraction is: " ); 
  56.  
  57. [frac2 print]; 
  58.  
  59. printf( "\n" ); 
  60.  
  61. // free memory 
  62.  
  63. [frac release]; 
  64.  
  65. [frac2 release]; 
  66.  
  67. return 0; 
  68.  
  69. } 

 

output

  1. The fraction is: 3/10 
  2.  
  3. The fraction is: (3/10) 

这个程式的输出中，第一个 fraction 会输出 3/10，而第二个会输出 (3/10)。这是 FractionB 中实作的方式。

poseAsClass 这个 method 是 NSObject 的一部份，它允许 subclass 扮演 superclass。

Protocols

Objective-C 裡的 Protocol 与 Java 的 interface 或是 C++ 的 purely virtual class 相同。

 

  1. Printing.h 
  2.  
  3. @protocol Printing 
  4.  
  5. -(void) print; 
  6.  
  7. @end 
  8.  
  9. Fraction.h 
  10.  
  11. #import 
  12.  
  13. #import "Printing.h" 
  14.  
  15. @interface Fraction: NSObject { 
  16.  
  17. int numerator; 
  18.  
  19. int denominator; 
  20.  
  21. } 
  22.  
  23. -(Fraction*) initWithNumerator: (int) n denominator: (int) d; 
  24.  
  25. -(void) setNumerator: (int) d; 
  26.  
  27. -(void) setDenominator: (int) d; 
  28.  
  29. -(void) setNumerator: (int) n andDenominator: (int) d; 
  30.  
  31. -(int) numerator; 
  32.  
  33. -(int) denominator; 
  34.  
  35. @end 
  36.  
  37. Fraction.m 
  38.  
  39. #import "Fraction.h" 
  40.  
  41. #import 
  42.  
  43. @implementation Fraction 
  44.  
  45. -(Fraction*) initWithNumerator: (int) n denominator: (int) d { 
  46.  
  47. self = [super init]; 
  48.  
  49. if ( self ) { 
  50.  
  51. [self setNumerator: n andDenominator: d]; 
  52.  
  53. } 
  54.  
  55. return self; 
  56.  
  57. } 
  58.  
  59. -(void) print { 
  60.  
  61. printf( "%i/%i", numerator, denominator ); 
  62.  
  63. } 
  64.  
  65. -(void) setNumerator: (int) n { 
  66.  
  67. nnumerator = n; 
  68.  
  69. } 
  70.  
  71. -(void) setDenominator: (int) d { 
  72.  
  73. ddenominator = d; 
  74.  
  75. } 
  76.  
  77. -(void) setNumerator: (int) n andDenominator: (int) d { 
  78.  
  79. nnumerator = n; 
  80.  
  81. ddenominator = d; 
  82.  
  83. } 
  84.  
  85. -(int) denominator { 
  86.  
  87. return denominator; 
  88.  
  89. } 
  90.  
  91. -(int) numerator { 
  92.  
  93. return numerator; 
  94.  
  95. } 
  96.  
  97. -(Fraction*) copyWithZone: (NSZone*) zone { 
  98.  
  99. return [[Fraction allocWithZone: zone] initWithNumerator: numerator 
  100.  
  101. denominator: denominator]; 
  102.  
  103. } 
  104.  
  105. @end 
  106.  
  107. Complex.h 
  108.  
  109. #import 
  110.  
  111. #import "Printing.h" 
  112.  
  113. @interface Complex: NSObject { 
  114.  
  115. double real; 
  116.  
  117. double imaginary; 
  118.  
  119. } 
  120.  
  121. -(Complex*) initWithReal: (double) r andImaginary: (double) i; 
  122.  
  123. -(void) setReal: (double) r; 
  124.  
  125. -(void) setImaginary: (double) i; 
  126.  
  127. -(void) setReal: (double) r andImaginary: (double) i; 
  128.  
  129. -(double) real; 
  130.  
  131. -(double) imaginary; 
  132.  
  133. @end 
  134.  
  135. Complex.m 
  136.  
  137. #import "Complex.h" 
  138.  
  139. #import 
  140.  
  141. @implementation Complex 
  142.  
  143. -(Complex*) initWithReal: (double) r andImaginary: (double) i { 
  144.  
  145. self = [super init]; 
  146.  
  147. if ( self ) { 
  148.  
  149. [self setReal: r andImaginary: i]; 
  150.  
  151. } 
  152.  
  153. return self; 
  154.  
  155. } 
  156.  
  157. -(void) setReal: (double) r { 
  158.  
  159. rreal = r; 
  160.  
  161. } 
  162.  
  163. -(void) setImaginary: (double) i { 
  164.  
  165. iimaginary = i; 
  166.  
  167. } 
  168.  
  169. -(void) setReal: (double) r andImaginary: (double) i { 
  170.  
  171. rreal = r; 
  172.  
  173. iimaginary = i; 
  174.  
  175. } 
  176.  
  177. -(double) real { 
  178.  
  179. return real; 
  180.  
  181. } 
  182.  
  183. -(double) imaginary { 
  184.  
  185. return imaginary; 
  186.  
  187. } 
  188.  
  189. -(void) print { 
  190.  
  191. printf( "%_f + %_fi", real, imaginary ); 
  192.  
  193. } 
  194.  
  195. @end 
  196.  
  197. main.m 
  198.  
  199. #import 
  200.  
  201. #import "Fraction.h" 
  202.  
  203. #import "Complex.h" 
  204.  
  205. int main( int argc, const char *argv[] ) { 
  206.  
  207. // create a new instance 
  208.  
  209. Fraction *frac = [[Fraction alloc] initWithNumerator: 3 denominator: 10]; 
  210.  
  211. Complex *comp = [[Complex alloc] initWithReal: 5 andImaginary: 15]; 
  212.  
  213. id printable; 
  214.  
  215. id copyPrintable; 
  216.  
  217. // print it 
  218.  
  219. printable = frac; 
  220.  
  221. printf( "The fraction is: " ); 
  222.  
  223. [printable print]; 
  224.  
  225. printf( "\n" ); 
  226.  
  227. // print complex 
  228.  
  229. printable = comp; 
  230.  
  231. printf( "The complex number is: " ); 
  232.  
  233. [printable print]; 
  234.  
  235. printf( "\n" ); 
  236.  
  237. // this compiles because Fraction comforms to both Printing and NSCopyable 
  238.  
  239. copyPrintable = frac; 
  240.  
  241. // this doesn't compile because Complex only conforms to Printing 
  242.  
  243. //copyPrintable = comp; 
  244.  
  245. // test conformance 
  246.  
  247. // true 
  248.  
  249. if ( [frac conformsToProtocol: @protocol( NSCopying )] == YES ) { 
  250.  
  251. printf( "Fraction conforms to NSCopying\n" ); 
  252.  
  253. } 
  254.  
  255. // false 
  256.  
  257. if ( [comp conformsToProtocol: @protocol( NSCopying )] == YES ) { 
  258.  
  259. printf( "Complex conforms to NSCopying\n" ); 
  260.  
  261. } 
  262.  
  263. // free memory 
  264.  
  265. [frac release]; 
  266.  
  267. [comp release]; 
  268.  
  269. return 0; 
  270.  
  271. } 

 

output

  1. The fraction is: 3/10 
  2.  
  3. The complex number is: 5.000000 + 15.000000i 
  4.  
  5. Fraction conforms to NSCopying 

protocol 的宣告十分简单，基本上就是 @protocol ProtocolName (methods you must implement) @end。

要遵从(conform)某个 protocol，将要遵从的 protocols 放在 <> 裡面，并以逗点分隔。如：@interface SomeClass

protocol 要求实作的 methods 不需要放在 header 档裡面的 methods 列表中。如你所见，Complex.h 档案裡没有 -(void) print 的宣告，却还是要实作它，因为它(Complex class)遵从了这个 protocol。

Objective-C 的介面系统有一个独一无二的观念是如何指定一个型别。比起 C++ 或 Java 的指定方式，如：Printing *someVar = ( Printing * ) frac; 你可以使用 id 型别加上 protocol：id var = frac;。这让你可以动态地指定一个要求多个 protocol 的型别，却从头到尾只用了一个变数。如： var = frac;

就像使用@selector 来测试物件的继承关係，你可以使用 @protocol 来测试物件是否遵从介面。如果物件遵从这个介面，[object conformsToProtocol: @protocol( SomeProtocol )] 会回传一个 YES 型态的 BOOL 物件。同样地，对 class 而言也能如法炮製 [SomeClass conformsToProtocol: @protocol( SomeProtocol )]。

你可能感兴趣的:(Objective-C)

  • iOS内存管理简单理解 烧烤有点辣
    什么是引用计数引用计数（ReferenceCount）是一个简单而有效的管理对象生命周期的方式。当我们创建一个新对象的时候，它的引用计数为1，当有一个新的指针指向这个对象时，我们将其引用计数加1，当某个指针不再指向这个对象是，我们将其引用计数减1，当对象的引用计数变为0时，说明这个对象不再被任何指针指向了，这个时候我们就可以将对象销毁，回收内存。由于引用计数简单有效，除了Objective-C和S
  • Objective-C 静态方法可以重写吗 赵哥窟
    首先来看一段代码#import@interfacePerson:NSObject+(void)pringName:(NSString*)name;@end#import"Person.h"@interfacePerson()@end@implementationPerson+(void)pringName:(NSString*)name{NSLog(@"Person-%@",name);}@end
  • iOS OC 基础知识整理 孤独的浪客 ios
    1@synthesize和@dynamic的区别在Objective-C中，@synthesize和@dynamic用于实现属性(property)的自动或手动合成。它们告诉编译器如何处理类中声明的属性。@synthesize@synthesize指令用于告诉编译器自动生成getter和setter方法。在早期的Objective-C版本中，如果你声明了一个属性，你需要使用@synthesize来
  • Objective-C高级特性浅析与实践指南 小鹿撞出了脑震荡 objective-c学习
    OC的学习笔记（二）文章目录OC的学习笔记（二）@property访问控制符点语法自定义`init`方法内存管理retain和release@class处理发生异常的方法NSSrting的常用方法类方法对象方法lengthcharacterAtIndexisEuqalStringcompare@autorelease和自动释放池自动释放池Category类别与扩展category的运用NSNumb
  • isa 底层结构分析 远方竹叶
    OC对象的本质在我们日常的开发中，会创建很多个自定义的对象，大部分是继承自NSObject，但是具体到源码实现，就看不到了，怎么办呢？编译器clang就要登场了ClangClang是一个有Apple主导编写，基于LLVM的C/C++/Objective-C的编译器主要用于底层编译，将一些文件输出为C++文件，可以更好的查看底层的结构以及实现逻辑探索在main函数中创建一个LCPerson类，添加n
  • iOS之运行时机制(三) 奋拓达
    前言Objective-C语言是一门动态语言，它将很多静态语言在编译和链接时期做的事放到了运行时来处理。这种动态语言的优势在于：我们写代码时更具灵活性，如我们可以把消息转发给我们想要的对象，或者随意交换一个方法的实现等这种特性意味着Objective-C不仅需要一个编译器，还需要一个运行时系统来执行编译的代码。对于Objective-C来说，这个运行时系统就像一个操作系统一样：它让所有的工作可以正
  • Swift笔记：可选类型 du_90 Swift学习swift可选类型nil
    C和Objective-C中并没有可选类型这个概念。最接近的是Objective-C中的一个特性，一个方法要不返回一个对象要不返回nil，nil表示“缺少一个合法的对象”。然而，这只对对象起作用——对于结构体，基本的C类型或者枚举类型不起作用。对于这些类型，Objective-C方法一般会返回一个特殊值（比如NSNotFound）来暗示值缺失。这种方法假设方法的调用者知道并记得对特殊值进行判断。然
  • Objective-C实现SieveOfEratosthenes埃拉托色尼筛法打印所有素数算法（附完整源码） 源代码大师 objective-c算法蓝桥杯
    Objective-C实现SieveOfEratosthenes埃拉托色尼筛法打印所有素数算法下面是一个用Objective-C实现的埃拉托色尼筛法（SieveofEratosthenes）算法的完整源码。这个算法用于找出小于或等于给定整数的所有素数。#import@interfaceSieveOfEratosthenes:NSObject(void)printPrimesUpTo:(NSInte
  • Proto3: Generating Your Classes - 生成你的类 Upping8
    TogeneratetheJava,Kotlin,Python,C++,Go,Ruby,Objective-C,orC#codeyouneedtoworkwiththemessagetypesdefinedina.protofile,youneedtoruntheprotocolbuffercompilerprotoconthe.proto.Ifyouhaven'tinstalledthecomp
  • 【iOS】——分类拓展关联对象 不会敲代码的VanGogh ios分类macosobjective-c学习
    分类OC的动态特征允许使用类别为现有的类添加新方法并且不需要创建子类，不需要访问原有类的源代码。通过使用类别即可动态为现有的类添加新方法，而且可以将类定义模块化分布到多个相关文件。分类是Objective-C中的一种语言特性，它允许你为现有类添加新的方法，而无需修改原始类的源代码。分类就像一个“扩展”，你可以用它来添加新的功能，而不必创建子类。分类不能添加新的实例变量，只能添加方法。分类也可以把f
  • iOS面试：runtime如何实现weak变量的自动置nil？ androiios ios面试
    在iOS开发中，weak变量的自动置nil是Objective-C和Swift中内存管理的重要特性。这个特性主要依赖于Objective-C的运行时（runtime）机制。以下是对这个过程的详细解释：1.weak变量的定义weak变量是一种引用类型，它不会增加对象的引用计数。当一个对象的所有强引用（strong）被释放时，weak引用会自动被置为nil。这样可以避免循环引用（retaincycle
  • Objective-C实现Farey Approximation近似算法（附完整源码） 源代码大师 objective-c开发语言macos
    Objective-C实现FareyApproximation近似算法FareyApproximation是一种用于寻找有理数近似的方法，特别是在给定的实数和分母范围内。下面是一个使用Objective-C实现FareyApproximation的简单示例。Objective-C实现FareyApproximation#import@interfaceFareyApproximation:NSOb
  • Objective-C属性字符串NSAttributedString FEverStar iOS开发iOS开发入门到精通objective-cNSAttribut属性字符串
    NSAttributedString是Objective-C中的属性字符串类，GitHub上也有很多第三方，用得较多的是TTTAttributedLabel，这里给大家介绍一下系统NSAttributedString类来实现富文本，并可实现点击事件，同时点击事件可携带参数。因为要做点击事件，所以我们用UITextView，首先声明一个UITextView属性：@property(nonatomic
  • 深入探索Objective-C的NSOrthography：拼写检查的艺术与科学 2402_85758349 objective-c开发语言macos
    标题：“深入探索Objective-C的NSOrthography：拼写检查的艺术与科学”在软件开发中，拼写检查是一个重要的功能，它帮助用户避免拼写错误，提高文本的准确性和专业性。Objective-C，作为iOS和macOS开发的主要语言之一，提供了NSOrthography类来处理拼写检查。本文将深入探讨NSOrthography的工作原理，并展示如何在实际应用中实现拼写检查功能。1.拼写检查
  • Objective-C中的查询大师：深入探索NSPredicate与NSExpression 原机小子 objective-c开发语言macos
    标题：Objective-C中的查询大师：深入探索NSPredicate与NSExpression在Objective-C中，NSPredicate和NSExpression是CoreData框架中的两个强大工具，它们允许开发者以声明式的方式来查询和操作数据。通过使用这些工具，可以轻松地对集合进行筛选、排序和计算，而无需编写复杂的循环和条件语句。本文将详细介绍NSPredicate和NSExpre
  • objective-c中调用shell命令 maricoliu macobjective-c
    Launchingatask[permalink]Herearethebasicstolaunch"ls-l-a-t"inthecurrentdirectory,andthenreadtheresultintoanNSString:NSTask*task;task=[[NSTaskalloc]init];[tasksetLaunchPath:@"/bin/ls"];NSArray*argument
  • Objective-C执行Shell Grey Wind 各语言执行shellobjective-c开发语言
    代码如下#import@interfaceShellCommand:NSObject+(NSString*)executeCommand:(NSString*)command;@end@implementationShellCommand+(NSString*)executeCommand:(NSString*)command{NSTask*task=[[NSTaskalloc]init];[ta
  • Objective-C中的广播站：深度解析NSNotificationCenter 2401_85763639 objective-cios开发语言
    标题：Objective-C中的广播站：深度解析NSNotificationCenter在Objective-C中，NSNotificationCenter是一个强大的组件，它允许对象之间进行松耦合的通信。这种机制通常被称为发布-订阅模式或观察者模式。NSNotificationCenter允许对象发送通知，而无需知道哪些对象会接收这些通知。本文将详细解释NSNotificationCenter的
  • Objective-C中的MVC架构：构建清晰、可维护的iOS应用 2401_85761003 开发语言
    标题：Objective-C中的MVC架构：构建清晰、可维护的iOS应用在iOS开发中，MVC（Model-View-Controller）架构模式是一种经典的设计模式，用于分离应用的业务逻辑、用户界面和控制逻辑，以提高代码的可维护性和可扩展性。本文将详细介绍Objective-C中如何使用MVC架构，包括MVC的基本概念、各组件的职责以及如何在实际项目中应用MVC架构，并通过代码示例展示其实现。
  • Objective-C中的时光机器：NSKeyedArchiver与NSKeyedUnarchiver的序列化之旅 杨哥带你写代码 objective-c开发语言macos
    标题：Objective-C中的时光机器：NSKeyedArchiver与NSKeyedUnarchiver的序列化之旅在Objective-C的世界中，对象序列化是一种将对象状态转换为可以存储或传输的形式的技术，而反序列化则是这一过程的逆过程。NSKeyedArchiver和NSKeyedUnarchiver是iOS和macOS开发中用于对象序列化的两个非常有用的类。它们允许开发者将对象的状态归
  • Objective-C 中的管道艺术：NSPipe 通信全解析 2401_85742452 objective-cios开发语言
    标题：Objective-C中的管道艺术：NSPipe通信全解析在Unix和类Unix系统编程中，管道是一种常见的进程间通信（IPC）机制。而在Objective-C中，NSPipe类提供了一种在应用程序内不同线程或进程之间进行通信的高级抽象。本文将详细探讨NSPipe的工作机制，并展示如何在实际的Objective-C应用程序中使用管道进行线程间通信。1.NSPipe简介NSPipe是Found
  • 深入Objective-C：NSFilePresenter与NSFileProvider的协同艺术 2401_85812053 objective-c开发语言macos
    标题：深入Objective-C：NSFilePresenter与NSFileProvider的协同艺术在macOS开发中，文件的呈现和提供是应用程序与系统文件交互的核心部分。Objective-C作为macOS开发的主要语言，提供了NSFilePresenter和NSFileProvider两个协议来帮助开发者实现文件的动态管理和访问。本文将深入探讨这两个协议的工作原理，并提供实际代码示例，以帮
  • Objective-C 动态调用秘籍：NSInvocation 的魔法 2401_85812026 objective-cios开发语言
    标题：Objective-C动态调用秘籍：NSInvocation的魔法在Objective-C编程中，NSInvocation是一个强大的工具，它允许你在运行时动态地调用方法。这种能力对于实现诸如方法拦截、依赖注入、或者在不知道方法签名的情况下调用方法等高级功能至关重要。本文将深入探索NSInvocation的使用方法，并展示如何通过代码示例来动态调用Objective-C中的方法。1.NSIn
  • iOS 开发：Object-C 和 Swift 的区别 （AI问答） app开发工程师V帅 iosswift开发语言
    一：语言类型的区别（最主要区别）object-c是动态类型语言；swift是静态类型语言；看一下AI的回答，很全面~~Objective-C和Swift的语言类型区别主要体现在以下几个方面：1.静态类型vs.动态类型Objective-C：动态类型：使用动态类型系统。你可以在运行时决定对象的实际类型，这使得编译器在编译时不进行严格的类型检查。这种灵活性可以增加编程的灵活性，但也可能带来运行时错误。
  • 深入解析：Objective-C中的NSDistributedNotificationCenter分布式通知机制 2401_85743969 objective-c分布式开发语言
    标题：深入解析：Objective-C中的NSDistributedNotificationCenter分布式通知机制在Objective-C的世界中，NSDistributedNotificationCenter是一个强大的工具，它允许应用程序在不同的进程之间发送和接收通知。这种分布式通知机制对于构建复杂的系统非常有用，尤其是在需要跨应用通信的场景中。本文将深入探讨NSDistributedNo
  • Cocoa基本原理指南之十一 - Cocoa设计模式 iteye_20746 设计模式移动开发xcode
    Cocoa设计模式Cocoa环境的很多架构和机制都有效地使用了设计模式：即为特定上下文中反复出现的问题提供解决方案的抽象设计。Cocoa中设计模式的实现有不同的形式。下面部分中描述的一些设计—比如协议和范畴—是Objective-C语言的特性；在另外一些场合中，“模式的实例”被实现为一个类或一组相关的类（比如类簇和单件类）；还有一些场合下，模式表现为一个大的框架结构，比如响应者链模式。抽象工厂模式
  • 探索分布式编程的未来：eDistantObject——简化你的跨进程通信之旅 温宝沫Morgan
    探索分布式编程的未来：eDistantObject——简化你的跨进程通信之旅在现代软件开发中，高效且灵活的跨进程通信已成为不可或缺的一部分。eDistantObject（简称eDO），一个出自Google的开源杰作，正为此而来，它为Objective-C和Swift开发者提供了一种无需繁琐RPC构建即可实现远程调用的轻巧途径。项目介绍eDistantObject，直译为“简易远端对象”，它的核心在
  • 探秘eDistantObject：轻松实现跨进程通信 庞锦宇
    探秘eDistantObject：轻松实现跨进程通信在软件开发中，进程间的通信是一种常见的需求，它允许不同的程序或服务之间交换数据和控制行为。为此，我们介绍一个由Google开源的项目——eDistantObject，它提供了一种简单的方法来实现在Objective-C和Swift中的远程调用，而无需显式构建RPC（RemoteProcedureCall）结构。项目介绍eDistantObject
  • 网络访问 datacloud 网络object服务器apiurlobjectivec
    《OBjectiveC2.0Phrasebook-17networkaccess》开发跨平台网络可知应用程序的标准方法是使用Berkeley套接字API。它也是开发TCP/IP的一部分，并且是协议无关的。大多数语言都对这个API进行了实现。在Objective-C中，你仍然可以尽情使用C语言，它提供了所有底层接口的能力。但是大多数时候，这么做往往事倍功半。Foundation框架提供了一些类，使开
  • iOS面试题(三) WinJayQ
    1、Objective-C中创建线程的方法是什么？如果在主线程中执行代码，方法是什么？如果想延时执行代码、方法又是什么？线程创建有三种方法：使用NSThread创建、使用GCD的dispatch、使用子类化的NSOperation,然后将其加入NSOperationQueue;在主线程执行代码，方法是performSelectorOnMainThread，如果想延时执行代码可以用performSe
  • 异常的核心类Throwable 无量 java源码异常处理exception
    java异常的核心是Throwable，其他的如Error和Exception都是继承的这个类 里面有个核心参数是detailMessage，记录异常信息，getMessage核心方法，获取这个参数的值，我们可以自己定义自己的异常类，去继承这个Exception就可以了，方法基本上，用父类的构造方法就OK，所以这么看异常是不是很easy package com.natsu;
  • mongoDB 游标（cursor） 实现分页 迭代 开窍的石头 mongodb
    上篇中我们讲了mongoDB 中的查询函数，现在我们讲mongo中如何做分页查询      如何声明一个游标        var mycursor = db.user.find({_id:{$lte:5}});       迭代显示游标数
  • MySQL数据库INNODB 表损坏修复处理过程 0624chenhong tomcatmysql
    最近mysql数据库经常死掉，用命令net stop mysql命令也无法停掉，关闭Tomcat的时候，出现Waiting for N instance(s) to be deallocated 信息。查了下，大概就是程序没有对数据库连接释放，导致Connection泄露了。因为用的是开元集成的平台，内部程序也不可能一下子给改掉的，就验证一下咯。启动Tomcat,用户登录系统，用netstat -
  • 剖析如何与设计人员沟通 不懂事的小屁孩 工作
    最近做图烦死了，不停的改图，改图……。烦，倒不是因为改，而是反反复复的改，人都会死。很多需求人员不知该如何与设计人员沟通，不明白如何使设计人员知道他所要的效果，结果只能是沟通变成了扯淡，改图变成了应付。 那应该如何与设计人员沟通呢？ 我认为设计人员与需求人员先天就存在语言障碍。对一个合格的设计人员来说，整天玩的都是点、线、面、配色，哪种构图看起来协调；哪种配色看起来合理心里跟明镜似的，
  • qq空间刷评论工具 换个号韩国红果果 JavaScript
    var a=document.getElementsByClassName('textinput'); var b=[]; for(var m=0;m<a.length;m++){ if(a[m].getAttribute('placeholder')!=null) b.push(a[m]) } var l
  • S2SH整合之session 灵静志远 springAOPstrutssession
    错误信息： Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'cartService': Scope 'session' is not active for the current thread; consider defining a scoped
  • xmp标签 a-john 标签
    今天在处理数据的显示上遇到一个问题： var html = '<li><div class="pl-nr"><span class="user-name">' + user + '</span>' + text + '</div></li>'; ulComme
  • Ajax的常用技巧（2）---实现Web页面中的级联菜单 aijuans Ajax
    在网络上显示数据，往往只显示数据中的一部分信息，如文章标题，产品名称等。如果浏览器要查看所有信息，只需点击相关链接即可。在web技术中，可以采用级联菜单完成上述操作。根据用户的选择，动态展开，并显示出对应选项子菜单的内容。 在传统的web实现方式中，一般是在页面初始化时动态获取到服务端数据库中对应的所有子菜单中的信息，放置到页面中对应的位置，然后再结合CSS层叠样式表动态控制对应子菜单的显示或者隐
  • 天-安-门，好高 atongyeye 情感
        我是85后，北漂一族，之前房租1100，因为租房合同到期，再续，房租就要涨150。最近网上新闻，地铁也要涨价。算了一下，涨价之后，每次坐地铁由原来2块变成6块。仅坐地铁费用，一个月就要涨200。内心苦痛。     晚上躺在床上一个人想了很久，很久。        我生在农
  • android 动画 百合不是茶 android透明度平移缩放旋转
    android的动画有两种  tween动画和Frame动画   tween动画;,透明度,缩放,旋转,平移效果   Animation   动画 AlphaAnimation 渐变透明度 RotateAnimation 画面旋转 ScaleAnimation 渐变尺寸缩放 TranslateAnimation 位置移动 Animation
  • 查看本机网络信息的cmd脚本 bijian1013 cmd
    @echo 您的用户名是：%USERDOMAIN%\%username%>"%userprofile%\网络参数.txt" @echo 您的机器名是：%COMPUTERNAME%>>"%userprofile%\网络参数.txt" @echo ___________________>>"%userprofile%\
  • plsql 清除登录过的用户 征客丶 plsql
    tools---preferences----logon history---history  把你想要删除的删除 -------------------------------------------------------------------- 若有其他凝问或文中有错误，请及时向我指出， 我好及时改正，同时也让我们一起进步。 email ： binary_spac
  • 【Pig一】Pig入门 bit1129 pig
    Pig安装 1.下载pig   wget http://mirror.bit.edu.cn/apache/pig/pig-0.14.0/pig-0.14.0.tar.gz   2. 解压配置环境变量      如果Pig使用Map/Reduce模式，那么需要在环境变量中，配置HADOOP_HOME环境变量   expor
  • Java 线程同步几种方式 BlueSkator volatilesynchronizedThredLocalReenTranLockConcurrent
    为何要使用同步？      java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），      将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，      从而保证了该变量的唯一性和准确性。 1.同步方法&
  • StringUtils判断字符串是否为空的方法（转帖） BreakingBad nullStringUtils“”
    转帖地址：http://www.cnblogs.com/shangxiaofei/p/4313111.html   public static boolean isEmpty(String str)   　　判断某字符串是否为空，为空的标准是 str== null  或 str.length()== 0  
  • 编程之美-分层遍历二叉树 bylijinnan java数据结构算法编程之美
    import java.util.ArrayList; import java.util.LinkedList; import java.util.List; public class LevelTraverseBinaryTree { /** * 编程之美 分层遍历二叉树 * 之前已经用队列实现过二叉树的层次遍历，但这次要求输出换行，因此要
  • jquery取值和ajax提交复习记录 chengxuyuancsdn jquery取值ajax提交
    // 取值 // alert($("input[name='username']").val()); // alert($("input[name='password']").val()); // alert($("input[name='sex']:checked").val()); // alert($("
  • 推荐国产工作流引擎嵌入式公式语法解析器-IK Expression comsci java应用服务器工作Excel嵌入式
    这个开源软件包是国内的一位高手自行研制开发的，正如他所说的一样，我觉得它可以使一个工作流引擎上一个台阶。。。。。。欢迎大家使用，并提出意见和建议。。。 ----------转帖--------------------------------------------------- IK Expression是一个开源的（OpenSource），可扩展的（Extensible），基于java语言
  • 关于系统中使用多个PropertyPlaceholderConfigurer的配置及PropertyOverrideConfigurer daizj spring
    1、PropertyPlaceholderConfigurer Spring中PropertyPlaceholderConfigurer这个类，它是用来解析Java Properties属性文件值，并提供在spring配置期间替换使用属性值。接下来让我们逐渐的深入其配置。 基本的使用方法是：(1) <bean id="propertyConfigurerForWZ&q
  • 二叉树:二叉搜索树 dieslrae 二叉树
        所谓二叉树,就是一个节点最多只能有两个子节点,而二叉搜索树就是一个经典并简单的二叉树.规则是一个节点的左子节点一定比自己小,右子节点一定大于等于自己(当然也可以反过来).在树基本平衡的时候插入,搜索和删除速度都很快,时间复杂度为O(logN).但是,如果插入的是有序的数据,那效率就会变成O(N),在这个时候,树其实变成了一个链表. tree代码:
  • C语言字符串函数大全 dcj3sjt126com cfunction
    C语言字符串函数大全     函数名: stpcpy 功 能: 拷贝一个字符串到另一个 用 法: char *stpcpy(char *destin, char *source); 程序例:   #include <stdio.h> #include <string.h>   int main
  • 友盟统计页面技巧 dcj3sjt126com 技巧
    在基类调用就可以了, 基类ViewController示例代码 -(void)viewWillAppear:(BOOL)animated { [super viewWillAppear:animated]; [MobClick beginLogPageView:[NSString stringWithFormat:@"%@",self.class]];
  • window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法 flyvszhb javajdk
    window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法 本机已经安装了jdk1.7，而比较早期的项目需要依赖jdk1.6，于是同时在本机安装了jdk1.6和jdk1.7. 安装jdk1.6前，执行java -version得到 C:\Users\liuxiang2>java -version java version "1.7.0_21&quo
  • Java在创建子类对象的同时会不会创建父类对象 happyqing java创建子类对象父类对象
      1.在thingking in java 的第四版第六章中明确的说了，子类对象中封装了父类对象，   2."When you create an object of the derived class, it contains within it a subobject of the base class. This subobject is the sam
  • 跟我学spring3 目录贴及电子书下载 jinnianshilongnian spring
        一、《跟我学spring3》电子书下载地址： 《跟我学spring3》  （1-7 和 8-13） http://jinnianshilongnian.iteye.com/blog/pdf     跟我学spring3系列 word原版 下载     二、 源代码下载 最新依
  • 第12章 Ajax（上） onestopweb Ajax
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • BI and EIM 4.0 at a glance blueoxygen BO
    http://www.sap.com/corporate-en/press.epx?PressID=14787   有机会研究下EIM家族的两个新产品~~~~   New features of the 4.0 releases of BI and EIM solutions include: Real-time in-memory computing –
  • Java线程中yield与join方法的区别 tomcat_oracle java
    长期以来，多线程问题颇为受到面试官的青睐。虽然我个人认为我们当中很少有人能真正获得机会开发复杂的多线程应用(在过去的七年中，我得到了一个机会)，但是理解多线程对增加你的信心很有用。之前，我讨论了一个wait()和sleep()方法区别的问题，这一次，我将会讨论join()和yield()方法的区别。坦白的说，实际上我并没有用过其中任何一个方法，所以，如果你感觉有不恰当的地方，请提出讨论。 &nb
  • android Manifest.xml选项 阿尔萨斯 Manifest
    结构 继承关系 public final class Manifest extends Objectjava.lang.Objectandroid.Manifest 内部类 class Manifest.permission权限 class Manifest.permission_group权限组 构造函数 public Manifest () 详细 androi
  • Oracle实现类split函数的方 zhaoshijie oracle
    关键字：Oracle实现类split函数的方 项目里需要保存结构数据，批量传到后他进行保存，为了减小数据量，子集拼装的格式，使用存储过程进行保存。保存的过程中需要对数据解析。但是oracle没有Java中split类似的函数。从网上找了一个，也补全了一下。 CREATE OR REPLACE TYPE t_split_100 IS TABLE OF VARCHAR2(100); cr
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他