Java 读书笔记6

访问权限控制

其实这部分已经不用像java编程思想中讲的那么麻烦了；

1.java中关于编译的简单内容
首先java程序跑起来，会生成.class,这个.class会在环境变量\包名这里；
然后import的时候，找到这个class就可以啦；
2.以private构造方法的单例设计模式，日后再说喽，其实之前应该写过；

3.protected的方法主要用来干啥呢？因为在继承中，可能子类在别的包中，你写public的话，谁都可以访问，不写public又访问不到，所以protected出现了；所有继承者都可以用；
ps：其实java语言真的很实际，你自己推一推，其实也会知道；但还是赞叹人家的设计想法啊；

2017-02-25

Java 垃圾回收（未完成）

# 垃圾回收

早就知道java会垃圾回收了，但是对其中道理一点都不了解，我想成为大神，还是必须要多懂一些，多会一些，多写一些吧；

# 垃圾回收的算法和思想

引用计数法
这个相当于计数，因为java每个变量的名字实际上是一种引用，我们可以给一个对象很多引用，那么同时，当对象没有引用的时候，说明这个对象没有用了，可以扔掉了；
ps：对象都没有引用了，说明这块地址，这个对象，程序已经使用不了，那就赶紧清理呗
tracing算法追踪算法
当我们通过计数这种方式，进行垃圾清理，我们会多出很多操作，每次都要加减，还要存储计数；那么可不可以不要这么麻烦呢，追踪算法，顾名思义，追踪，通过所有引用追踪对象，如果对象存在，将其标记；追踪结束后，回收那些没有标记的对象；
compacting算法
对于一个对象，我们怎么知道他是不是活着呢？我们可以移动它呀。于是我们可以把对象移动至堆得一侧，那么另一侧就是不可操作的对象了；
copying算法
上面说移到另一侧，这个呢直接就有好多堆，从这里移到哪里，然后清理旧的
5.generation算法
简单来说，应该是说分堆，分代，新生成的对象，放在新代中，执行清理，存活的对象扔到旧代中；
就像是你现在混黑社会，外圈是要淘汰的，比如说一分钟淘汰一次，滤掉的就是不合格的，剩下的升级；升级后清理密度变低，这样就节省了时间；

## 稍微深度一下：

我们在子函数建立一个对象a，当子函数运行完成时，返回时？这个a还存在吗？

对象存不存在不一定，a一定不存在了，首先a是一个引用，他的作用于只在子函数运行时，函数结束，他就不存在了；但是这个对象存不存在就要看垃圾回收何时进行了；

2017-02-23

Java 读书笔记5

初始化与清理

1.重载和区分重载
：书上例子很好，洗衣服，洗车，洗狗；同样都是洗，却洗的是不一样的东西，似乎用一个名字做不同的事情，理所应当；
而且呢，还告诉我们为什么不一样，因为给的参数不一样，当来着是衣服的时候，就用洗衣服的方式来洗，如果是车，就用车的方式；
不可以通过返回值区分，你洗狗洗出来特干净，他就不干净，但是方法实际是相同的；
不可以通过访问修饰符区分，你就给你家洗衣服，洗衣店谁家衣服都洗，但是方法还是一样的；

2.基本类型与重载；
简单来说呢，基本类型在重载时，由于类型不同重载就会出现问题；
上代码喽

public class Test  {
    public void testfloat(float a)
    {
        System.out.println("lll");
    }
    public  void  testdouble(double a)
    {
        System.out.println("222");
    }
}
        Test test = new Test();
        double a = 0;
        float b= 0;
        test.testfloat(a);//这样写报错    大类型不能向下转换，直接报错
        test.testfloat((float) a);
        test.testdouble(b);    小类型转化为大类型

其实想想就明白了，32位转化为64位。又没什么损失，反过来的话，就会丢失精度；况且如果能够来回转的话，我估计你最后都不知道出来的是哪个类型的；

3.this关键字

一般的this肯定这么用的最多，这时其实不写this也是一样的啦；写上this更加清晰，指的是本对象里的某个属性等于参数。

public class Hello { 
    String s = "Hello"; 
    public Hello(String s){ 
        System.out.println("s = " + s); 
        System.out.println("1 -> this.s = " + this.s); 
        this.s = s; 
        System.out.println("2 -> this.s = " + this.s); 
    } 
    public static void main(String[] args) { 
    Hello x=new Hello("HelloWorld!"); 
    } 
}

还有就是调用自己的其他构造函数，继承什么的题目里经常会有的那种

public class Flower{ 
           Flower (int petals){} 
           Flower(String ss){} 
           Flower(int petals, Sting ss){ 
                //petals++;调用另一个构造函数的语句必须在最起始的位置 
                this(petals); 
               //this(ss);会产生错误，因为在一个构造函数中只能调用一个构造函数 
           } 
}

这次学到了这个

public class A { 
  public A() { 
    new B(this).print();     //将自身当成参数传递过去
  } 
  public void print() { 
    System.out.println("Hello from A!"); 
  } 
} 
public class B { 
  A a; 
  public B(A a) { 
    this.a = a; 
  } 
  public void print() { 
    a.print(); 
    System.out.println("Hello from B!"); 
  } 
}

匿名类 this一般代表整个匿名类，日后再说

public class A { 
    int i = 1; 
    public A() { 
        Thread thread = new Thread() { 
            public void run() { 
                for(;;) { 
                    A.this.run();       //匿名类
                    try { 
                        sleep(1000); 
                    } catch(InterruptedException ie) {     }
                } 
           } 
        }; //注意这里有; 
        thread.start(); 
    } 
    public void run() { 
        System.out.println("i = " + i); 
        i++; 
    } 
    public static void main(String[] args) throws Exception { 
        new A(); 
    }
}

初始化顺序（对于类来说）

1.静态变量初始化 //由于static不可初始化局部变量，就没有小函数的担心啦；
2.普通变量初始化
3.变量都初始化后，方法开始执行

2017-02-23

Java 读书笔记3

操作符

1.赋值和引用（别名）；
=我们最常见；意思可以使等于，也可以是赋值，在Java中，赋值也是有坑的

public class Tank {
    int level;
}
    public static void main(String[] args) {
 Tank tank1 = new Tank();
        tank1 .level = 1;
        Tank tank2 = new Tank();
        tank2. level = 2;
        System.out.println(tank1.level);//输出1
        System.out.println(tank2.level);//输出2
        tank1 = tank2;
        //tank1.level = tank2.level; 其实这么写才是对的
        System.out.println(tank1.level);//输出2
        System.out.println(tank2.level);//输出2
        tank1.level = 27;
		
        System.out.println(tank2.level);//输出27
      }

对上面的赋值 tank1=tank2 来说，好像是在说你以后什么值都和他相等就对了；但其实不是的，tank1 = tank2 是在讲tank1 以后和tank2 都指向同一个对象了；
tank1 和tank2 本质都是引用，现在他们指向同一个对象了，那么不管这个对象的level怎么变化，tank1和tank2 都是一个值；

打个比方好了不管叫做对象名或者引用什么的；我们将对象看成人，将引用看成名字或代号，说家里两兄弟，哥哥去打仗了，对弟弟说，这一去恐怕就回不来了，带着我的名字活下去吧；
那么从此以后弟弟就有了两个名字同时代表他；而哥哥恐怕就被当做不存在喽；

ps:本章有很多关于操作符的相关内容能够，用到再看吧，反正记不住；

2017-02-22

Java 读书笔记2

一切都是对象

1.引用和对象（java编程思想中这样讲）

1 2	Classa a; //此处可理解为引用，就是说起好名字啦，但是对象还没初始化呢 a= new Classa(); //初始化后，对象才被创建成功；

2.储存中的堆与栈；
http://stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap
栈呢，是先进后出；在函数调用中，被调用函数后进栈，先结束，所以先出栈；所以对内存来说，函数（function）使用栈这种空间；
堆呢；以java为例，在调用某函数时，可能会创建新的对象；这些对象没有明确的先后之分（不重要），而且随时可能创建，销毁，所以就把他们都放在堆中管理啦；

2017-02-22