昨天机试过了  今天要面试了  感觉还有些不明白  谁能概括哈  面试都考哪些啊

1)数组中类型一旦确定,就不能更改
2)数组的长度是固定的
3)数组的定义格式:类型 数组名 [元素个数]

面向对象是必须的！多看下！数组！多线程和反射理解一下能说出来一些就行！集合也会问到的！面向对象一定要看！一定要看！一定要看！把你会的一股脑全说出来就差不多了！老师不会那么死板的

数组定义格式
        数据类型[] 数组名 = new 数据类型[数组的长度];
A:什么是数组的初始化
        * 就是为数组开辟连续的内存空间，并为每个数组元素赋予值
* B:如何对数组进行初始化
        * a:动态初始化 只指定长度，由系统给出初始化值
                * int[] arr = new int[5];        
        * b:静态初始化 给出初始化值，由系统决定长度
                * int[] arr= {3,4,5};       
* C:动态初始化的格式：
        * 数据类型[] 数组名 = new 数据类型[数组长度];

数组操作的两个常见小问题越界和空指针
* a:ArrayIndexOutOfBoundsException:数组索引越界异常
                * 原因：你访问了不存在的索引。
        * b:NullPointerException:空指针异常
                * 原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。
                * int[] arr = {1,2,3};
                * arr = null;
                * System.out.println(arr[0]);
数组的操作1遍历2获取最值数组的操作3反转4查表法5基本查找
二维数组格式1
        * int[][] arr = new int[3][2];
int[] x,y[];        x是一维数组,y是二维数组
int[] x;
int[] y[];
二维数组练习1遍历2求和
#基本数据类型的值传递:不改变原值,因为调用后就会弹栈(无论怎么改变局部变量都消失了)
#引用数据类型的值传递:改变原值,因为即使方法弹栈,但是在堆内存中对象还在,可以通过地址值方法
Java中到底是值传递,还是址传递;
1:基本数据类型传递值.
2:引用数据类型传递地址.
#(面试说这种)3:Java中只有传值,,因为地址值也是值.支持者是Java之夫高司令

嘎嘎...{:3_51:}笔记里复制的

面试自己看着笔记,说个差不多应该就可以了

数组的定义：
概念：同一种类型数据的集合。其实数组就是一个容器。
数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

6666666666666

把笔记里的致使癫痫从头到尾看一遍，如果有遗忘或者模棱两可的知识点和代码，都要再敲一遍，平时基础视频里的练习都要认真完成一遍，最后就是多做一些逻辑算法题。
望采纳

面试考什么？
基本是自我介绍和理论概念，中间细节和注意事项你可以多问问

楼主，你好，数组的定义常用的有以下几种方式：
1、声明数组的同时初始化数组。
int arr[]={数组中的每个元素};
2、声明数组的同时指定数组的长度。
int arr[10];

常考的知识点有以下几点：
1、数组的长度是固定的。数组一旦声明，就必须为其指定长度。（第二种数组定义的方式int arr[10];
2、如果数组的元素个数确定，数组的长度可以省略不写。（第一种数组定义的方式nt arr[]={数组中的每个元素};
3、数组在内存中是如何表示的（这是重点！）
这里有个公式：
数组名＝数组的地址＝数组的第一个元素的地址＝数组的第一个元素的最低字节的地址。
4、当我们声明一个数组的时候，其实是在内存中申请一块空间。这个空间的大小＝数组中的每个元素所占的字节数*数组中元素的个数。
5、数组也是一个变量。变量在内存中寻址，也是从大到小。也就是说，先从内存中的高字节开始寻找，寻找能够存得下该数组的连续的空间。这里必须强调，这个空间必须是连续的！
6、第五点完成后，有了这个连续的空间，数组中的每个元素便在这个连续的空间里，从低字节到高字节，按序存储在这个连续的空间里。先存第一个元素，再存第二个元素，依此类推。第一个元素的地址是最小的。最后一个元素的地址是最大的。


什么时候我们要用到数组：
1、当我们需要存储多个类型相同，而且数据的意义也相同的时候，我们就需要定义一个数组。

掌握了以上几点，数组这一块知识点你就基本掌握了。纯手打的，满意请采纳，谢谢！

面向对象是经常问的

      数据类型[] 数组名 = new 数据类型[数组的长度];
  数组长度只要确定了 就不可变 数组有初始值
基本数据类型为0    引用数据类型为null
两种方式：
1 、int [] a=new int[5];先给定数组长度，然后再赋值
2、int [] a={1,2,3,4,5,6}   直接给定值  让系统去算长度
通过数组名.length属性计算长度   如：a.length

A:什么是数组的初始化
        * 就是为数组开辟连续的内存空间，并为每个数组元素赋予值
* B:如何对数组进行初始化
        * a:动态初始化 只指定长度，由系统给出初始化值
                * int[] arr = new int[5];        
        * b:静态初始化 给出初始化值，由系统决定长度       
* C:动态初始化的格式：
        * 数据类型[] 数组名 = new 数据类型[数组长度];
* D:案例演示
        * 输出数组名称和数组元素

10个必问的问题

1、#import和#include的区别，@class代表什么？

@class一般用于头文件中需要声明该类的某个实例变量的时候用到，在m文件中还是需要使用#import

而#import比起#include的好处就是不会引起重复包含

2、谈谈Object-C的内存管理方式及过程？

1.当你使用new,alloc和copy方法创建一个对象时,该对象的保留计数器值为1.当你不再使用该对象时,你要负责向该对象发送一条release或autorelease消息.这样,该对象将在使用寿命结束时被销毁.

2.当你通过任何其他方法获得一个对象时,则假设该对象的保留计数器值为1,而且已经被设置为自动释放,你不需要执行任何操作来确保该对象被清理.如果你打算在一段时间内拥有该对象,则需要保留它并确保在操作完成时释放它.

3.如果你保留了某个对象,你需要(最终)释放或自动释放该对象.必须保持retain方法和release方法的使用次数相等.

3、Object-C有私有方法吗？私有变量呢？

objective-c – 类里面的方法只有两种, 静态方法和实例方法. 这似乎就不是完整的面向对象了,按照OO的原则就是一个对象只暴露有用的东西. 如果没有了私有方法的话, 对于一些小范围的代码重用就不那么顺手了. 在类里面声名一个私有方法

@interface Controller : NSObject { NSString *something; }

+ (void)thisIsAStaticMethod;

– (void)thisIsAnInstanceMethod;

@end

@interface Controller (private) -

(void)thisIsAPrivateMethod;

@end

@private可以用来修饰私有变量

在Objective‐C中，所有实例变量默认都是私有的，所有实例方法默认都是公有的

4、Object-C有多继承吗？没有的话用什么代替？cocoa 中所有的类都是NSObject 的子类

多继承在这里是用protocol 委托代理 来实现的

你不用去考虑繁琐的多继承 ,虚基类的概念.

ood的多态特性 在 obj-c 中通过委托来实现.

5、内存管理 Autorelease、retain、copy、assign的set方法和含义？

1，你初始化(alloc/init)的对象，你需要释放(release)它。例如：

NSMutableArray aArray = [[NSArray alloc] init]; 后，需要 [aArray release];

2，你retain或copy的，你需要释放它。例如：

[aArray retain] 后，需要 [aArray release];

3，被传递(assign)的对象，你需要斟酌的retain和release。例如：

obj2 = [[obj1 someMethod] autorelease];

对象2接收对象1的一个自动释放的值，或传递一个基本数据类型(NSInteger，NSString)时：你或希望将对象2进行retain，以防止它在被使用之前就被自动释放掉。但是在retain后，一定要在适当的时候进行释放。

关于索引计数(Reference Counting)的问题

retain值 = 索引计数(Reference Counting)

NSArray对象会retain(retain值加一)任何数组中的对象。当NSArray被卸载(dealloc)的时候，所有数组中的对象会 被 执行一次释放(retain值减一)。不仅仅是NSArray，任何收集类(Collection Classes)都执行类似操作。例如 NSDictionary，甚至UINavigationController。

Alloc/init建立的对象，索引计数为1。无需将其再次retain。

[NSArray array]和[NSDate date]等“方法”建立一个索引计数为1的对象，但是也是一个自动释放对象。所以是本地临时对象，那么无所谓了。如果是打算在全Class中使用的变量(iVar)，则必须retain它。

缺省的类方法返回值都被执行了“自动释放”方法。(*如上中的NSArray)

在类中的卸载方法“dealloc”中，release所有未被平衡的NS对象。(*所有未被autorelease，而retain值为1的)

6、浅拷贝和深拷贝区别是什么

简单的来说就是，在有指针的情况下，浅拷贝只是增加了一个指针指向已经存在的内存，而深拷贝就是增加一个指针并且申请一个新的内存，使这个增加的指针指向这个新的内存，采用深拷贝的情况下，释放内存的时候就不会出现在浅拷贝时重复释放同一内存的错误

7、C和obj-c 如何混用

1）obj-c的编译器处理后缀为m的文件时，可以识别obj-c和c的代码，处理mm文件可以识别obj-c,c,c++代码，但cpp文件必须只能用c/c++代码，而且cpp文件include的头文件中，也不能出现obj-c的代码，因为cpp只是cpp

2)在mm文件中混用cpp直接使用即可，所以obj-c混cpp不是问题

3）在cpp中混用obj-c其实就是使用obj-c编写的模块是我们想要的。

如果模块以类实现，那么要按照cpp class的标准写类的定义，头文件中不能出现obj-c的东西，包括#import cocoa的。实现文件中，即类的实现代码中可以使用obj-c的东西，可以import,只是后缀是mm。

如果模块以函数实现，那么头文件要按c的格式声明函数，实现文件中，c++函数内部可以用obj-c，但后缀还是mm或m。

总结：只要cpp文件和cpp include的文件中不包含obj-c的东西就可以用了，cpp混用obj-c的关键是使用接口，而不能直接使用 实现代 码，实际上cpp混用的是obj-c编译后的o文件，这个东西其实是无差别的，所以可以用。obj-c的编译器支持cpp

8、Objective-C中类别和类扩展的区别。

答案：category和extensions的不同在于后者可以添加属性。另外后者添加的方法是必须要实现的。

extensions可以认为是一个私有的Category。

9、我们说的Objective-C是动态运行时语言是什么意思？

答案：多态。 主要是将数据类型的确定由编译时，推迟到了运行时。

这个问题其实浅涉及到两个概念，运行时和多态。

简单来说，运行时机制使我们直到运行时才去决定一个对象的类别，以及调用该类别对象指定方法。

多态：不同对象以自己的方式响应相同的消息的能力叫做多态。意思就是假设生物类（life）都用有一个相同的方法-eat;

那人类属于生物，猪也属于生物，都继承了life后，实现各自的eat，但是调用是我们只需调用各自的eat方法。

也就是不同的对象以自己的方式响应了相同的消息（响应了eat这个选择器）。

因此也可以说，运行时机制是多态的基础？

10、Objective-C堆和栈的区别？

管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。

申请大小：

栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因 此，能从栈获得的空间较小。

堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出

分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。

分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的。

以上就是10个面试者经常会碰到的Objective-C基础面试题，如果你正好要去应聘iOS岗位那么请回到文章开始重新认真阅读吧。iOS开发还是相对比较有前途的，大家觉得呢？

数组一般都是供底层使用,实际代码一般使用别的容器--集合

###05.01_Java语言基础(数组概述和定义格式说明)(了解)
* A:为什么要有数组(容器)
        * 为了存储同种数据类型的多个值
* B:数组概念
        * 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
        * 数组既可以存储基本数据类型，也可以存储引用数据类型。

* C:数组定义格式
        数据类型[] 数组名 = new 数据类型[数组的长度];
###05.02_Java语言基础(数组的初始化动态初始化)(掌握)
* A:什么是数组的初始化
        * 就是为数组开辟连续的内存空间，并为每个数组元素赋予值
* B:如何对数组进行初始化
        * a:动态初始化 只指定长度，由系统给出初始化值
                * int[] arr = new int[5];        
        * b:静态初始化 给出初始化值，由系统决定长度       
* C:动态初始化的格式：
        * 数据类型[] 数组名 = new 数据类型[数组长度];
* D:案例演示
        * 输出数组名称和数组元素

###05.03_Java语言基础(Java中的内存分配以及栈和堆的区别)
* A:栈(掌握)
        * 存储局部变量
* B:堆(掌握)
        * 存储new出来的数组或对象
* C:方法区
        * 面向对象部分讲解
* D:本地方法区
        * 和系统相关
* E:寄存器
        * 给CPU使用
###05.04_Java语言基础(数组的内存图解1一个数组)(掌握)
* A:画图演示
        * 一个数组

###05.05_Java语言基础(数组的内存图解2二个数组)(了解)
* A:画图演示
        * 二个不同的数组

###05.06_Java语言基础(数组的内存图解3三个引用两个数组)(了解)
* A:画图演示
        * 三个引用，有两个数组的引用指向同一个地址

###05.07_Java语言基础(数组的初始化静态初始化及内存图)(掌握)
* A:静态初始化的格式：
        * 格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
        * 简化格式：
                * 数据类型[] 数组名 = {元素1,元素2,…};
* B:案例演示
        * 对数组的解释
        * 输出数组名称和数组元素
* C:画图演示
        * 一个数组

###05.08_Java语言基础(数组操作的两个常见小问题越界和空指针)(掌握)
* A:案例演示
        * a:ArrayIndexOutOfBoundsException:数组索引越界异常
                * 原因：你访问了不存在的索引。
        * b:NullPointerException:空指针异常
                * 原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。
                * int[] arr = {1,2,3};
                * arr = null;
                * System.out.println(arr[0]);

###05.09_Java语言基础(数组的操作1遍历)(掌握)
* A:案例演示
        * 数组遍历：就是依次输出数组中的每一个元素。
        * 数组的属性:arr.length数组的长度
        * 数组的最大索引:arr.length - 1;
         
                        public static void print(int[] arr) {
                                for (int i = 0;i < arr.length ;i++ ) {
                                        System.out.print(arr[i] + " ");
                                }
                        }

###05.10_Java语言基础(数组的操作2获取最值)(掌握)
* A:案例演示
        * 数组获取最值(获取数组中的最大值最小值)
               
                        public static int getMax(int[] arr) {
                                int max = arr[0];
                                for (int i = 1;i < arr.length ;i++ ) {                        //从数组的第二个元素开始遍历
                                        if (max < arr[i]) {                                                        //如果max记录的值小于的数组中的元素
                                                max = arr[i];                                                        //max记录住较大的
                                        }
                                }
               
                                return max;
                        }
###05.11_Java语言基础(数组的操作3反转)(掌握)
* A:案例演示
        * 数组元素反转(就是把元素对调)
                       
                        public static void reverseArray(int[] arr) {
                                for (int i = 0;i < arr.length / 2 ; i++) {
                                        //arr[0]和arr[arr.length-1-0]交换
                                        //arr[1]和arr[arr.length-1-1]交换
                                        //arr[2]和arr[arr.lentth-1-2]
                                        //...
               
                                        int temp = arr[i];
                                        arr[i] = arr[arr.length-1-i];
                                        arr[arr.length-1-i] = temp;
                                }
                        }

###05.12_Java语言基础(数组的操作4查表法)(掌握)
* A:案例演示
        * 数组查表法(根据键盘录入索引,查找对应星期)
       
                        public static char getWeek(int week) {
                                char[] arr = {' ','一','二','三','四','五','六','日'};                //定义了一张星期表
                                return arr[week];                                                                                        //通过索引获取表中的元素
                        }

###05.13_Java语言基础(数组的操作5基本查找)(掌握)
* A:案例演示
        * 数组元素查找(查找指定元素第一次在数组中出现的索引)
       
                        public static int getIndex(int[] arr,int value) {
                                for (int i = 0;i < arr.length ;i++ ) {                                //数组的遍历
                                        if (arr[i] == value) {                                                        //如果数组中的元素与查找的元素匹配
                                                return i;
                                        }
                                }
                                return -1;
                        }

###05.14_Java语言基础(二维数组概述和格式1的讲解)(了解)
* A:二维数组概述
* B:二维数组格式1
        * int[][] arr = new int[3][2];
* C:二维数组格式1的解释
* D:注意事项
        * a:以下格式也可以表示二维数组
                * 1:数据类型 数组名[][] = new 数据类型[m][n];
                * 2:数据类型[] 数组名[] = new 数据类型[m][n];
        * B:注意下面定义的区别
        *
                        int x;
                        int y;
                        int x,y;
                       
                        int[] x;
                        int[] y[];
                       
                        int[] x,y[];        x是一维数组,y是二维数组
* E:案例演示
        * 定义二维数组，输出二维数组名称，一维数组名称，一个元素

###05.15_Java语言基础(二维数组格式1的内存图解)(了解)
* A:画图演示
        * 画图讲解上面的二维数组名称，一维数组名称，一个元素的值的问题

###05.16_Java语言基础(二维数组格式2的讲解及其内存图解)(了解)
* A:二维数组格式2
        * int[][] arr = new int[3][];
* B:二维数组格式2的解释
* C:案例演示
        * 讲解格式，输出数据，并画内存图

###05.17_Java语言基础(二维数组格式3的讲解及其内存图解)(了解)
* A:二维数组格式3
        * int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
* B:二维数组格式3的解释
* C:案例演示
        * 讲解格式，输出数据，并画内存图

###05.18_Java语言基础(二维数组练习1遍历)(掌握)
* A:案例演示
        * 需求：二维数组遍历

        * 外循环控制的是二维数组的长度，其实就是一维数组的个数。
        * 内循环控制的是一维数组的长度。

                        int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
       
                        for (int i = 0;i < arr.length ;i++ ) {                        //获取到每个二维数组中的一维数组
                                for (int j = 0;j < arr[i].length ;j++ ) {        //获取每个一维数组中的元素
                                        System.out.print(arr[i][j] + " ");
                                }
       
                                System.out.println();
                        }
###05.19_Java语言基础(二维数组练习2求和)(掌握)
* A:案例演示
*
                需求：公司年销售额求和
                某公司按照季度和月份统计的数据如下：单位(万元)
                第一季度：22,66,44
                第二季度：77,33,88
                第三季度：25,45,65
                第四季度：11,66,99
               
                int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

                int sum = 0;                                                                        //定义变量,记录每次相加的结果
                for (int i = 0;i < arr.length ;i++ ) {                        //获取每一个一维数组
                        for (int j = 0;j < arr[i].length ;j++ ) {        //获取每一个一维数组中的元素
                                sum = sum + arr[i][j];                                        //累加
                        }
                }

                System.out.println(sum);
###05.20_Java语言基础(思考题Java中的参数传递问题及图解)(掌握)
* A:案例演示
*
                看程序写结果，并画内存图解释
                public static void main(String[] args) {
                        int a = 10;
                        int b = 20;
                        System.out.println("a:"+a+",b:"+b);
                        change(a,b);
                        System.out.println("a:"+a+",b:"+b);
       
                        int[] arr = {1,2,3,4,5};
                        change(arr);
                        System.out.println(arr[1]);
                }
       
                public static void change(int a,int b) {
                        System.out.println("a:"+a+",b:"+b);
                        a = b;
                        b = a + b;
                        System.out.println("a:"+a+",b:"+b);
                }
       
                public static void change(int[] arr) {
                        for(int x=0; x<arr.length; x++) {
                                if(arr[x]%2==0) {
                                        arr[x]*=2;
                                }
                        }
                }

数组是在程序设计中，为了处理方便， 把具有相同类型的若干变量按有序的形式组织起来的一种形式。 一维数组的定义 举个例子 int a[ 3]={1,2,3,4}; 二维数组的定义方法较灵活 可以按行分段也可以连续定义 如 int a[5][3]={ {80,75,92},{61,65,71},{59,63,70},{85,87,90},{76,77,85} };（分段） int a[5][3]={ 80,75,92,61,65,71,59,63,70,85,87,90,76,77,85 }; 这个是连续的

lrwillinggerry 发表于 2016-8-19 14:07
###05.01_Java语言基础(数组概述和定义格式说明)(了解)
* A:为什么要有数组(容器)
        * 为了存储同种数据类型 ...

同学，你这是双圆视频总结出的吗，很好

大傻宝宝 发表于 2016-8-28 01:55
同学，你这是双圆视频总结出的吗，很好

那就给我12个黑马币啊!{:2_30:}