精华内容
下载资源
问答
  • Object-C

    千次阅读 2016-04-14 18:23:51
    Classes 像其他的面向对象的语言一样,Object-C也提供创建对象的蓝本,即。首先我们在中定义一些可以重复使用的属性和方法。然后,我们实例化,即对象,之后就可以使用属性和访问。Object-C和C++一样,从...

    Classes 类

    像其他的面向对象的语言一样,Object-C也提供创建对象的蓝本,即类。首先我们在类中定义一些可以重复使用的属性和方法。然后,我们实例化类,即对象,之后就可以使用属性和访问。

    Object-C和C++一样,从类的实现中抽象出了类的接口。接口中定义了类的公开的方法和属性,相应的实现代码,定义方法和属性的具体的实现。这和我们看到的函数,分离关注点是一样的。

    A class’s interface and implementation

    这张我们将学习关于类接口,实现、属性、方法已经实例化的基本语法。我们也会介绍Object-C的内省和反射的功能。

    Creating Classes 创建对象

    我们将定义一个叫Car的类,他的接口在Car.h文件中,他的实现在Car.m 文件中。这些是标准的Object-C的文件扩展名。当其他的类想使用这个类的功能时,需要使用这个类的头文件,而类的实现文件是给编译器使用的。

    xcode 提供方便的创建类的模板。我们可以从 File > New > File …或者Cmd + N 快捷键创建类。在模板中从iOS > Cocoa Touch中选择Object-C类模板。之后,提示您配置一些信息:

    创建类

    在Class 域中填写Car。在subclass of 中选择NSobject。NSObject 类是其他所有Object-C类的父类。点击下一步,提示选择文件存储的位置,选择存储在工程根目录下。在对话框的下面,注意选择您的工程为目标工程。这样是保证文件会被编译。

    点击next后,您会在Xcode的工程导航中看到Car.h文件和Car.m文件。如果您选择工程名称,在编译资源模块中,您会发现在Car.m文件在构建路径中。任何您想让编译器编译的文件都必须在这个类表中。

    Interfaces 接口

    Car.h 文件中包含一些样板代码,从现在开始,我们修改如下,声明一个叫model的变量和一个叫drive的方法。

    // Car.h
    #import <Foundation/Foundation.h>
    
    @interface Car : NSObject {
        // Protected instance variables (not recommended)
    }
    
    @property (copy) NSString *model;
    
    - (void)drive;
    
    @end
    

    通过@interface指令创建接口,后面接着类的名字和父类的名字,中间用冒号隔开。保护类型的变量可以定时在花括号内。大多数开发者喜欢讲实例变量放在.m文件中,而不是头文件中。

    @property 声明一个public 类型的变量,而且通过copy定义内存管理行为。这种情况下,赋值给model变量的值,是一个副本,而不是直接指向值。在属性章节我们将会讨论更多的细节。接下来是属性的数据类型和名字,就像普通的变量声明一样。

    以- (void)开头的行,定义了一个叫drive的函数,没有参数, (void) 部分定义函数的返回值类型。在方法前面的减号,表示一个实例方法,与之相对应的是类方法。

    Implementations 实现

    任何类的实现,第一件事是引入相对应的头文件。 @implementation 和@interface是一样的,除了不需要父类。私有的变量可以定义在类名之后的括号中。

    // Car.m
    #import "Car.h"
    
    @implementation Car {
        // Private instance variables
        double _odometer;
    }
    
    @synthesize model = _model;    // Optional for Xcode 4.4+
    
    - (void)drive {
        NSLog(@"Driving a %@. Vrooooom!", self.model);
    }
    
    @end

    @synthesize 帮助我们为属性产生存取方法(getter和setter方法)。默认,getter方式是属性名(model),setter方法是set前缀加属性名首字符大写,这样比手动写每一个存储器的特征方便。_model 部分定义了属性的私有实例变量名。

    xcode 4.4 之后,用@property声明的属性变量,自动产生存取方法。如果您认为默认的实例变量命名规则可以,您可以省略@synthesize行。

    drive方法的实现和接口中有相同的方法签名,但是在签名之后,有方法调用时执行的代码。我们是通过self.model 获取model的值,而不是通过_model。这是最佳实践,利用了属性的存储方法。只有在init方法和dealloc方法中您才需要直接访问实例变量。

    self 关键是指向方法调用的实例。除了获取属性值,还可以调用方法。在教程中您将看到很多这样的例子。

    Instantiation and Usage 实例化和用法

    任何想访问类的文件,都要引入类的头文件,我们绝对不能直接访问类的实现。这样将违反了,分离实现和接口的目的。所以,为了让我们类生效,如下修改main.m.

    // main.m
    #import <Foundation/Foundation.h>
    #import "Car.h"
    
    int main(int argc, const char * argv[]) {
        @autoreleasepool {
            Car *toyota = [[Car alloc] init];
    
            [toyota setModel:@"Toyota Corolla"];
            NSLog(@"Created a %@", [toyota model]);
    
            toyota.model = @"Toyota Camry";
            NSLog(@"Changed the car to a %@", toyota.model);
    
            [toyota drive];
    
        }
        return 0;
    }
    

    在使用#import执行引入头文件之后,您可以使用alloc/init模式实例化类。正如您所见,实例化分成两个步骤:首先使用alloc方法为对象分配内存,接着初始化对象。你绝对不能使用未初始化的对象。

    再次强调,所有对象都作为指针存储。这也就是为什么我们使用Car *toyota,而不是 Car toyota。

    为了调用Object-C对象的方法,我们将实例名和方法名,放在方括号内,用空格分开。在方法名之后是参数,参数之前是冒号。所以您有C++、java、Python编程背景,[toyota setModel:@”Toyota Corolla”]可以转化成toyota.setModel(“Toyota Corolla”)。

    toyota.setModel("Toyota Corolla");

    方括号的语法可能是您不太习惯,但是我确信,在您阅读网方法章节后,您会非常习惯这种写法。

    这个例子为您展示了两种获取属性的方法。您可以使用存取方法,或者点语法。

    Class Methods and Variables 类方法和变量

    上面的例子定义的实例方法和属性,我们也可以定义类的方法和属性,在其他的语言中称为static方法或者属性。

    类方法的声明和实例方法是一样的,除了在方法之前是加号而不是减号。添加如下的class方法在Car.h文件中:

    // Car.h
    + (void)setDefaultModel:(NSString *)aModel;
    

    同样,在方法的实现之前也添加加号,但是没有类变量,您可以在实现文件中定义static变量模拟。

    // Car.m
    #import "Car.h"
    
    static NSString *_defaultModel;
    
    @implementation Car {
    ...
    
    + (void)setDefaultModel:(NSString *)aModel {
        _defaultModel = [aModel copy];
    }
    
    @end
    

    [aModel copy] 创建了一个参数的副本,而不是直接指向参数。这就是为什么我们在声明model变量时,使用(copy)属性。

    类方法使用和实例方法一样的方括号语法,但是他必须直接从类调动,不能在实例上调用。[toyota setDefaultModel:@”Model T”]将会报错。

    // main.m
    [Car setDefaultModel:@"Nissan Versa"];
    

    “Constructor” Methods 构造方法

    在Object-C中没有构造方法。然而,对象的初始化是通过init方法,在对象内存分配完成之后。这也就是为什么对象实例化分两步:分配内存和初始化。有一个类的初始化方法,等会我们会讨论。

    init是默认的初始化方法。您也可以自定义您自己的初始化方法。自定义的初始化方法,没有什么特殊的,和其他的实例方法一样。

    // Car.h
    - (id)initWithModel:(NSString *)aModel;

    为了实现这个方法,我们要遵守初始化方法的命名规范,像initWithModel。super关键字指向它的父类,self指向方法调用的对象。添加如下代码到Car.m

    // Car.m
    - (id)initWithModel:(NSString *)aModel {
        self = [super init];
        if (self) {
            // Any custom setup work goes here
            _model = [aModel copy];
            _odometer = 0;
        }
        return self;
    }
    
    - (id)init {
        // Forward to the "designated" initialization method
        return [self initWithModel:_defaultModel];
    }

    初始化方法总是返回对象自己的引用。如果不能初始化,返回nil.这也就是为什么我们在使用之前,总是检测他是否存在。但是总是只有一个初始化方法做这件事。其他的初始化方法,调用这个指定的初始化方法。这样当你定义多个初始化方法的时候,就省去了一些模板代码。

    注意,我们在initWithModel方法中直接给_model和_odometer赋值,也只有这一个地方可以这样,其他的地方,需要使用self.model和self.odometer.

    Class-Level Initialization 类-初始化方法

    类级别的初始化方法和init方法一样。我们可以在这里初始化类,在其他地方使用它之前。例如我们赋值_defaultModel。例如:

    // Car.m
    + (void)initialize {
        if (self == [Car class]) {
            // Makes sure this isn't executed more than once
            _defaultModel = @"Nissan Versa";
        }
    }

    类的初始化方法,在类使用之前,只能被调用一次。这就包括他所有的子类。最佳实践是我们使用self == [Car class]确认初始化方法已经执行了。注意,在类方法中,self关键字,指向类自己,而不是实例。

    Object-C不强制您标示重写方法。

    接下来我们看看自定义初始化方法的执行情况。在类第一次被使用的时候,会执行[Car initialize]方法,即将_defaultModel赋值@”Nissan Versa”。这个可以在第一个NSLog中看到。第二个自定义方法initWithModel输出结果可以在第二个输出中看到。

    // main.m
    #import <Foundation/Foundation.h>
    #import "Car.h"
    
    int main(int argc, const char * argv[]) {
        @autoreleasepool {
    
            // Instantiating objects
            Car *nissan = [[Car alloc] init];
            NSLog(@"Created a %@", [nissan model]);
    
            Car *chevy = [[Car alloc] initWithModel:@"Chevy Corvette"];
            NSLog(@"Created a %@, too.", chevy.model);
    
        }
        return 0;
    }

    Dynamic Typing 动态类型

    类可以被一个对象表示,即类对象,这样我们就可以方法他们的属性。而且可以在执行时改变类的行为,增加或者修改方法。这是非常厉害的动态类型能力。这样您可以在不知道当前对象是什么类型,也可以调用方法和设置属性。

    最简单的获取类方法的方式是调用类方法。例如,[Car class]返回一个表示类的对象。您可以将此对象传递给isMemberOfClass: 和 isKindOfClass:方法获取其他对象的信息。

    // main.m
    #import <Foundation/Foundation.h>
    #import "Car.h"
    
    int main(int argc, const char * argv[]) {
        @autoreleasepool {
            Car *delorean = [[Car alloc] initWithModel:@"DeLorean"];
    
            // Get the class of an object
            NSLog(@"%@ is an instance of the %@ class",
                  [delorean model], [delorean class]);
    
            // Check an object against a class and all subclasses
            if ([delorean isKindOfClass:[NSObject class]]) {
                NSLog(@"%@ is an instance of NSObject or one "
                      "of its subclasses",
                      [delorean model]);
            } else {
                NSLog(@"%@ is not an instance of NSObject or "
                      "one of its subclasses",
                      [delorean model]);
            }
    
            // Check an object against a class, but not its subclasses
            if ([delorean isMemberOfClass:[NSObject class]]) {
                NSLog(@"%@ is a instance of NSObject",
                      [delorean model]);
            } else {
                NSLog(@"%@ is not an instance of NSObject",
                      [delorean model]);
            }
    
            // Convert between strings and classes
            if (NSClassFromString(@"Car") == [Car class]) {
                NSLog(@"I can convert between strings and classes!");
            }
        }
        return 0;
    }
    

    NSClassFromString() 是另一种获取类对象的方法。这样可以使您在运行时获取类对象。然而不是高效的。所以最好使用类方法获取类对象。

    如果您对动态类型感兴趣,您可以查看Slectors和id类型的相关内容

    Summary

    这个模块我们学习了创建类、初始化对象、定义初始化方法、调动类方法和变量。了解了一点关于动态类型的知识。

    Object不支持命名空间,所以Cocoa中的函数有NS、CA、AV这样的前缀,避免冲突。这个对类也是一样的。我me你建议对于特定项目的类,命名使用三个字母的前缀,例如,XYZCar。

    当然我们忽略了一些重要的细节。不用担心,如果您对属性和方法还不是很清楚。下一章我我们将近不这些漏洞,我们近距离观察 @property 指令和影响他行为的属性。

    展开全文
  • # 定义一个Person class Person(object): """人类""" def __init__(self, name , age): self.name = name self.age = age p = Person(‘小黑‘,18) print(p) print(‘\n\n\n\n\n‘) # 定义一个Person class ...
  • Object C Dictionary字典

    千次阅读 2015-10-13 12:39:44
    的确如此,在Object C中提供了两个字典,分别为NSDictionary 和 NSMutableDictionary. 在.NET中我们也学习过Dictionary,这个集合的存储方式是键值对的方式存储的。而且使用Dictionary查找元素也极为简单。   ...

     通过Array数组和Set集合的学习和理解,可以想象得到Dictionary也分为两种情况了,那就是可变和不可变两种类型的。的确如此,在Object C中提供了两个字典类,分别为NSDictionary 和 NSMutableDictionary. 在.NET中我们也学习过Dictionary类,这个集合的存储方式是键值对的方式存储的。而且使用Dictionary查找元素也极为简单。

     

      一 NSDictionary 不可变字典

        (1) 初始化字典

    复制代码
    NSDictionary *dic=[NSDictionary dictionaryWithObject:@"hechen" forKey:@"name"];
            NSDictionary *dic1=[NSDictionary dictionaryWithObjectsAndKeys:@"hechen",@"name",@"25",@"age", nil];
            NSDictionary *dic2=[[NSDictionary alloc] init];
            
            NSLog(@"%d",[dic count]);
            NSLog(@"%d",[dic1 count]);
            NSLog(@"%d",[dic2 count]);
            
    复制代码

        上面列举了三种方式来初始化字典对象:

        1. [[NSDictionary alloc] init] 方法最为常见了,先给NSDictionary分配空间再初始化,这也是大众的方式;

        2. 使用dictionaryWithObject forkey 该方法在初始化的时候提供了两个参数,第一个为存储的值,第二个为key,这个和我们平时在.NET中有点不一样的,这里的key是放在后面的。

        3. 使用dictionaryWithObjectsAndKeys 这个方法同样用于初始化NSDictionary,这里可以传入多个值,奇数为value值,偶数为key值,但是必须以nil形式结尾。这个和之前的NSArray,NSSet一致,标识集合的结束。

        (2)获得NSDictionary的长度

        NSDictionary的长度使用方法count方法来获得,这个和大多数集合一样

    复制代码
    NSDictionary *dic=[NSDictionary dictionaryWithObject:@"hechen" forKey:@"name"];
            NSDictionary *dic1=[NSDictionary dictionaryWithObjectsAndKeys:@"hechen",@"name",@"25",@"age", nil];
            NSDictionary *dic2=[[NSDictionary alloc] init];
            
            NSLog(@"%d",[dic count]);
            NSLog(@"%d",[dic1 count]);
            NSLog(@"%d",[dic2 count]);
            
    复制代码

        以上代码中获得了三个NSDictionary的长度,分别输出的结果为1,2,0;这里也刚好说明了上面三种方式初始化的不同之处。

        (3)获得NSDictionary中Keys的迭代

    复制代码
    NSEnumerator *enumer=[dic1 keyEnumerator];
            NSString *key2=[enumer nextObject];
            while(key2!=nil){
                NSLog(@"输出Key=%@",key2);
                key2=[enumer nextObject];
            }
    复制代码

        以上代码可以看得出来使用keyEnumerator 方法获取NSDictionary Key的集合迭代,然后使用迭代器遍历输出所有的元素。

        (4)获取NSDictionary中的Values的迭代

    NSEnumerator *enumerObject=[dic1 objectEnumerator];
            for(NSObject *object in enumerObject){
                NSLog(@"输出Value = %@",object);
            }

        获取Value的方法和获取key的方法基本类似,这里在循环遍历的时候有些不同,但是两者的结果是一样的,可以稍微注意一下

        (5)根据Key获取Value

    NSString *va=[dic1 objectForKey:@"name"];
            NSLog(@"objectForKey = %@",va);

        在Object C通过key获取Value要使用方法objectForKey,在上面的案例中已经简单而且明确的展示了其用法。

     

      二. NSMutableDictionary 动态字典

        NSMutableDictionary 是NSDictionary的子类,继承了其所有的方法和属性。但是和NSDictionary有着一定的区别就是NSMutableDictionary可以动态的修改和增加删除里面的元素。

        (1) dictionaryWithCapacity方法设置其初始容量

    NSMutableDictionary *muDic1=[NSMutableDictionary dictionaryWithCapacity:10];

        上面的代码中初始化了一个NSMutableDictionary对象,并且设置其初始容量为10; 和NSMutableArray,NSMutableSet一样,当存储的元素达到最大容量之后会自动扩充容量,所以不用担心数组越界。

        (2) 往NSMutableDictionary中添加元素

    复制代码
    [muDic1 setObject:@"中国" forKey:@"name"];
            [muDic1 setObject:@"area" forKey:@"add"];
            NSEnumerator *enumerKeys=[muDic1 keyEnumerator];
            for(NSString *key in enumerKeys){
                NSString *value=[muDic1 objectForKey:key];
                NSLog(@"输出的值 = %@",value);
            }
    复制代码

        从以上代码可以看到使用 setObject forKey 方法可以往字典中添加元素, 方法的前一个参数为value,后一个参数为key。使用循环可以得到相应的值。

        (3) 删除字典中的元素

    [muDic1 removeObjectForKey:@"add"];
            for(NSString *key in [muDic1 keyEnumerator]){
                NSLog(@"-----%@",[muDic1 objectForKey:key]);
            }

        以上代码是根据一个key值来删除NSMutableDictionary中的元素,所使用的方法为removeObjectForKey,在NSMutableDictionary中还提供了根据多个key值删除的元素的方法。

        - (void)removeObjectsForKeys:(NSArray *)keyArray;这个方法参数为一个数组,用于删除数组中包含的key的所有元素。

    复制代码
    [muDic1 removeObjectsForKeys:[NSArray arrayWithObjects:@"ab", nil]];
    
    [muDic1 removeAllObjects];
    
    for(NSString *key in [muDic1 keyEnumerator]){
        NSLog(@"*********%@",[muDic1 objectForKey:key]);
    }
    复制代码

        上面第一句代码用于从数组中删除包含的元素,而第二句则用于删除NSMutableDictionary中的所有元素。最终没有任何结果输出。

     

    展开全文
  • Object C基础语法

    千次阅读 2018-05-29 21:31:02
    Object C基础语法 1.关键字  基本上所有关键字都是以@开头  @interface @implementation @end  @public @protected @private @selector  @try @catch @throw @finally  @protecal @optionl @required @class  ...

    Object C基础语法

    1.关键字

       基本上所有关键字都是以@开头

       @interface @implementation @end

       @public @protected @private @selector

       @try @catch  @throw @finally

       @protecal @optionl @required @class

       @property @synthesize @dynamic

       self super id cmd  _block _strong _week

    2.字符串以@开头

      比如@"hello“是oc中的字符串,而“Hello"则是c语言中的字符串

     3.其它语法

       基本数据类型 char int float double BOOL(YES\NO)

       nil 相当于c语言NULL,也就是0

       基本语句 循环语句(do while,while,for),条件语句(if  if-else,switch)

       注释 //和/*....*/

        屏幕输出NSLog(@"Hello");NsLog(@“age is %i",29);

    面向对象

    #import <Foundation/Foundation.h>
    @interface Car :NSObject{
        int wheels;
        int speed;
    }
    @end
    
    //类的实现
    @implementation Car
    
    @end
    
    
    int main()
    {
        //使用new来创建对象
        [Car new];
        return 0;
    }

    方法:
    #import <Foundation/Foundation.h>
    @interface Car :NSObject{
        //@public 让外部指针直接访问对象内的成员变量
        @public
        int wheels;
        int speed;
        // oc方法中任何类型都必须用小括号()括注
        // oc方法中的小括号():括注数据类型
      
    }
    - (void)run;
    @end
    
    //类的实现
    @implementation Car
    - (void)run
    {
        NSLog(@"跑起来了");
    }
    @end
    
    
    int main()
    {
        //使用new来创建对象
        Car *p=[Car new];
        //给p指向的对象赋值
        p->wheels=4;
        [p run];
        NSLog(@"wheels:%d",p->wheels);
        return 0;
    }


    bogon:ios asange$ cc -c class.m

    bogon:ios asange$ cc class.o -framework Foundation

    bogon:ios asange$ ./a.out

    2017-06-14 13:09:32.180 a.out[3402:448299] 跑起来了

    2017-06-14 13:09:32.180 a.out[3402:448299] wheels:4

    bogon:ios asange$ 


    匿名对象


    #import <Foundation/foundation.h>
    @interface Car:NSObject
    {
        @public
        int speed;
    }
    - (void) run;
    @end
    
    @implementation Car
    - (void) run{
        NSLog(@"跑起来啦....");
    }
    @end
    
    int main()
    {
        [Car new]->speed=300;
        [[Car new] run];
        return 0;
    }

    运行结果:

    bogon:ios asange$ cc -c test5.m
    bogon:ios asange$ cc test5.o -framework Foundation
    bogon:ios asange$ ./a.out
    2017-06-20 12:17:41.712 a.out[15692:2446756] 跑起来啦....
    bogon:ios asange$ 


    类方法 
    以+ 开头
    #import <Foundation/foundation.h>
    @interface Person : NSObject
        + (void)print;
    @end
    
    @implementation Person
     + (void)print
    {
        NSLog(@"这是类方法");
    }
    @end
    
    int main()
    {
        [Person print];
        return 0;
    }

    运行结果:
    bogon:ios asange$ cc -c test7.m
    bogon:ios asange$ cc test7.o -framework Foundation
    bogon:ios asange$ ./a.out
    2017-06-21 18:12:53.393 a.out[8105:1320528] 这是类方法
    bogon:ios asange$ 
    

    继承结构:
    #import <Foundation/Foundation.h>
    @interface Person : NSObject
    {
        @public
        int name;
    }
    - (void)say;
    @end
    
    @implementation Person
    - (void)say{
        NSLog(@"im saying");
    }
    @end
    
    @interface User : Person
    
    @end
    
    @implementation User
    
    @end
    
    int main()
    {
        User *u=[User new];
        [u say];
        return 0;
    }

    运行结果:

    bogon:ios asange$ cc -c test8.m

    bogon:ios asange$ cc test8.o -framework Foundation

    bogon:ios asange$ ./a.out

    2017-06-22 23:53:53.204 a.out[15664:2162356] im saying

    bogon:ios asange$ 



    Nstring 的用法

    占位符号 ”%@“

     

    #import <Foundation/Foundation.h>
    int main()
    {
        NSString *str=@"hhh";
        char *name="你好";
        NSLog(@"我在吃饭,%@",str);
        return 0;
    }

    运行结果:

    ios icourt$cc nstring.m -framework Foundation

    ios icourt$./a.out

    2017-07-12 21:55:59.435 a.out[35531:4095080] 我在吃饭,hhh

    ios icourt$


    #import <Foundation/Foundation.h>
    int main()
    {
        NSString *str=@"hhh";
        char *name="你好";
        NSLog(@"我在吃饭,%@",str);
        
        int length=[str length];//计算字符串的长度
        NSLog(@"字符串长度:%d",length);
        
        NSString *newStr=[NSString stringWithFormat:@"my age is %d",28];
        NSLog(@"-----%@",newStr);
        return 0;
    }

    ios icourt$cc nstring.m -framework Foundation

    ios icourt$./a.out

    2017-07-12 22:11:43.491 a.out[36121:4115883] 我在吃饭,hhh

    2017-07-12 22:11:43.491 a.out[36121:4115883] 字符串长度:3

    2017-07-12 22:11:43.492 a.out[36121:4115883] -----my age is 28

    ios icourt$


    @property的作用: 生产get set方法

    @synthesize 自动生成get set 并且会访问这个带下滑线的变量 如:@synthesize  age 访问的是_age变量

    id 万能指针 指向任何oc对象 等同于NSObject


    构造方法 模版

    - (id)init

       if(self=[super init])

    {   

         self.age=10;
    }

    return self;

    }


    NSObject 默认description方法 返回的类名+内存地址 . 跟java类似 

    NSString的简单用法

      NSString *str=@"hello";

        NSLog(@"开始吧,%@",str);

       NSString *na=[NSString stringWithFormat:@"hello:%@",@"xx"];

        NSLog(na);

     //字符转换成字串
        char *c="yes";
        NSString *string= [NSString stringWithUTF8String:c];
        NSLog(@"字符转字符串%@",string);
        
        //字符串转换成字符
        char *c2=[string UTF8String];
        NSLog(@"字符串转字符%s",c2);



    展开全文
  • 一、Object 1、equals 方法 2、toString 方法 二、String 1、字符串定义方式: 2、String 常用构造方法 3、String 的字符串的长度 4、String 其他方法 三、StringBuffer 1、StringBuffer ...

    目录

    一、Object 类

    1、equals 方法

    2、toString 方法

    二、String 类

    1、字符串定义方式:

    2、String 类常用构造方法

    3、String 类的字符串的长度

    4、String 类其他方法

    三、StringBuffer 类

    1、StringBuffer 常用方法使用

    四、StringBuilder 类


    一、Object 类

    Object类是Java中的根类,是所有类的父类,Object类中所有方法子类都可以使用。在Object类中有很多方法,这里讲述 equals方法和toString方法。

    1、equals 方法

    • 用于比较两个对象是否相同
    • 实际是使用两个对象的内存地址进行比较
    • equals 方法内部使用的是 == 比较运算符
    • 源码分析:
      public boolean equals(Object obj){
          return (this == obj);
      }

      源码中,equals 方法传入 Object 类,由于 Object 类是所有类的父类,所以任何参数都能传入,返回值中 “==” 表示比较对象内存的地址,由于对象都是 new出来的,所以地址肯定不同,返回值为 false。在实际开发中,比较地址是没有什么实际意义的,往往需要重写 equals 方法,用来比较成员变量。

    • 实例分析:
      //创建Person类继承Object类
      public class Person extends Object {
          private int age;
          private String name;
      
          //带参构造方法
          public Person(String name,int age){
              this.age = age;
              this.name = name;
          }
      
          //重写父类的代码
          public boolean equals(Object obj)
          {
              //进行非空判断
              if(obj == null)
              {
                  return false;
              }
              //和自己比较
              if(this == obj)
              {
                  return true;
              }
              //判断是否是同一类
              if(obj instanceof Person)
              {
                  Person p = (Person)obj;     //需要对obj进行向下转型
                  return this.age == p.age;
              }
              return false;
          }
      }
      //在main中进行调用
      public static void main(String[] args)
      {
          Person p1 = new Person("Tom",18);    //创建对象p1
          Person p2 = new Person("Tim",18);    //创建对象p2
          boolean b = p1.equals(p2);    //调用重写的equals方法比较p1和p2的成员
          System.out.println(b);    //返回true
      }

      注意事项:
      (1) 使用 equals(Object obj) 传递参数时,实际上是隐藏了多态的向上转型:Object obj = p2,将 p2 子类型提升为 Object 父类型,因此不能直接调用子类特有成员,需要对obj参数进行类型的向下转型:Person p = (Person)obj;
      (2) 为了防止不同类进行比较,需要对参数是否同类进行判断
      (3) 为了防止空参数传入,需要进行非空判断
      (4) 为了防止和自己进行比较,需要对自己进行判断

    2、toString 方法

    • 源码分析:
      public String toString() {
          return getClass().getName() + "@" + Integer.toHexString(hashCode());
      }

       

    • 用于返回该对象的字符串表示
    • 该方法返回一个字符串,该字符串由类名(对象是该类的一个实例)、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说,该方法返回一个字符串,它的值等于:getClass()+'@'+Interger.toHexString(hashCode())
    • 由于 toString 方法返回的是结果的内存地址,在实际开发中,往往需要按照对象的属性得到响应的字符串表象形式,所以需要重写toString 方法
    • 实例分析:
      //创建Person类继承Object类(这里省略了set、get方法)
      public class Person extends Object {
          private String name;
          private int age;
          //重写Object类中的toString方法
          public String toString()
          {
              return name + age;
          }
      }
      //在main中调用
      public static void main(String[] args)
      {
          Person p1 = new Person("Tom",18);    //创建p1对象
          System.out.println(p1);    //输出一个语句,写的是一个对象,则默认调用的是toString方法
      }
      注意事项:
      (1) 重写 Object 类中的 toString 方法,让其返回成员信息
      (2) 在输出语句中,直接写入一个对象,会默认调用 toString 方法

    二、String 类

    String 类代表字符串,Java程序中所有字符串字面值都作为此类的实例实现。字符串是常量,一旦创建就不能改变,字符串本身是不能改变的,但存放字符串的地址可以改变,引用变量指向的内存可以改变。

    1、字符串定义方式:

    String str1 = "qwer";
    String str2 = new String("qwer");
    System.out.println(str1 == str2);    //false
    System.out.println(str1.equals(str2));    //true
    • String str1 = "qwer";    ===>在内存中只有一个对象,这个对象在字符串常量池中
    • String str2 = new String("qwer");    ===>在内存中有两个对象,一个对象是在堆中的new String(),另一个对象是字符串 “qwer”本身对象,在字符串常量池中
    • str1 == str2 为 false 是因为引用类型比较的是地址,肯定不同
    • str1.equals(str2) 为 true 是因为String类将equals方法进行了重写,建立了字符串自己的判断依据,通过字符串对象中的字符来判断

    2、String 类常用构造方法

    • String(byte[] bytes):将字节数组中的每个字节,通过查询编码表后得到的结果,默认编码表一个汉字采用两个字节表示
    • String(byte[] bytes,int offset,int length):将字节数组的一部分转成字符串
    • String(char[] value):将字符数组转成字符串
    • String(char[] value,int offset,int count):将字符数组的一部分转换成字符串
    • 代码实例:
      public static void main(String[] args)
      {
          //String(byte[] bytes)
          byte[] bytes = {97,98,99,100};
          String str = new String(bytes); //调用String类构造方法,传递字节数组
          System.out.println(str);    //将字节数组中的每个字节,通过查询编码后得到结果
      
          //String(byte[] bytes,int offset,int length)
          byte[] bytes1 = {97,98,99,100};
          String str1 = new String(bytes1,1,2);
          System.out.println(str1);   //将字节数组的一部分转换成字符串
      
          //String(char[] value)
          char[] ch = {'a','b','c','d'};
          String str2 = new String(ch);   //将字符数组转换成字符串
          System.out.println(str2);
      
          //String(char[] value,int offset,int count)
          char[] ch2 = {'a','b','c','d'};
          String str3 = new String(ch2,1,2);   //将字符数组的一部分转换成字符串
          System.out.println(str3); 
      }

       

    3、String 类的字符串的长度

    • str.length():返回str字符串长度
    • str.substring(int beginIndex):返回一个新字符串,内容为指定位置开始到字符串末尾的所有字符
    • str.substring(int beginIndex,int endIndex):返回一个新字符串,内容为指定位置开始到指定位置结束所有字符
    • 逻辑实例:
      String str = "abcdef";
      int len = str.length();    //返回字符串长度
      String s1 = str.substring(1); //返回一个新字符串,内容为指定位置开始到字符串末尾的所有字符
      String s2 = str.substring(2, 4);//返回一个新字符串,内容为指定位置开始到指定位置结束所有字符
      

    4、String 类其他方法

    • int indexOf(int ch ) :在给定字符串中查找字符(ASCII),找到返回字符数组所对应的下标找不到返回-1
    • int indexOf(int ch,int fromIndex):从指定的下标开始查找某个字符,查找到返回下标,查找不到返回-1
    • int indexOf(String str): 在给定符串中查找另一个字符串
    • int indexPf(String str,int fromlndex):从指定的下标开始查找某个字符串
    • byte[] getBytes() 把该字符串 转换成 字节数组
    • char[] toCharArray() 把该字符串 转换成 字符数组
    • String replace(char old,char new) 在该字符串中,将给定的旧字符,用新字符替换
    • String replace(String old,String new) 在该字符串中, 将给定的旧字符串,用新字符串替换
    • String trim() 去除字符串两端空格,中间的不会去除,返回一个新字符串
    • String toLowerCase() 把该字符串转换成 小写字符串
    • String toUpperCase() 把该字符串转换成 大写字符串

    三、StringBuffer 类

    StringBuffer 又称为可变字符序列,它是类似于 String 的字符串缓冲区,通过某些方法调用可以改变的该序列的长度和内容。其实StringBuffer是一个字符串的缓冲区,就是个容器,容器中可以装很多个字符串,并且能够对其中的字符串进行各种操作。

    1、StringBuffer 常用方法使用

    • append(String str):将制定字符串追加到此字符序列
    • delete(int star,int end):移除指定字符串
    • insert(int offset,String str):在指定位置插入
    • replace(int star,int end,String str):替换指定范围的内容
    • reverse():将字符序列反转
    • toString():返回此序列中数据的字符串表示形式
    • substring(int star,int end):从指定位置开始到指定位置结束,截取该字符串缓冲区,返回新字符串
    • 逻辑实例:
      //创建一个字符串缓冲区对象,用于存储数据
      StringBuffer sb = new StringBuffer();
      sb.append("qwert");    //添加字符串
      sb.insert(2,"as");    //在指定位置插入
      sb.delete(1,4);    //删除
      sb.replace(1,4,"dfs");    //替换指定范围内的内容
      String str = sb.toString();    //返回此序列中数据的字符串表示形式

      注:append、delete、insert、replace、reverse方法调用后,返回值都是当前对象自己,所以 StringBuffer 字符序列的长度和内容

    四、StringBuilder 类

    StringBuilder 类是字符串缓冲区,是一个可变的字符序列,该类被设计用作 StringBuffer 的一个简易替换,用在字符串缓冲区被单个线程使用的时候。如果可能,建议优先采用该类,因为大多数实现中,它比 StringBuffer 要快

     

    展开全文
  • python中输出的实例输出为何是<__main__类名 object at xxxx>这种形式? 原因:__str__()这个特殊方法将对象转换为字符串的结果  效果图:  代码:  # 定义一个Person ...
  • NSLog格式化输出数据——ObjectC

    千次阅读 2014-12-02 09:17:29
    本文转自:点击打开链接  1 . 几种常用类型变量声明  int i =10;  BOOL isShow=YES;   BOOL isShow=1;   float f = 3.1415926;  char a =120;... object-c
  • Java的常用—StringObject类

    千次阅读 2018-08-06 23:21:47
    Object类,作为Java中所有的父类,即使不常直接使用,也会经常使用到其中的方法。下面就讲一讲这两个常用的基本操作。  String:可以将字符串常量、变量赋值给String。其中值得注意的一点是,String...
  • 先上图: 输出语句:  NSLog(@"%@",var); 补充说明: NSString 类型(字符串) %@ Bool 类型 %i Bool类型值默认为False,即0,为True时输出为1。 Float 类型 %f %0.2f 只保留两位小数
  • 本文对java的ClassObject类的概念和原理做了详尽的介绍,并且详细介绍了Object的各种方法,以及这两个之间的关系。 ClassObject类是Java中最根本最重要的两个,理解它们是理解Java面向对象技术的基础,...
  • Object类介绍

    千次阅读 2018-10-16 18:25:49
     Object类在JAVA里面是一个比较特殊的,JAVA只支持单继承,子类只能从一个父类来继承,如果父类又是从另外一个父类继承过来,那他也只能有一个父类,父类再有父类,那也只能有一个,JAVA为了组织这个组织得比较...
  • Object-C,数组NSArray

    千次阅读 2015-12-01 21:24:34
    晚上回来,写了2个iOS应用程序。 就是在界面中,展示标签。一种是手动构造界面,然后... Object-C相对简单一些,黑屏控制台输出,而iOS可视化界面的程序,代码较多,也不好描述。 iOS程序的“上下文环境”更复杂一
  • 在开发时,需要打印相关的日志,帮助...Object C中利用NSLog打印相关日志信息,在这里我只事记录一些简单的内容。 NSLog的定义 NSLog定义在NSObjCRuntime.h中,如下所示: void NSLog(NSString *format, …);
  • 【含答案】第三章 的重用--3.2-Object (1)单选题 关于Object类,下面说法正确的是 A equals方法可以比较两个对象的属性值是否相等 B 如果两个对象同一,那么它们不一定相等 C 如果两个对象相等,那么它们...
  • 面向对象之Object-所有的基类

    千次阅读 2018-07-22 13:00:58
    一、Object类  我们一般所创建的都是Object的子类,所有的都是继承Object类的. Object类在JAVA里面是一个比较特殊的,JAVA只支持单继承,子类只能从一个父类来继承,如果父类又是从另外一个父类继承过来,...
  • Mac OS objectc关于代码模拟键盘输入

    千次阅读 2017-01-17 14:16:41
    最近因为公司项目需要,需要做个模拟键盘输入软件来作为一个第三方的软件来控制另外一个软件,找了很多资料,终于解决了,至此把我遇到的问题贴出来。 1.单个键盘输入: ...CGEventRef push = ...
  • C#中的object类深入理解

    万次阅读 2011-08-11 11:36:33
    C#中所有的都直接或间接继承自System.Object类,这使得C#中的得以单根继承。如果我们没有明确指定继承,编译器缺省认为该继承自System.Object类。System.Object类也可用小写的object关键字表示,两者完全...
  • 比如最常用的NSMutableArray, NSMutableDictionary等, 这集合在调用读写方法时并不是线程安全的,也就是说会出现数据不一致性和崩溃现象. 2. 解决办法就是使用@syncronized()关键字, 有点类似Java.
  • object类的基本方法

    千次阅读 2017-06-21 14:52:38
    getClass(), hashCode(), equals(), clone...Object类是Java中其他所有的祖先,没有Object类Java面向对象无从谈起。作为其他所有的基类,Object具有哪些属性和行为,是Java语言设计背后的思维体现。 Object类位于
  • Java 重写Object类的常见方法

    千次阅读 2013-09-19 23:18:23
    当我们写一个的时候,都会对Java.lang.Object类的一些重要方法进行重写,这些方法包含:hashCode(),toString(),equals(),finalize(),clone(),wait(),notify()/notifyAll() 这八个方法。 一 Equals()方法: 1....
  • 如何输出类的非静态成员函数地址

    千次阅读 2012-01-16 15:44:41
    首先我们定义一个Ctest,里面包含三个不同形式的成员函数,静态成员函数statFunc()、动态成员函数dynFunc()和虚拟函数virtFunc()。在main函数中我们利用cout标准输出流分别输出这三个函数的地址,程序如下所示:...
  • IOS开发笔记10-Object-C中的对象

    万次阅读 2016-12-08 08:00:53
    前言关于c语言的基础部分已经记录完毕,接下来就是学习Object-C了,编写oc程序需要使用Foundation框架。下面就是对oc中的对象介绍。对象对象和结构类似,一个对象可以保存多个相关的数据。在结构中,我们称这些
  • Object-C 介绍

    千次阅读 2016-04-10 13:34:44
    介绍Object-C 是一个为苹果IOS 和OS X系统编写程序的语言。它能够编译和构建命令行功能、GUI、领域框架的通用语言。他也提供了很多的功能帮助维护复杂的应用。 像C++一样,Object-C也是在C语言的基础上添加了面向...
  • Object-C数据类型

    千次阅读 2015-10-13 15:13:46
    oc基本数据类型,输出限定词
  • Object类中的registerNatives方法的作用深入介绍

    千次阅读 多人点赞 2019-06-06 19:03:18
    一直以来,对Object类中的registerNatives()方法感到十分好奇,想知道它的作用到底是什么。但查阅了不少博客,目前还没找到全面彻底且浅显易懂地介绍该方法作用的博客。于是就有了写本文的想法。本文不会直接给出...
  • C++调用Object-C

    千次阅读 2017-08-18 10:16:54
    2017-08-17 20:46:29.513 test[11267:1497093] This is object-c msg 使用限制 OC++ 没有为OC增加C++的功能,也没有为C++增加OC的功能。例如,不能用OC语法调用C++对象,也不能为OC对象增加构造...
  • Object类之equals方法

    千次阅读 2016-07-05 21:56:21
    class Cat {  int color;  int height;  int weight;  public boolean equals(Object obj)  {  if(obj == null)  return false;  else  {  
  • object-c中如果想要包含头文件用#import(就像c中的#include)如果想要导入部分或者整个框架的话,可以导入框架的“umberlla”头文件,它的名字和框架的名字一样,但并不是独立的,格式如下: #...
  • 前言 这里介绍的是一些基础,比较...Object类 是所有的根 方法 toString(): 1)Object类中的toString打印格式为全限定名@hashCode。 注:全限定名=包名+类名,包名与类名使用点号连接,用来唯一标识一个

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 521,788
精华内容 208,715
关键字:

objectc输出类