精华内容
下载资源
问答
  • Java匿名对象

    2020-04-18 09:18:24
    Java匿名对象一、匿名对象 虽然是创建对象的简化写法,但是应用场景非常有限。...因为没有对该对象进行引用,所以匿名对象一旦使用完,就会被垃圾回收期器回收 匿名对象:没有变量名的对象。 语法格式: new 类名(...

    Java匿名对象一、匿名对象

    虽然是创建对象的简化写法,但是应用场景非常有限。
    创建匿名对象时,只有创建对象的语句,却没有把对象地址赋值给某个变量。
    创建匿名对象时,会在堆区中给对象分配内存空间,但是却没有在栈区中添加一个首地址的引用,即没有在栈中分配地址指向堆区。
    因为没有对该对象进行引用,所以匿名对象一旦使用完后,就会被垃圾回收期器回收
    匿名对象:没有变量名的对象。

    语法格式:

    new 类名(参数列表)

    二、应用场景

    1、创建匿名对象直接调用方法,没有变量名    
    Demo:

    new Scanner(System.in);
    

    2、一旦调用两次方法,就是创建了两个对象,造成浪费。    
    Demo:

    new Scanner(System.in).nextInt();
    new Scanner(System.in).nextInt();
    

    注意:一个匿名对象,只能使用一次。

    3、匿名对象可以作为方法的参数和返回值
    作为参数:

    1 class Test {
    2 public static void main(String[] args) {
    3 // 普通方式 4 Scanner sc = new Scanner(System.in);
    5 input(sc);
    6 //匿名对象作为方法接收的参数 7 input(new Scanner(System.in));
    8 }
    9 public static void input(Scanner sc){
    10 System.out.println(sc);
    11 }
    12 }
    

    作为返回值:

    1 class Test2 {
    2 public static void main(String[] args) {
    3 // 普通方式 4 Scanner sc = getScanner();
    5 }
    6 public static Scanner getScanner(){
    7 //普通方式
    8 //Scanner sc = new Scanner(System.in);
    9 //return sc;
    10 //匿名对象作为方法返回值11 return new Scanner(System.in);
    12 }
    13 }
    
    展开全文
  • 这意味着,即使应用针对新创建的block对象保留了强引用类型的指针,一旦创建对象的方法返回,新创建的block对象也会被立即释放。为了在声明block对象的方法返回仍然保留该对象,必须向其发送copy消息。拷贝某个...

    系统对block对象和其他对象的内存管理方式不同,block对象是在栈中创建的,而其他对象是在堆中创建的。这意味着,即使应用针对新创建的block对象保留了强引用类型的指针,一旦创建该对象的方法返回,新创建的block对象也会被立即释放。为了在声明block对象的方法返回后仍然保留该对象,必须向其发送copy消息。拷贝某个block对象时,应用会在堆中创建该对象的备份。

    展开全文
  • 1、对象在内存中的存储 ...当程序启动时,会加载项目中所有的类和分类,...当第一次使用某个创建对象的时候,就会调用当前类的+initialize方法,也就是初始化对象,使创建出来的对象可以使用。 对象在内存

    1、对象在内存中的存储


    类加载:

    当程序启动时,会加载项目中所有的类和分类,而且加载后会调用每个类和分类的+load方法,而且只会调用一次。并且类一旦加载到内存,就不会被回收,直到程序结束的时候才会被回收。这个过程就叫做类加载。

    当第一次使用某个类创建对象的时候,就会调用当前类的+initialize方法,也就是初始化对象,使创建出来的对象可以使用。

    对象在内存之中是如何存储的呢?我们这里的p指针是在函数中声明的,那么p就是一个局部指针变量,也就是p变量存储在栈空间中。比如:

    int main(){
        Person *p = [Person new];
        return 0;
    }

    new做了什么事情?

    1.申请空间:在堆内存之中根据类的“模板”申请一块合适大小的空间创建对象。类“模板”中有哪些属性,就把这些属性声明在这块空间之中。对象中声明了类定义的所有的属性和_isa指针和引用计数器(_isa指针指向代码段中的类)。

    2.初始化对象:初始化这块空间之中对象的属性的值,就是为属性赋默认值。

    3.返回对象地址:返回这块空间的内存地址。

    通过指针访问对象的属性和方法?

    1.访问属性:通过指针可以找到指针指向的堆空间中的对象,找到对象后就可以直接访问对象的属性。

    2.调用方法:根据指针找到堆空间中的对象,在根据对象中的_isa指针找到代码段中的类中的方法。


    2、nil和NULL


    NULL是C中指针变量的值,代表这个指针不指向任何变量,这个时候NULL等价于0。

    int *p = NULL;//等价于int *p = 0;

    nil是OC中指针变量的值,代表这个指针不指向任何对象,这个时候nil等价于0。

    Person *p = nil;//等价于Person *p = 0;

    注意:

    1.其实NULL和nil都是一个宏,并且宏值都是0。只不过NULL是在C语言中声明的宏,nil是在OC中声明的宏。所以在使用的时候应该区分开来使用。在OC中尽量使用nil,C中只能使用NULL。

    2.如果一个类指针没有指向任何对象,通过这个指针去访问对象的属性的时候会报错。通过这个指针去调用方法的时候不会报错,但是不会有任何回应。


    3、#pragma mark分组导航标记


    1.#pragma mark 分组名

    在导航栏显示分组名

    2.#pragma mark -

    在导航栏显示一条水平线

    3.#pragma mark - 分组名

    在导航栏显示分组名,分组名上面加一条水平线



    4、方法与函数


    函数指的是C语言中的函数,方法指的是定义在OC类中的方法。

    不同点:

    1.函数除了不能定义在@interface之中,可以定义在源文件中其他的任意地方(建议不要写在类中)。方法的声明只能写在@interface中,方法的实现只能写在@implementation中(语法强制要求)。

    2.函数可以直接调用(函数是孤立的)。而方法只能创建对象,通过对象名来调用(方法归属于类或者对象)。

    相同点:

    1.无论是函数还是方法,他们都是封装了一个代码块,代表一个单独的功能。



    5、多文件开发


    如果我们开发一个程序,不可能将所有的类都写在同一个源文件,后期维护和团队开发都非常不方便。所以我们需要分模块开发,并且每个模块包含两个文件,分别是类的声明文件和实现文件。类的声明写在.h文件,类的实现写在.m文件(类的实现里也要引入类的声明文件),使用这个类之前用#import引入.h文件就行了。

    新建文件的时候选择Cocoa Class,文件名使用类名,就会同时创建类的声明文件和类的实现文件。然后我们在.h文件中写类的声明,在.m文件中写类的实现。例如:

    Person.h文件

    #import <Foundation/Foundation.h>
     
    @interface Person : NSObject
    {
    @public
        NSString *_name;
    }
    - (void)sayHi;
    @end

    Person.m文件

    #import "Person.h"
     
    @implementation Person
    - (void)sayHi{
        NSLog(@"你好%@",_name);
    }
    @end

    main.m文件

    #import <Foundation/Foundation.h>
    #import "Person.h"
     
    int main(int argc, const char * argv[]) {
        @autoreleasepool {
            Person *p = [Person new];
            p -> _name = @"jack";
            [p sayHi];
        }
        return 0;
    }


    6、对象和方法


    对象作为方法的参数

    对象可以作为方法的参数,因为类的本质就是一个数据类型。并且传递的时候是地址传递,相当于在方法中操作的参数和实参是同一个对象。

    Gender.h文件

    //单独在一个头文件中定义一个性别枚举
    typedef enum{GenderMale,GenderFemale}Gender;

    Person.h文件

    #import <Foundation/Foundation.h>
    #import "Gender.h"
     
    @interface Person : NSObject
    {
    @public
        NSString *_name;
        Gender _gender;
        int _age;
    }
     
    //人的打招呼方法声明
    - (void)sayHi;
    @end

    Person.m文件

    #import "Person.h"
     
    @implementation Person
     
    //人的打招呼方法实现
    - (void)sayHi{
        NSLog(@"我是%@,性别%@,年龄%i",_name,_gender == 0 ? @"男" : @"女",_age);
    }
    @end
    God.h文件
    #import <Foundation/Foundation.h>
    #import "Person.h"
     
    @interface God : NSObject
    {
    @public
        NSString *_name;
        Gender _gender;
    }
     
    //上帝的打招呼方法声明
    - (void)sayHi;
     
    //上帝杀死一个人的方法声明
    - (void)killWithPerson:(Person *)person;
    @end

    God.m文件

    #import "God.h"
     
    @implementation God
     
    //上帝的打招呼方法实现
    - (void)sayHi{
        NSLog(@"我是%@,性别%@",_name,_gender == 0 ? @"男" : @"女");
    }
     
    //上帝杀死一个人的方法实现
    - (void)killWithPerson:(Person *)person{
        person -> _age = 0;
        NSLog(@"%@已经被%@杀死",person -> _name,self -> _name);
    }
    @end

    main.m文件

    #import <Foundation/Foundation.h>
    #import "Person.h"
    #import "God.h"
     
    int main(int argc, const char * argv[]) {
        @autoreleasepool {
            
            //实例化一个人对象
            Person *p = [Person new];
            
            //给这个对象的成员变量赋值
            p -> _name = @"小明";
            p -> _gender = GenderMale;
            p -> _age = 21;
            
            //调用这个对象的打招呼方法
            [p sayHi];//输出 我是小明,性别男,年龄21
            
            //实例化一个上帝对象
            God *g = [God new];
            
            //给这个对象的成员变量赋值
            g -> _name = @"上帝";
            
            //调用这个对象的杀死人方法
            [g killWithPerson:p];//输出 小明已经被上帝杀死
            
            NSLog(@"小明的寿命等于:%i",p->_age);//输出 小明的寿命等于:0
     
            
        }
        return 0;
    }

    对象作为方法的返回值

    Gender.h文件

    //单独在一个头文件中定义一个性别枚举
    typedef enum{GenderMale,GenderFemale}Gender;

    Person.h文件
    #import <Foundation/Foundation.h>
    #import "Gender.h"
     
    @interface Person : NSObject
    {
    @public
        NSString *_name;
        Gender _gender;
        int _age;
    }
     
    //人的打招呼方法声明
    - (void)sayHi;
    @end
    Person.m文件
    #import "Person.h"
     
    @implementation Person
     
    //人的打招呼方法实现
    - (void)sayHi{
        NSLog(@"我是%@,性别%@,年龄%i",_name,_gender == 0 ? @"男" : @"女",_age);
    }
    @end
    God.h文件
    #import <Foundation/Foundation.h>
    #import "Person.h"
     
    @interface God : NSObject
    {
    @public
        NSString *_name;
        Gender _gender;
    }
     
    //上帝的打招呼方法声明
    - (void)sayHi;
     
    //上帝杀死一个人的方法声明
    - (void)killWithPerson:(Person *)person;
     
    //上帝造人的方法
    - (Person *)makePersonWithName:(NSString *)name;
    @end
    God.m文件
    #import "God.h"
     
    @implementation God
     
    //上帝的打招呼方法实现
    - (void)sayHi{
        NSLog(@"我是%@,性别%@",_name,_gender == 0 ? @"男" : @"女");
    }
     
    //上帝杀死一个人的方法实现
    - (void)killWithPerson:(Person *)person{
        person -> _age = 0;
        NSLog(@"%@已经被%@杀死",person -> _name,self -> _name);
    }
     
    //上帝造人的方法
    - (Person *)makePersonWithName:(NSString *)name{
        Person *p = [Person new];
        p -> _name = name;
        
        NSLog(@"上帝制造了一个叫%@的人",p -> _name);
        return p;
    }
    @end
    main.m文件
    #import <Foundation/Foundation.h>
    #import "Person.h"
    #import "God.h"
     
    int main(int argc, const char * argv[]) {
        @autoreleasepool {
            
            //实例化一个上帝对象
            God *g = [God new];
            
            //上帝制造了一个人
            Person *p = [g makePersonWithName:@"小明"];//输出 上帝制造了一个叫小明的人
            
            //给制造出来的对象的成员变量赋值
            p -> _age = 19;
            p -> _gender = GenderMale;
            
            //调用这个对象的方法
            [p sayHi];//输出 我是小明,性别男,年龄19
     
        }
        return 0;
    }


    7、对象和属性

    对象可以作为类的实例变量,比如我们有一个人类和一个狗类,每一个人拥有一只狗,那狗也是人的属性了。比如:

    Dog.h文件

    #import <Foundation/Foundation.h>
     
    @interface Dog : NSObject
     
    @property (nonatomic,copy) NSString *name;//狗名
     
    - (void)shout;//狗叫的方法声明
    @end

    Dog.m文件

    #import "Dog.h"
     
    @implementation Dog
     
    //狗叫的方法实现
    - (void)shout{
        NSLog(@"叫%@的狗叫了",_name);
    }
    @end

    Person.h文件

    #import <Foundation/Foundation.h>
    #import "Dog.h"
     
    @interface Person : NSObject
    @property (nonatomic,retain) Dog *dog;//人的狗
    @end
    Person.m文件
    #import "Person.h"
     
    @implementation Person
     
    @end
    main.m文件
    #import <Foundation/Foundation.h>
    #import "Person.h"
     
    int main(int argc, const char * argv[]) {
        @autoreleasepool {
            
            //实例化一个人对象
            Person *person = [[Person alloc] init];
            
            //给人对象的dog成员赋值一个狗对象
            person.dog = [[Dog alloc] init];
            person.dog.name = @"小白";
            
            //调用狗对象叫的方法
            [person.dog shout];
            
        }
        return 0;
    }




    展开全文
  • 2)每个对象可以通过创建包含现有对象的包的方式来创建新类型的对象。因此,可以在程序中构建复杂的体系,同时将其复杂性隐蔽在对象的简单性背后。 3)某一个特定类型的所有对象都可以接收同样的消息。 每个对象都有...

    面向对象编程OOP

    OOP允许根据类型来描述问题,而不是根据运行解决方案的计算机来描述问题。
    1)程序是对象的集合,它们通过发送消息来告知彼此所要做的。可以把消息想象为对某个特定对象的方法的调用请求。
    2)每个对象可以通过创建包含现有对象的包的方式来创建新类型的对象。因此,可以在程序中构建复杂的体系,同时将其复杂性隐蔽在对象的简单性背后。
    3)某一个特定类型的所有对象都可以接收同样的消息。

    每个对象都有一个接口

    一旦类被建立,就可以随心所欲地创建类的任意个对象,然后去操作它们。接口确定了对某一特定对象所能发出的请求。但是在程序中必须有满足这些请求的代码。这些代码与隐藏的数据一起构成了实现

    Light
    on()
    off()
    brighten()
    dim()

    Light it = new Light();
    it.on();
    上例中,创建了一个Light对象,定义这个对象的引用“it”,然后调用new方法来创建该类型的新对象。为了向用户发送消息,需要声明对象的名称,并以圆点符号连接一个消息请求。这些差不多就是用对象来进行设计的全部。

    被隐藏的具体体现

    程序开发人员按角色分为类创建者客户端程序员

    类创建者:构建类,这种类只向客户端程序员暴露必须的部分,而隐藏其他部分。(因为类创建者可以修改被隐藏的部分,不用担心对其他人造成任何影响。被隐藏的部分通常代表对象内部脆弱的部分,很容易被客户端程序员所毁坏,这样可以减少bug。)

    客户端程序员:收集各种用来实现快速应用开发的类。

    Java用三个关键字在类的内部设定边界:public、private、protected
    public表示对任何人都是可用的。
    private表示除了类型创建者和类型内部方法之外的任何人都不能访问的元素。
    protected与private作用相当,差别仅在于继承的类可以访问peotected成员,但是不能访问private成员。

    展开全文
  • 一旦使用一次,这个匿名对象就无法调用变成了垃圾,只能通过系统的垃圾回收机制在某个时刻进行内存回收。 2.好处: 匿名对象随用随建,用完可以更好的回收内存,节省内存 3.使用场景: 用作方法参数 用作匿名...
  • 可以指定将表、索引和大型对象(LOB)数据放置到某个文件组中,这意味着这些对象的所有页都将从该文件组的文件中分配。 一个数据库最多可以创建32 767个文件组。文件组中只能包含数据文件,日志文
  • 【05-面向对象(下)】

    2018-07-03 21:42:31
    Lambda表达式来创建对象,该表达式创建出来的对象的目标类型就是这个函数式接口。 •Lambda表达式有如下两个限制:  –Lambda表达式的目标类型必须是明确的函数式接口。  –Lambda表达式只能为函数式接口...
  • ------培训 学习型博客,请多指教----------- 简单的说对象就是封装了的数据和方法,类就是模版。 一、对象在内存中的存储 ...当程序启动时,会加载项目中所有的类和...当第一次使用某个创建
  • 一旦某个类的Class对象载入内存,他就被用来创建这个类的所有对象。有一些网上视频和资料说Class对象就是类编译的字节码文件(.class文件,不知道Class cls=类名.class ;这种取得Class对象的方式后面的“类名....
  • 可用关键字static来标识某个对象的特定元素是静态的,但java对象本身从来不会存放在静态存储空间里。 5) 常量存储 常量值通常直接存储在程序代码内部,这样做是安全的,因为它们永远不会被改变。有时,在嵌入式...
  • 实例变量(类变量)为对象实例私有,若在系统中只存在一个此对象的实例,在多线程环境下,“犹如”静态变量那样,被某个线程修改,其他线程对修改均可见,故线程非安全; 注意:如果每个线程执行都是在不同的...
  • 可使碎片最小化,使每一个Extent都相同(等于NEXT值) 一旦建立了某个对象,它的INITIAL和MINEXTENTS参数不能修改(Oracle 816中可修改MINEXTENTS参数) 对于NEXT和PCTINCREASE的任何修改都只影响
  • C++引用与指针的区别

    2020-07-05 16:33:47
    1.初始化要求不同。引用在创建的同时必须...引用不能使用指向空值的引用,它必须总是指向某个对象。而指针则可以是NULL,不需要总是指向某些对象,可以把指针指向任意的对象。更加灵活,不易出错。 4.使用引用的..
  • 关于静态变量

    千次阅读 2018-07-23 15:31:56
    实例变量属于某个对象的属性,必须创建了实例对象,其中的实例变量才会被分配空间,才能使用这个实例变量。静态变量不属于某个实例对象,而是属于类,所以也称为类变量,只要程序加载了类的字节码,不用创建任何实例...
  • const :const对象一旦创建后其值就不能改变,const对象必须初始化。 b. 引用:是将引用与对象绑定在一起,而不是将对象的值拷贝给引用。引用一旦初始化完成,就无法再让引用和另外一个对象绑定在一起。引用必须...
  • String类

    2021-05-07 20:56:21
    我看过源代码,String底层是一个byte字节数组构成的,并且是被final修饰的,因为数组一旦创建长度不可变,并且是被final修饰的应用一旦指向某个对象后不可再指向其他对象,所以Srring是不可变的; 构造器 String...
  • asp.net mvc EF修改指定数据库列的数据

    千次阅读 2016-07-04 11:53:01
    [EF对象管理容器]: 每个通过EF数据上下文操作的实体对象,都需要存在上下文的容器中,一旦通过上下文的某个方法操作了实体对象后,那么上下文就会给它加一个状态标识。但调用上下文的SaveChanges方法的时候,上下文...
  • 1.初始化要求不同。引用在创建的同时必须初始化,即引用到一个有效的对象;而指针在定义的时候不必初始化,可以在定义后面的任何...3.不存在NULL引用,引用不能使用指向空值的引用,它必须总是指向某个对象;而指...
  • 指针与引用的区别

    2019-08-25 18:09:37
    1.初始化要求不同 引用在创建的时候必须初始化,即引用到一个有效的对象;而指针在定义的时候不必初始化,可以在定义后面的任意...引用不能使用指向空值的引用,它必须总是指向某个对象; 而指针则可以是NULL。 4.测...
  • 指针和引用的区别

    2016-09-19 22:44:44
    区别如下: 初始化要求不同:引用在创建的同时必须初始化,就是它必须引用到一个有效的...给引用赋值并不是改变它和原始对象的绑定关系不存在NULL引用:引用不能使用指向空值的引用,它必须总是指向某个对象;而指
  • 常用类

    2020-10-10 21:42:13
    字符串一旦创建不可再改变,“ abc”字符串对象一旦创建,不可再改变成“abcd”。 提升字符串的访问效率:在程序中使用了“缓存”技术,所有被双引号括起来的字符串都会在“字符串常量池"中创建一份。字符串常量池...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 163
精华内容 65
关键字:

一旦某个对象创建后