Java编程思想——初始化与清理

时间  2019-11-09
标签 java 编程 思想 初始化 清理 栏目 Java 繁體版
原文   原文链接

PS：最近一直忙于项目开发..因此一直没有写博客..趁着空闲期间来一发..html

 

学习内容:java

1.初始化算法

2.清理编程

 

1.初始化安全

  虽然本身的Java基础仍是比较良好的..可是在解读编程思想的时候仍是发现了许多的细节问题本身并无彻底的掌握.既然是研磨,那么就应该更加的细致.函数

  i.构造方法的重载.学习

  首先说明一下,为何构造方法须要重载.测试

  须要重载的一个重要缘由就是,由于咱们的构造器只能有一个名字,也就是和类名相同.可是若是咱们须要经过不一样的方式去构造一个对象的时候咱们该如何是好？那么这里就须要经过对构造器的重载来实现.这样就须要多个构造器来实现.首先就是须要一个默认的构造器,而后其余的构造器就须要经过在重载构造器的方式来构造不一样的构造器(针对不一样的参数).this

class Darker{
    private String darker;
    public Darker() {
        // TODO Auto-generated constructor stub
        System.out.println("Default Constructor: "+darker);
    }
    
    public Darker(String darker){
        this.darker = darker;
        System.out.println("Overload Constructor: "+darker);
    }
}

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Darker darker = new Darker();
        Darker darker2 = new Darker("darker");
    }
}

  这样经过重载构造器.咱们就能够经过使用不一样的方法对对象进行初始化.那么重载的方法.Java如何知道要走哪一个方法去构造一个对象呢？其实不难理解,因为方法名称相同,那么无非就是经过参数的不一样来识别.甚至经过参数的顺序也可以调用不一样的构造器.不过通常是不推荐这样使用的.
spa

  ii.默认构造器.

  默认构造器被称为无参构造器,做用就是建立一个默认的对象.若是咱们的类中没有定义一个默认构造器,那么编译器会自动为咱们建立一个默认的构造器.不难发现.咱们在写一个class的时候,即便不书写默认构造器,咱们仍然能够建立一个普通的对象.

class Darker{
    public String getDarker() {
        return darker;
    }
    public void setDarker(String darker) {
        this.darker = darker;
    }
    private String darker;
}

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Darker darker = new Darker();
        darker.setDarker("darker");
        System.out.println(darker.getDarker());
    }
}
/**
 *OutPut
 *darker 
 */

  咱们能够看到,咱们即便不去定义一个默认构造器去建立对象仍然是没有任何问题的.由于编译器会自动为咱们加上一个默认构造器.可是这里有一个陷阱..

package com.thinking.in.java;

class Darker{
    
    private String darker;
    
    public Darker(String darker){
        this.darker = darker;
    }
    
//    public Darker(){
//    
//    }
    
    public String getDarker() {
        return darker;
    }

    public void setDarker(String darker) {
        this.darker = darker;
    }
    
}

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Darker darker = new Darker();
        darker.setDarker("darker");
        System.out.println(darker.getDarker());
    }
}

  这个代码和上面的那个区别在于咱们定义了一个有参构造器.可是正是因为这个定义,咱们就没法使用经过无参构造器去建立一个对象.Darker darker = new Darker(); 这句话连编译都没法经过.直接报错 The constructor Darker() is undefined .也就是咱们的无参构造器没有定义.这是什么缘由呢？这里的问题就取决于Java的机制.若是咱们没有去书写任何一个构造器,那么Java会自动为咱们添加上一个默认的构造器,咱们能够直接构造对象.可是若是咱们定义了一个构造器(注意:有参构造器).那么Java就会明白:你已经定义了一个构造器了,因此你知道本身在作什么.只是忽略掉了默认构造器.这样Java就不会为咱们添加默认构造器了.前面一直在说有参,若是咱们把默认构造器的注释拿掉,那么咱们 Darker darker = new Darker()这句话就不会出错了.

 iii.涉及基本类型的重载

 基本类型的重载涉及的东西并非不少.只是涉及了两个概念..扩辗转型和窄化转型.

 扩辗转型:

package com.thinking.in.java;

public class Main {
    void f1(char x) {System.out.print("f1(char) ");}
    void f1(byte x) {System.out.print("f1(byte) ");}
    void f1(short x) {System.out.print("f1(short) ");}
    void f1(int x) {System.out.print("f1(int) ");}
    void f1(long x) {System.out.print("f1(long) ");}
    void f1(float x) {System.out.print("f1(float) ");}
    void f1(double x) {System.out.print("f1(double) ");}

    void f2(byte x) {System.out.print("f2(byte) ");}
    void f2(short x) {System.out.print("f2(short) ");}
    void f2(int x) {System.out.print("f2(int) ");}
    void f2(long x) {System.out.print("f2(long) ");}
    void f2(float x) {System.out.print("f2(float) ");}
    void f2(double x) {System.out.print("f2(double) ");}

    void f3(short x) {System.out.print("f3(short) ");}
    void f3(int x) {System.out.print("f3(int) ");}
    void f3(long x) {System.out.print("f3(long) ");}
    void f3(float x) {System.out.print("f3(float) ");}
    void f3(double x) {System.out.print("f3(double) ");}
    
    void f4(int x) {System.out.print("f4(int) ");}
    void f4(long x) {System.out.print("f4(long) ");}
    void f4(float x) {System.out.print("f4(float) ");}
    void f4(double x) {System.out.print("f4(double) ");}

    void f5(long x) {System.out.print("f5(long) ");}
    void f5(float x) {System.out.print("f5(float) ");}
    void f5(double x) {System.out.print("f5(double) ");}

    void f6(float x) {System.out.print("f6(float) ");}
    void f6(double x) {System.out.print("f6(double) ");}

    void f7(double x) {System.out.print("f7(double) ");}
    
    void testConstVal() {
        System.out.print("5: ");
        f1(5);f2(5);f3(5);f4(5);f5(5);f6(5);f7(5);
    }

    void testChar() {
        char x = 'x';
        System.out.print("char: ");
        f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
    }

    void testByte() {
        byte x = 0;
        System.out.print("byte: ");
        f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
    }

    void testShort() {
        short x = 0;
        System.out.print("short: ");
        f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
    }

    void testInt() {
        int x = 0;
        System.out.print("int: ");
        f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
    }

    void testLong() {
        long x = 0;
        System.out.print("long: ");
        f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
    }

    void testFloat() {
        float x = 0;
        System.out.print("float: ");
        f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
    }

    void testDouble() {
        double x = 0;
        System.out.print("double: ");
        f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Main m = new Main();
        m.testConstVal();m.testChar();m.testByte();m.testShort();
        m.testInt();m.testLong();m.testFloat();m.testDouble();
    }
}
/* Output:
5: f1(int) f2(int) f3(int) f4(int) f5(long) f6(float) f7(double)
char: f1(char) f2(int) f3(int) f4(int) f5(long) f6(float) f7(double)
byte: f1(byte) f2(byte) f3(short) f4(int) f5(long) f6(float) f7(double)
short: f1(short) f2(short) f3(short) f4(int) f5(long) f6(float) f7(double)
int: f1(int) f2(int) f3(int) f4(int) f5(long) f6(float) f7(double)
long: f1(long) f2(long) f3(long) f4(long) f5(long) f6(float) f7(double)
float: f1(float) f2(float) f3(float) f4(float) f5(float) f6(float) f7(double)
double: f1(double) f2(double) f3(double) f4(double) f5(double) f6(double) f7(double)
*///:~

  上面这段代码其实就涉及到了扩辗转型,扩辗转型:将存储数据信息量小的类型,转换成存储数据信息量较大的类型.从testConstVal()函数中就能够看出来了.咱们传递的int = 5..是个int值常量.在f1()-f4()中都可以找到能够接收int的参数.可是在f5()-f7()中就没法找到可以接收int类型的函数,那么这里就会使用到扩辗转型.将int = 5提高为long,float,double.由于扩辗转型是不存在数据信息丢失的问题.所以这种转化是相对安全的.这里有一个特例,针对char类型,若是没有找到与char类型匹配的函数,会直接将char转化成int类型.

 窄化转型:

public class Main {
    
     void f1(char x) { System.out.print("f1(char)"); }
     void f1(byte x) { System.out.print("f1(byte)"); }
     void f1(short x) { System.out.print("f1(short)"); }
     void f1(int x) { System.out.print("f1(int)"); }
     void f1(long x) { System.out.print("f1(long)"); }
     void f1(float x) { System.out.print("f1(float)"); }
     void f1(double x) { System.out.print("f1(double)"); }

     void f2(char x) { System.out.print("f2(char)"); }
     void f2(byte x) { System.out.print("f2(byte)"); }
     void f2(short x) { System.out.print("f2(short)"); }
     void f2(int x) { System.out.print("f2(int)"); }
     void f2(long x) { System.out.print("f2(long)"); }
     void f2(float x) { System.out.print("f2(float)"); }

     void f3(char x) { System.out.print("f3(char)"); }
     void f3(byte x) { System.out.print("f3(byte)"); }
     void f3(short x) { System.out.print("f3(short)"); }
     void f3(int x) { System.out.print("f3(int)"); }
     void f3(long x) { System.out.print("f3(long)"); }

     void f4(char x) { System.out.print("f4(char)"); }
     void f4(byte x) { System.out.print("f4(byte)"); }
     void f4(short x) { System.out.print("f4(short)"); }
     void f4(int x) { System.out.print("f4(int)"); }

     void f5(char x) { System.out.print("f5(char)"); }
     void f5(byte x) { System.out.print("f5(byte)"); }
     void f5(short x) { System.out.print("f5(short)"); }

     void f6(char x) { System.out.print("f6(char)"); }
     void f6(byte x) { System.out.print("f6(byte)"); }

     void f7(char x) { System.out.print("f7(char)"); }

     void testDouble() {
       double x = 0;
       System.out.print("double argument:");
       f1(x);f2((float)x);f3((long)x);f4((int)x);
       f5((short)x);f6((byte)x);f7((char)x);
     }
     
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Main m = new Main();
        m.testDouble();
    }
}
/* Output:
double argument:f1(double)f2(float)f3(long)f4(int)f5(short)f6(byte)f7(char)*///:~

  咱们能够看到,咱们此次针对double = 0 这个常量进行测试,从f2()-f7()就没法找到与double请求参数所匹配的函数.这里就涉及到了窄化转型.因为没有合适的类型,所以只能将double进行窄化转型,转为float,long,int以此类推.由于咱们若是想要函数正常运行,就必须使用窄化转型,不然就会报错.可是窄化转型会将存储数据信息量大的类型转化成存储数据信息小的类型.这样就很容易致使数据信息丢失的状况.所以通常状况下是不推荐的.

 iv.成员初始化

 成员初始化没有什么过多可说的,咱们只须要知道.在咱们定义局部变量的时候,在定义的同时须要进行初始化操做,不然咱们是没法使用当前的局部变量的.可是若是咱们在一个类中定义了成员变量,那么咱们能够在定义的时候不去进行初始化操做,Java会自动的帮咱们执行初始化的操做.

//函数中的局部变量若是在定义的时候没被初始化,会出现异常.
void f(){
   int i;
   i++;  //Error  
}
//类中的成员变量,在被定义的时候就被初始化了.
public class Main {
    private int dint;
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(new Main().dint);  //init 0 
    }
}

  v.静态数据的初始化

 针对静态数据,仍是有一些东西须要注意的,咱们都知道静态数据在内存单元中只占用一块存储区域,不管有多少个对象建立.是一个做用于域范围的变量.没法当作局部变量去看待.而且当静态数据一旦被初始化以后,后续就不会再次执行初始化的操做.

class Static{
    public Static() {
        // TODO Auto-generated constructor stub
    }
    
    public void Print(){
        System.out.println("Static");
    }
}
class TestStatic{
    static Static s = new Static(); 
    public TestStatic() {
        // TODO Auto-generated constructor stub
        s.Print();
        s1.Print();
    }
    static Static s1 = new Static();
}
public class Main {
        
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new TestStatic();
    }
}

  总结一下对象初始化的过程.好比说有一个类.那么对象被建立以前,JVM首先会找到类的指定路径.定位.class文件(字节码文件).而后JVM将.class文件装载.这时有关当前类的静态初始化操做将所有完成.(静态初始化只在Class对象首次加载的时候执行一次).当咱们去new对象的时候,JVM会在堆区中开辟一块内存,内存首先被清0,而后将类中全部的变量进行初始化.最后执行构造方法.

 

2.清理/垃圾回收

  初始化涉及的内容并非特别的多,而且相对而言也比较的简单,清理才是须要重点掌握的地方.

  为何须要垃圾回收,垃圾回收是针对内存而言的,之因此进行垃圾回收是针对某块内存已经再也不进行使用的时候,那么这块内存中的数据就要被回收,也就被称为所谓的"垃圾".可是回收并非时时刻刻都在调用的.由于GC的使用也会耗费必定的资源.而且咱们还须要明确一点就是，垃圾回收并不能保证必定会被运行.由于它所针对的是内存空间是否充足.

  i.finalize()函数.

  在读编程思想的时候看到了这个方法,虽然知道,可是一直也不明确这个方法具体用在什么地方.何时调用.简单的说一下.

  首先finalize()函数是针对一种"特殊"的方式为某个对象申请了一块特殊的内存空间.因为GC只知道释放由new方式建立的对象.所以若是咱们使用了一种特殊的方式为某个对象申请了一块特殊的内存空间.就须要使用finalize()函数执行清理.

  咱们都知道Java是使用new去建立对象的,那么这种特殊的方式究竟是怎样的？这种特殊的方式多是在分配内存的时候使用了C语言的方式为对象分配了内存,而不是Java一般的方式,这种方式发生在使用"本地方法"的时候发生的,也就是Java中的native方法,经过JNI与C/C++进行交互,那么本地方法就由C/C++来执行了,那么C语言分配内存的方式是经过使用malloc()方法来分配内存的.那么使用malloc()方法分配内存空间以后,在不使用的时候须要使用free来进行释放,若是咱们没有去调用free函数去释放内存,那么这块内存将一直不会被释放,也就致使了内存泄漏,由于free是C/C++中才有的方法,所以咱们若是想使用free就须要经过使用finalize()中用本地方法进行调用.

  所以在垃圾清理的时候咱们是不能期望使用finalize()函数的.那么垃圾回收就须要使用到咱们熟悉的东西了.

  ii.Garbage Collection(GC)

  垃圾回收器.概念相比你们都很是熟悉,在这里不进行多余的说.具体要说的是它的工做原理.

  GC的工做原理:

  对于工做原理就不得不说说引用计数法：

  好比说没个对象都有一个计数器,当对象被建立的时候,计数器的数值设置为1,当咱们再也不使用这个对象的时候,对象已经离开了做用域或者是null的时候,计数器的数值设置为0,而后垃圾回收期在全部的对象列表上进行遍历,而后将计数器为0的对象进行回收,是否是感受这样的设计仍是比较合理的呢？可是其实这种设计是有很大的缺陷的.若是咱们的对象之间存在循环调用.那么就会出现,对象应该被回收,可是计数器却不为0的状况.针对这种状况须要具体说一下了.

  引用计数法虽然经常使用在解释垃圾收集的方式,可是没有一个JVM是使用这种算法的.

public class GcDemo {

    public static void main(String[] args) {
        GcObject obj1 = new GcObject(); //Step 1
        GcObject obj2 = new GcObject(); //Step 2

        obj1.instance = obj2; //Step 3
        obj2.instance = obj1; //Step 4

        obj1 = null; //Step 5
        obj2 = null; //Step 6
    }
}

class GcObject{
    public Object instance = null;
}

  咱们来看一下上面这个例子,若是使用引用计数法会致使什么问题.

 

  1：GcObject实例1的引用计数加1，实例1的引用计数=1；

  2：GcObject实例2的引用计数加1，实例2的引用计数=1；

  3：GcObject实例2的引用计数再加1，实例2的引用计数=2；

  4：GcObject实例1的引用计数再加1，实例1的引用计数=2；执行到4，则GcObject实例1和实例2的引用计数都等于2。

  5：栈帧中obj1再也不指向Java堆，GcObject实例1的引用计数减1，结果为1；

  6：栈帧中obj2再也不指向Java堆，GcObject实例2的引用计数减1，结果为1。到此，发现GcObject实例1和实例2的计数引用都不为0，那么若是采用的引用计数算法的话，那么这两个实例所占的内存将得不到释放，这便产生了内存泄露。

  执行完5-6步的结果以下.

  这样引用计数算法在JVM是没有办法获得应用的.所以JVM采用另外一种模式的算法来解决这样状况的发生.

   可达性算法:

   现现在的Hotspot 中的minor GC就是使用这种算法.其中的核心就是图论.图中能够到达的对象就是活对象,没法到达的对象就应该被回收.这种算法有点相似于BFS算法(即:广度优先搜索遍历).从根节点出发.遍历整个图中的全部节点.可以到达的对象即构成连通的,不能到达的地方为不通的.知道BFS算法的应该都特别的清楚.不过minor GC使用的是Cheney算法的变种.根节点为GC Roots而且能够有多个.这些节点被存储在一个队列当中.而后开始遍历整个图.遍历到的对象就是活的.遍历不到的就须要回收.

   GC Roots可使本地方法栈中JNI所引用的对象，虚拟机栈的栈帧局部变量所引用的对象，以及方法区中静态变量或者常量所引用的对象.

 

  reference1->对象实例1；reference2->对象实例2；reference3-> 对象实例4；reference3->; 对象实例4 ->对象实例6；

  能够得出对象实例一、二、四、6都具备GC Roots可达性，也就是存活对象，不能被GC回收的对象。而对于对象实例三、5直接虽然连通，但并无任何一个GC Roots与之相连，这即是GC Roots不可达的对象，这就是GC须要回收的垃圾对象。回过头来看看最前面的实例，GcObject实例1和实例2虽然从引用计数虽然都不为0，但从可达性算法来看，都是GC Roots不可达的对象。总之，对于对象之间循环引用的状况，引用计数算法，则GC没法回收这两个对象，而可达性算法则能够正确回收。   

  最后介绍一下堆区:由于对象的内存分配都是在堆区当中的.堆区的结构以下:

 

  堆区的结构如上图.全部经过new建立的对象的内存都在堆中分配，堆被划分为新生代和旧生代，新生代又被进一步划分为Eden和Survivor区，最后Survivor由FromSpace和ToSpace组成，结构图新生代。新建的对象都是用新生代分配内存，Eden空间不足的时候，会把存活的对象转移到Survivor中，新生代大小能够由-Xmn来控制，也能够用-XX:SurvivorRatio来控制Eden和Survivor的比例。旧生代用于存放新生代中通过屡次垃圾回收 (也即Minor GC) 仍然存活的对象.也就是通过Cheney变种算法从From区拷贝到堆区的对象.这就是GC的垃圾回收机制.

  Java的垃圾回收器被称为自适应的,分带的,中止-复制，标记-清扫式垃圾回收器.其缘由在于他的工做方式,所谓的自适应是它能够根据不一样方式切换到不一样的工做状态.分表明示在执行中止-复制状态的时候,不一样的内存块会有不一样的代数来判断当前的对象是否存活.所谓的自适应的状态就表示中止-复制和标记-清扫的状态的切换.至于什么是中止-复制，清扫-标记这两个概念我就不进行多说了,Java编程思想上给了明确的概念.

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程