java初始化机制（一）

1、初始化一般是通过构造器进行初始化的，如果类中没有写构造器则编译器自动为其提供默认构造器。如果程序中已经写了构造器，则编译器不会提供默认构造器。

Banana b=new Banana();

2、构造器的重载

如果想要以多种方式创建一个对象该怎么办？

方法名相同，参数个数（或类型）不同的构造器同时存在，就是构造器重载。构造器重载是必须的，但是也可以应用到其他方法中。

//构造器重载

<span style="color:#000000;">public Constructor02(){} 
 public Constructor02(int i){} 
 public Constructor02(int i,int j){} 
 public Constructor02(float i){}</span>

3、构造方法区分

每个重载方法都有一个唯一的参数类型列表，用来区分具体调用哪个方法。

但是基本类型能够从一个较小的类型自动提升至一个较大的类型。如果传入的数据类型小于方法中声明的形式参数类型，实际数据类型就会被提升。char型略有不同，如果无法找到恰好接受char参数的方法，就会把char直接提升到int.

提升顺序为：byte<short<int<long<float<double:如果是说实际类型是byte类型，它首先向上提升为short,如果没有short类型，则提升为int,如果没有int则提升为long......

char直接提升为int及以上的类型。

<span style="color:#000000;">package jin.feng1; 
class Constructor02{ 
 public Constructor02(){} 
 public Constructor02(int i){} 
 public Constructor02(int i,int j){} 
 public Constructor02(float i){} 
 //void print(int i){ System.out.println("int");} 
 void print(float i){ System.out.println("float");} 
 //void print(char i){ System.out.println("char");} 
 void print(short i){ System.out.println("short");} 
 void print(double i){ System.out.println("double");} 
} 
public class Constructor01 
{ 
 public static void main(String[] args) 
 { 
 Constructor02 constructor02=new Constructor02(); 
 char c='a'; 
 int a=1; 
 float b=9; 
 double d=9; 
 constructor02.print(c); 
 } 
} 
//output
float
</span>

4、为什么返回值区分不了重载方法

例如方法定义如下：

void f(){}
int f(){return 1;}
调用的时候f(),则编译器不知道该调用哪个方法。所以用返回值区分是行不通的。

5、this关键字

this表示当前对象的引用

如果你希望在方法内部获得对当前对象的引用，this关键字只能在方法内部使用，表示对“调用方法的那个对象”的引用。

package jin.feng1; 
class Banana{ 
 void print(){} 
 void peel(int i){ 
  print();//直接调用，编译器自动转变为this.print() 
 } 
} 
public class This01 
{ 
 public static void main(String[] args) 
 { 
 Banana a=new Banana(); 
 Banana b=new Banana(); 
 a.peel(1);//编译自动添加this 转变为Banana.peel(a,1) 
 b.peel(2); 
 } 
} 

一般编译器都会帮你自动添加，所以只有当需要明确指出对当前对象的引用时，才需要使用this关键字。

Banana increment(){

  i++;

  return this; //

 }

将当前对象传递给其他方法：

return Peel.peel(this);

 

如果想要在构造器中调用构造器，避免重复

<span style="color:#000000;BACKGROUND-COLOR: #ffffff">public Constructor02(){} 
 public Constructor02(int i){this();} //产生符合此参数列表的某个构造器的明确调用
 public Constructor02(int i,int j){this(i);} 
 public Constructor02(float i){}</span>

6、static关键字

一个类中static方法只能访问static类型，还可以通过创建对象进行访问其他非static方法（一般是main方法中，其他方法中没什么实际意义）。

但是非static方法既能够访问static变量又能够访问static方法。

<span style="color:#000000;">class Banana{ 
 int j; 
 static int i; 
 static void count(){ 
  Banana b9=new Banana();
  b9.i=9; 
  b9.j=8; //通过创建对象访问其非static类型的
  b9.print(); //通过创建对象访问其非static类型的
  //j++;  不可直接访问
  //print(); 
  i++;//直接访问static变量 
 } 
 void print(){ //非static方法直接访问static成员。
  System.out.println("i:"+i); 
  count(); 
 } 
 Banana increment(){ 
  i++; 
  return this; 
 } 
}
</span>

注意：static成员每个类仅仅只有一份

static类型的成员变量一般用来计数，因为每个类仅仅只有一份，可以对创建对象进行计数啊

但是static类型的成员方法有什么用？

静态方法是类内部的一类特殊方法，只有在需要时才将对应的方法声明成静态的，一个类内部的方法一般都是非静态的 那在什么时候需要呢？

 
 

  
  一般是为了方便调用才会声明为static方法:
 
 
 
 

  
  

   
   

    
    

     
     

      
      
 
       
例如为了方便方法的调用，Java API中的Math类中所有的方法都是静态的，而一般类内部的static方法也是方便其它类对该方法的调用。
 
       
 
        
 
         
 
          
 
           
 
            
 
             
注意使用：
 
             
              
              

               
               静态方法可以直接通过类名调用，任何的实例也都可以调用，
              
              

              
              

               
               因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。
              
              
              
              

               
               因为实例成员与特定的对象关联！这个需要去理解，
               
               因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。