think in java第五章 初始化与清理 总结随笔

时间：2022-02-22 21:49:26

正如章节名本章主要讲解的是java的初始化和清理的知识。下面就是我对本章的总结。

用构造器确保初始化

在这一小节中最少需要理解的有两个方面：

        1) 构造器是如何确保在创建对象时使之得到初始化。java是一门采用了构造器的语言（就我了解过的面向对象语言都采用了构造器这种初始化机制），在对象创建时，如果其类具有构造器，java就会在用户有能力操作对象之前自动的调用相应的构造器，从而保证初始化的进行。

        2) 如何使用构造器进行对象初始化。我们知道调用构造器是编译器完成的，为了让编译器明白去调用哪个方法，java中规定构造器的名称和类名称相同。构造器可以分为无参构造器（默认构造器）和有参构造器。

带有构造器（无参）的简单类：

public class SimpleConstructor {
public static void main(String[] args) {
new Dog();
}
}
class Dog {
Dog(){//this is the constructor
System.out.println("旺财");
}
}

带有构造器（有参）的简单类：

public class SimpleConstructor {
public static void main(String[] args) {
new Dog("旺财");
}
}
class Dog {
Dog(String str) {
System.out.println(str);
}
}

方法重载

方法重载概述: 在同一个类中，允许存在超过一个的同名的方法，前提是它们各自的参数个数或者参数类型不同即可。

方法重载特点: 与返回值类型无关，只看方法名和参数列表。

用例：重载的构造器和重载的方法

public class SimpleConstructor {
public static void main(String[] args) {
Dog d =new Dog("旺财");
d.info();
d.info("旺财");
}
}
class Dog {
String name;
Dog() {//无参
System.out.println("汪汪");
}
Dog(String str) {//有参
name = str;
System.out.println(str);
}

void info() {
System.out.println("这是一只狗");
}
void info(String str) {
name = str;
System.out.println(str + "是一只狗" );
}
}

用例：重载的构造器和重载的方法

public class SimpleConstructor {
public static void main(String[] args) {
Dog d =new Dog("旺财");
d.info();
d.info("旺财");
}
}
class Dog {
String name;
Dog() {//无参
System.out.println("汪汪");
}
Dog(String str) {//有參
name = str;
System.out.println(str);
}

void info() {
System.out.println("这是一只狗");
}
void info(String str) {
name = str;
System.out.println(str + "是一只狗" );
}
}

默认构造器和this关键字

当你写的类中没有构造器，编译器会帮你自动创建一个默认的构造器。

关于this的总结：Java中的this与面向对象的程序设计密切相关，它表示当前对象。

this关键字详解：

     抛出问题：  如果有两个相同类型的对象a和b去调用同一个方法info()，如果只有一个info()方法，它如何才能知道被哪个对象所调用呢？

public class SimpleConstructor {
public static void main(String[] args) {
Dog a = new Dog();
Dog b = new Dog();

                a.info();
                b.info();

 }}

     重点：编译器会将操作对象的引用作为第一个参数传递给info()。

Dog.info(a);
Dog.info(b);

因为上述对象的引用传递是编译器传入的，没有标识符可用，所以选用this这个关键字表示调用方法的那个对象。
清理：终结处理和回收垃圾

针对java的终结处理和回收垃圾自己现在也是一知半解，很难将所知道的总结成语言，下面是一篇专门介绍java的终结处理和垃圾回收的博客。我觉得写的很不错

地址:http://blog.csdn.net/xiaotian15/article/details/8246309

成员初始化

java尽力保证：所有变量在使用前都能得到恰当的初始化。

每一个基本类型数据成员保证都会有一个初始值；引用数据类型在未得到初始化时，该引用就会得到一个特殊值null；
构造器初始化
使用构造器来进行数据初始化，它将在构造器被调用之前发生。

public class Constructor {
int i;
public Constructor() {
i = 1;
}
}

在类的内部，初始化的顺序取决于变量定义的先后顺序。即使变量定义在方法定义之间，它们仍然会在任何方法被调用之前得到初始化。 

public class SimpleConstructor {
public static void main(String[] args) {
BigDog bg = new BigDog();
}

}
class Dog {
    public Dog(int i) {
        System.out.println(i);
    }
}
class BigDog {
Dog d1 = new Dog(1);
BigDog() {
    d3 = new Dog(4);
}
    Dog d2 = new Dog(2);
    Dog d3 = new Dog(3);
}
结果：1234

static数据的初始化：无论创建多少个对象，静态数据永远只占用一份存储空间。static关键字不能应用于局部变量，因此它只能作用于域。如果一个域是静态的基本类型域，且没有对它进行初始化，那么它就会获得基本类型的标准初值，而如果它是一个对象的引用，则默认初始值为null。

了解静态存储区域何时初始化： 

public class StaticInitialization { 
public static void main(String args[]) {  
System.out.println("Creating new Cupboard() in main");  
new Cupboard();  
System.out.println("Creating new Cupboard() in main");  
new Cupboard();  
table.f2(1);  
cupboard.f3(1);  
}  
static Table table=new Table();  
static Cupboard cupboard=new Cupboard();  
}
class Bowl{  
    Bowl(int marker){  
        System.out.println("Bowl("+marker+")");  
    }  
    void f1(int marker){  
        System.out.println("f1("+marker+")");  
    }  
}  
class Table{  
    static Bowl bowl1=new Bowl(1);  
    Table(){  
        System.out.println("Table()");  
        bowl2.f1(1);  
    }  
    void f2(int marker){  
        System.out.println("f2("+marker+")");  
    }  
    static Bowl bowl2=new Bowl(2);  
}  

class Cupboard{  
    Bowl bowl3=new Bowl(3);  
    static Bowl bowl4=new Bowl(4);  
    Cupboard(){  
        System.out.println("Cupboard()");  
        bowl4.f1(2);  
    }  
    void f3(int marker){  
        System.out.println("f3("+marker+")");  
    }  
    static Bowl bowl5=new Bowl(5);  
}
答案：
Bowl(1)
Bowl(2)
Table()
f1(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f1(2)
f2(1)
f3(1)

数组初始化

数组的三种初始化方式：

public class TestArray {
public static void main(String[] args) {
//定义
int[] a;
int[] b;
//创建数组对象
a = new int[3];
b = new int[4];
/*
 * 1.默认初始化 
 * 数组元素相当于对象的成员变量，默认值跟成员变量的规则一样。数字0，布尔false，char\u0000，引用：null；
 */

/*
 * 2.动态初始化
 */
for(int i=0;i<a.length;i++) {
a[i] = i*2;
}
/*
 * 3.静态初始化
 */
int c[] = {1,2,3,4};

}
}

枚举类型

它是一种新的类型（其实也可以看作类），允许用常量来表示特定的数据片断，而且全部都以类型安全的形式来表示。

总结

我觉得本章的重点是要理解好构造器，这种初始化机制；还有就是java的垃圾回收机制的理解。



标签：

相关文章