JAVA编程思想笔记--初始化与清理

• foreach语法：一种新的更加简洁的for语句用于数组和容器，表示不必创建int变量去对由访问项构成的序列进行计数，foreach将自动产生每一项for(float x:f){} 定义了一个float类型的变量，继而将每一个f的元素赋值给x。

float f[] = new float[10];
for(float x : f)
  System.out.println(x);

• break用于强制退出循环，不执行循环中剩下的语句。而continue则停止执行当前迭代，然后退出循环起始处，开始下一次迭代。

    public static void main(String[] args) {
        int i = 0 ;

          while(true){
              i++;
              int j = i*27 ;
              if(j==1269)break;  //跳出循环
              if(i % 10 !=0)continue; //返回循环头部
              System.out.println(i+"");
          }
    }

• break和continue跟goto一样，使用相同的机制：标签 ；

---

---

---

• 初始化与清理： 清理指当使用完一个资源时，需要把占用的资源释放。

• 当创建一个对象时，也就给此对象分配到的存储空间取一个名字。

• 区分重载方法：每个重载的方法都必须有一个独一无二的参数类型列表

//方法的重载
public class Tree {
  int height;
  Tree(){
      height = 0 ;
  }
  Tree(int initialHeight){
      height = initialHeight;
  }
  void info(){
      System.out.println("Tree is " + height +"feet tall");
  }
  void info(String s){
      System.out.println(s + ": Tree is" + height + "feet tall");
  }
}

• 涉及基本类型的重载(构造方法，int,char,short)：如果传入的数据类型(实际参数类型)小于方法中声明的形式参数类型，实际数据类型就会被提升。char型略有不同，如果无法找到恰好接受char参数的方法，就会把char直接提升到int型。2.如果传入的实际参数较大，就得通过类型转换来执行窄化转换。

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

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

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

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

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

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

   void f7(double x){System.out.println("f7(double)");}

   void testConstVal(){
       System.out.println("5: ");
       f1(5);f2(5);f3(5);f4(5);f5(5);f6(5);f7(5);

   }

}
//output: 5:f1(int) f2(int) f3(int) f4(int) f5(long) f6(float)
//发现常数值5被当作int值处理，所以如果有某个重载方法接受int型参数，它就会被调用
//至于其他情况，如果传入的数据类型小于方法中声明的形式参数类型，实际数据类型就会被提升。

• 如果已经定义了一个构造器(无论是否有参数)，编译器就不会帮你自动创建默认构造器。

• this关键字只能在方法内部使用，表示对”调用方法的那个对象”的引用。

• static的含义：static方法就是没有this的方法，在static方法的内部不能调用非静态方法，反过来倒是可以。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途

• 垃圾回收器只知道释放那些经由new分配的内存，假定你的对象(并非使用new)获得一块”特殊”的内存区域，所以它不知道该如何释放改对象的这块”特殊”内存。

• 只要程序没有频临存储空间用完的那一刻，对象占用的空间就总得不到释放。对象可能不被垃圾回收。垃圾回收只与内存有关。

• 类的每个基本类型数据成员保证都会有一个初始值。

public class InitialValues {
    boolean t ;
    char c ;
    byte b ;
    short s ;
    int i ;
    long l ;
    float f ;
    double d ;
    InitialValues reference ;
    void printInitialValues(){
        System.out.println("Data type   Initial value");
        System.out.println("boolean     "+t);
        System.out.println("char        "+c);
        System.out.println("byte        "+b);
        System.out.println("short       "+s);
        System.out.println("int         "+i);
        System.out.println("long        "+l);
        System.out.println("float       "+f);
        System.out.println("double      "+d);
        System.out.println("reference   "+reference);
    }
}

//输出：
//boolean     false
//char        
//byte        0
//short       0
//int         0
//long        0
//float       0.0
//double      0.0
//reference   null

初始化顺序：在类的内部，变量定义的先后顺序决定了初始化的顺序，即使变量定义散布于方法定义之间，它们仍旧会在任何方法(包含构造器)被调用之前得到初始化

public class Window {
   Window(int marker){
       System.out.println(marker);
   }
}

public class House {
    Window w1 = new Window(1);  //第一个执行
    House(){
        System.out.println("House构造方法初始化");
        w3 = new Window(33);  //第四个执行
    }
    Window w2 = new Window(2); //第二个执行
    void f(){
        System.out.println("f()");
    };
    Window w3 = new Window(3); //第三个执行

}

//变量定义散布于方法之间，它们仍旧会在任何方法(包括构造器)被调用之前得到初始化
public class ArrayMaker  {   

    public static void main(String[] args) {
         House h = new House();
         h.f();
    }

}

• 静态数据的初始化
  1.static关键字不能应用于局部变量，因此只能作用于域。
  2.如果一个域是静态的基本类型域，且也没有对它进行初始化，那么它就会获得基本类型的标准初值；如果是一个对象引用，那么它的默认初始化值就是null。

//显示类
public class Bowl {
    Bowl(int marker){
        System.out.println("Bowl("+marker+")");
    }

    void f1(int marker){
        System.out.println("f1("+marker+")");
    }
}


public 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);  //第二个执行
}


public 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);  //第二个执行
}

public class ArrayMaker  {   

    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(); //第二个执行

}

1.初始化的顺序是先静态对象(如果它们尚未因前面的对象创建过程而被初始化),而后是”非静态”对象。

public class Counter{
   int i ;
   Counter(){ i = 7;} 
   }

那么i首先会被置0，然后变成7.

2.静态初始化动作只进行一次。

• 非静态实例初始化

public class Mugs {
    Mug mug1;
    Mug mug2;

    {//实例初始化子句是在两个构造器之前执行
        mug1 = new Mug(1);
        mug2 = new Mug(2);
    }

    Mugs(){

    }

    Mugs(int i){

    }
}

8.数组的初始化
在java中可以将一个数组赋值给另一个数组，其实真正做的只是复制了一个引用。

int[] a1 = {1,2,3,4,5};
int[] a2 ;
a2 = a1 ;


//例子：
public class ArrayMaker  {   

    public static void main(String[] args) { 
        int[] a1 = {1,2,3,4,5};
        int[] a2 ;
        a2 = a1 ;
        for(int i = 0 ;i1 ;
        for(int i = 0 ;iout.println("a1["+i+"]=" + a1[i]);
        }
    }

    //输出：a1[0] = 2  ..........

}

(1)int[] a :数组元素中的基本数据类型会自动初始化成空值(对于数字和字符，就是0:对于布尔值，是false)。

(2)整型包装器类Integer它是一个类而不是基本类型。

• 枚举类型：枚举类型的实例是常量，因此按照命名习惯它们都用大写字母表示。enum是一个类

public class ArrayMaker  {   

    public static void main(String[] args) { 
         Spiciness  howHot = Spiciness.MEDIUM; //1.
         System.out.println(howHot);

         //ordinal用来表示某个特定enum常量声明顺序
         for(Spicness s:Spicness.values())  //2.
             System.out.println(s+",ordinal"+s.ordinal()); 
    }

    public enum Spiciness {
        NOT,MILD,MEDIUM,HOT,FlAMING
    }

}

2.enum在switch中的实用

public class ArrayMaker {

    public static void main(String[] args) {
         describe(Spiciness.NOT);
    }

    public enum Spiciness {
        NOT, MILD, MEDIUM, HOT, FlAMING
    }

    //static 方法中只能调用  static 方法
    public static  void describe(Spiciness degree) {
        switch (degree) {
        case NOT:
            System.out.println("NOT");
            break;

        case MILD:
            System.out.println("MILD");
            break;

        default:
            break;
        }
    }
}