一.磨叽磨叽Java值传递与引用传递
“在Java里面参数传递都是按值传递”
即：按值传递是传递的值的拷贝，按引用传递其实传递的是引用的地址值，所以统称按值传递。
简单的说，基本数据类型是按值传递的，方法的实参是一个原值的复本。类对象是按对象的引用地址（内存地址）传递地址的值，那么在方法内对这个对象进行修改是会直接反应在原对象上的（或者说这两个引用指向同一内存地址）。注意String也是值传递。
public static void main(String[] args) {
String x = new String("now");
User user = new User("now");
change(x);
System.out.println("1:"+x);
change(user);
System.out.println("2:"+user.name);
User user1 = new User("now");
System.out.println("3:"+user1 .name);
}
public static void change(String x) {
x = "even";
}
public static void change(User x) {
x.name = "even";
}
public static void change(User x) {
x = new User("even");
}
得出的结果
1:even
2:even
3:now
二.回归正题，聊聊Java内部类的这些事
Java允许在一个类里面定义另一个类，类里面的类就是内部类，也叫做嵌套类
简单的内部类如下：
class OuterClass {
class InnerClass{
}
}
经常用到的内部类：
public class PrivateToOuter {
Runnable mRunnable = new Runnable(){
private int x=10;
@Override
public void run() {
System.out.println(x);
}
};
}
以上代码mRunnable让人并不觉得是内部类，它并不像InnerClass那样形象，但是其实以下句柄实现一个继承Runable的类，也就是自定义了一个类，那么明显它就是一个内部类。其实它是属于内部类一种：匿名内部类Anonymous Inner Class
{
private int x=10;
@Override
public void run() {
System.out.println(x);
}
}
内部类需要注意的以下几点：
（1）内部类的获取
内部类可以访问包装他的外部类的所有，方法和属性，包括私有方法。但是对其他类来说，它是隐藏的，哪怕对同一个包下面其他类来说，内部类都是隐藏的，也就是说，如果要访问内部类，就必须先要得到他的外部包装类，得到那个句柄之后在new 内部类，就可以调用他的方法了，如下：
OuterClass outer = new OuterClass();
InnerClass innerClass = outer.new InnerClass();
所以内部类是可以很好的解决单继承的问题。如果对于private在此逻辑为何失效的话，可以查看细话Java："失效"的private修饰符
（2）静态内部类
如果用static 将内部内静态化，那么内部类就只能访问外部类的静态成员变量，具有局限性
class Out {
private static int age = 12;
private int time = 14;
static class In {
public void print() {
System.out.println(age);
}
}
}
public class Demo {
public static void main(String[] args) {
Out.In in = new Out.In();
in.print();
}
}
也就是说in只能访问age，而非time
（3）私有内部类
如果一个内部类只希望被外部类中的方法操作，那么可以使用private声明内部类
class Out {
private int age = 12;
private class In {
public void print() {
System.out.println(age);
}
}
public void outPrint() {
new In().print();
}
}
public class Demo {
public static void main(String[] args) {
//此方法无效
/*
Out.In in = new Out().new In();
in.print();
*/
Out out = new Out();
out.outPrint();
}
}
需要特别告诉大家重要的point就是：
在内部类构造的时候，会将外部类的引用传递进来，并且作为内部类的一个属性，所以内部类会持有一个其外部类的引用。
在Java中，非静态的内部类和匿名内部类都会隐式地持有其外部类的引用。静态的内部类不会持有外部类的引用。所以point3中的内部类是无法获取到外部类的成员变量与方法。
回归到android：
public class SampleActivity extends Activity {
private final Handler handler= new Handler() {
@Override
public void handleMessage(Message msg) {
// ...
}
}
}
这是我们获取handler实例经常所做的操作，但是回归到point得知，handler的匿名内部类中有SampleActivity的引用，所以这是有可能导致OOM的隐患，比如以下代码：
public class SampleActivity extends Activity {
private final Handler mLeakyHandler = new Handler() {
@Override
public void handleMessage(Message msg) { // ... }
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mLeakyHandler.postDelayed(new Runnable() {
@Override
public void run() { /* ... */ }
}, 1000 * 60 * 10);
finish();
}
}
SampleActivity对象已经finish，但是mLeakyHandler的消息要在10分钟后执行操作，而Handler是一个匿名内部类的实例，其持有外面的SampleActivity的引用（而且Runable也是匿名内部类，其内部也是持有SampleActivity的引用），所以这导致了SampleActivity无法回收，进行导致SampleActivity持有的很多资源都无法回收，这就是我们常说的内存泄露。解决方法如下：
public class SampleActivity extends Activity {
private static class MyHandler extends Handler {
private final WeakReference<SampleActivity> mActivity;
public MyHandler(SampleActivity activity) {
mActivity = new WeakReference<SampleActivity>(activity);
}
@Override
public void handleMessage(Message msg) {
SampleActivity activity = mActivity.get();
if (activity != null) { // ... }
}
}
private final MyHandler mHandler = new MyHandler(this);
private static final Runnable sRunnable = new Runnable() {
@Override
public void run() { /* ... */ }
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mHandler.postDelayed(sRunnable, 1000 * 60 * 10);
finish();
}
}
