1.进程和线程的区别
进程是资源分配的最小单位, 程序执行时的一个实例．
线程是应用的最小的单位. 是程序执行的最小单位．
一个应用可以有一个或两进程,
同一进程下的线程共享全局变量、静态变量等数据
2.序列化Serializable 和Parcelable 的区别
(1).Serializable
Java自带 将一个对象转换成可存储可传输的状态，
public class Person implements Serializable{
private String name;
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
(2)Parcelable
android 自带 和Serializable有相同效果,将一个完整的对象进行分解．
分解后的每一部分都是Intent所支持的数据类型，这样也就实现传递对象的功能了
public class Data implements Parcelable{
private String color;
private int size;
protected Data(Parcel in) {
color = in.readString();
size = in.readInt();
}
public static final Creator<Data> CREATOR = new Creator<Data>() {
@Override
public Data createFromParcel(Parcel in) {
return new Data(in);
}
@Override
public Data[] newArray(int size) {
return new Data[size];
}
};
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(color);
dest.writeInt(size);
}
}
系统已经帮我们做了很多事情，我们只需要做的很简单，写自己需要的构造方法，变量的get和set
如
blic class Data implements Parcelable{
private String color;
private int size;
//get和set
//个人自己添加
public Data() {
}
//个人自己添加
public Data(String color, int size) {
this.color = color;
this.size = size;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
// 系统自动添加，给createFromParcel里面用
protected Data(Parcel in) {
color = in.readString();
size = in.readInt();
}
public static final Creator<Data> CREATOR = new Creator<Data>() {
/**
*
* @param in
* @return
* createFromParcel()方法中我们要去读取刚才写出的name和age字段，
* 并创建一个Person对象进行返回，其中color和size都是调用Parcel的readXxx()方法读取到的，
* 注意这里读取的顺序一定要和刚才写出的顺序完全相同。
* 读取的工作我们利用一个构造函数帮我们完成了
*/
@Override
public Data createFromParcel(Parcel in) {
return new Data(in); // 在构造函数里面完成了 读取 的工作
}
//供反序列化本类数组时调用的
@Override
public Data[] newArray(int size) {
return new Data[size];
}
};
@Override
public int describeContents() {
return 0; // 内容接口描述，默认返回0即可。
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(color); // 写出 color
dest.writeInt(size); // 写出 size
}
}
使用时机
1.在使用内存的时候，Parcelable比Serializable性能高，所以推荐使用Parcelable。
2.Serializable在序列化的时候会产生大量的临时变量，从而引起频繁的GC。
3.如果要存储到磁盘．需要使用Serializable，原因，Parcelable不能很好的保证数据的持续性．
3.谈谈对kotlin的理解
-1.可以无缝对接java，互相可以调用
-2.不用声明类型
-3.空安全
-4.数据对象实体类的创建，不再需要手动创建set或get方法
-5. 控件无需声明，直接通过控件id调用．
4.闭包和局部内部类的区别
-1. 闭包：方法中的局部变量会在执行结束后就会被释放，但是内部类访问此变量就形成了闭包
public class method(){
int i=30;
//局部内部类将输出这个局部变量
class innerClass{
public void getInt(){
System.out.println(i);
}
}
}
-1.成员内部类:
(1)访问 外部类所以静态,非静态成员
public class Person {
private static int hairLength = 5;
private int manAge = 18;
public class Man {
public int setHair() {
return hairLength;
}
public int setAge() {
return manAge;
}
}
}
(2)被访问
Person person = new Person();
Person.Man man = person.new Man();
Log.i("log", "" + man.setAge());
Log.i("log", "" + man.setHair());
-2. 静态内部类:
(1)访问:可访问外部类的静态 成员, 不可非静态成员
public class Person {
private static int hairLength = 5;
private int manAge = 18;
public static class Woman{
public int setHair() {
return hairLength;
}
}}
}
(2)被访问 访问非静态类,需要创建一个外部类实例. 访问静态n类,使用内部类类名访问内部类的静态成员。
Person.Woman woman = new Person.Woman();
woman.setHair();
-3. 局部内部类:
(1)访问 外部类所以静态,非静态成员
public class Person {
private static int hairLength = 5;
private int manAge = 18;
public void getChild(){
class child{
public void name(){
Log.i("log",""+manAge);
Log.i("log",""+hairLength);
}
}
new child().name();
}
}
(2)调用
Person person = new Person();
person.getChild();
-4. 匿名内部类:
public interface Person {
// private static int hairLength = 5;
// private int manAge = 18;
public void run();
}
Person person = new Person(){
@Override
public void run() {
}
};
下一节[集合]