学习内容:
1.初始化
2.清理
1.初始化
虽然自己的Java基础还是比较良好的..但是在解读编程思想的时候还是发现了许多的细节问题自己并没有完全的掌握.既然是研磨,那么就应该更加的细致.
i.构造方法的重载.
首先说明一下,为什么构造方法需要重载.
需要重载的一个重要原因就是,因为我们的构造器只能有一个名字,也就是和类名相同.但是如果我们需要通过不同的方式去构造一个对象的时候我们该如何是好？那么这里就需要通过对构造器的重载来实现.这样就需要多个构造器来实现.首先就是需要一个默认的构造器,然后其他的构造器就需要通过在重载构造器的方式来构造不同的构造器(针对不同的参数).
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如何知道要走哪个方法去构造一个对象呢？其实不难理解,由于方法名称相同,那么无非就是通过参数的不同来识别.甚至通过参数的顺序也能够调用不同的构造器.不过一般是不推荐这样使用的.
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,然后将类中所有的变量进行初始化.最后执行构造方法.
