java学习第五篇下（对象与类）

方法重载：

        同一类中有多个方法名相同但参数列表不同的方法，这种现象称为方法重载。其中参数列表不同包括以下情形：

                   1、参数的个数不同

                   2、参数对应的类型不同

public class Computer{
    int add(int a,int b){
         return a+b;        
    }
    void add(int a,int b,int c){
         int result=a+b+c;
        System.out.println(result);
    }
    public int add(int a,int b,int c,int d){
         return a+b+c+d;   
    }

}

注意：

             1、参数列表不同并不包含参数名不同，也就是说如果方法名相同，方法中的参数个数和类型相同，只是参数名不同，这样也不能称之为方法重载。

                2、方法中的其他构成成分不参与比较，访问控制符、修饰符、返回值类型。

一个类中有许多同名方法（构造方法或普通方法），在调用这些方法时，到底调用哪个方法取决于调用方法时参入参数的数据类型和个数。

public class Teacher{
    public static void print(int age,String name){
        System.out.println(age+","+name);
    }
    public static void print(String name,int age){
        System.out.println(name+","+age);
     }
    public static void main(String []args){
        print(33,"小明");
        print("小明",33);
  
    }
} 

代码块：

java中的代码块分为静态代码块和非静态代码块

静态代码块只在类加载时执行一次：

public class Test{
    static {
          System.out.println("静态代码块");
    }

    public static void main(String []args){
    }
}

               非静态代码块每次创建对象都会执行

public class Test{
      {
          System.out.println("非静态代码块");
      }
      public class void main(String []args){
            new Test();
            new Test();
     } 
}

             执行如下代码结果为

public class Test{

     {
          System.out.println("非静态代码块");
     }
     static {
          System.out.print("静态代码块");
     }
     public static void main(String []args){
           new Test();
           new Test();
     }
}

        结果为：静态代码块

                       非静态代码块

                       非静态代码块

全局变量与局部变量：

成员变量：实例属性和类属性（static修饰）

局部变量：形参（定义在方法括号中的参数）方法局部变量（方法中定义的变量）代码块局部变量（在代码块内定义的变量）

成员变量：直接在类中声明的变量叫做成员变量（又称全局变量）

public class Field{
     static int v;//定义int类型数据
     static double w;//定义double类型数据
     static char x;//定义char类型数据
     static boolean y;//定义boolean类型数据
     static String z;//定义String类型数据
     public static void main(String[]args){
         System.out.println(v);//输出0
         System.out.println(w);//输出0.0
         System.out.println(x);//输出空，实际上此时x的值是0
         System.out.println(y);//输出false
         System.out.println(z);//输出null
     }
}

如果未对成员变量设置初始值，则系统会根据成员变量的类型自动分配初始值：int类型分配初始值0、boolean类型分配初始值false，而自定义类型则分配初始值null。

成员变量定义后，其所在的作用域在整个类。

public class Field{
    static int x=9;
    
    public static void main(String[]args){
         System.out.println(x);//输出10
         System.out.println(flag);//输出true
    } 
    static boolean flag=true;//定义boolean类型数据 
}

成员变量的定义没有先后顺序，但最好将成员变量集中定义在类的顶部。

局部变量：    方法中的参数、方法中定义的变量和代码块中定义的变量统称为局部变量。

                      局部变量的作用范围从定义的位置开始到其所在语句块结束。

public class Test{
      {
           int x=9;//定义代码块局部变量
           System.out.println(x);
       }
      static void show(int args){//定义方法参数中的局部变量
           if(args==1){
                 int y=2;//方法中的局部变量
                 System.out.println(y);
           }
           // System.out.println(y);此处不能使用y局部变量
           System.out.println(args);  
      }
      public static void main(String []args){

          new Test();//用于执行代码块中的代码
          show(1);
       }

}

如果局部变量的名字与全局变量的名字相同，则全局变量被隐藏，即这个全局变量在同名局部变量所在的方法内暂时失效。

如果要在该局部变量作用域范围内访问该成员变量，则必须使用关键字this来引用成员变量。

public class Test{
     int x=1;

     void show(){
          int x=8;
          System.out.println(x);//输出1
          System.out.println(this.x);//输出8
     }

     public static void main(String []args){
           new Test().show();
     }
}

注意：关键字this不能被static修饰的方法中使用。

局部变量在使用之前必须显式初始化或赋值，局部变量没有默认值。

public class Test{
      static void show(int x){
           System.out.println(x);
           int y;
           //System.out.println(y);去掉注释符号报错
           y=2;
           System.out.println(y);

      }
      public static void main(String[]args){
          show();
     }
}

声明局部变量时，数据类型前除final外不容许有其他关键字，即定义格式为：[final] 数据类型 变量名=初始值；

public class Test{
     public class void main(String []args){
          int y=2;//在int前面添加public、static都会出错
          System.out.println(y);//输出2
     }
}

关键字static

成员变量：

           static修饰的成员变量称为类属性（又称静态变量）：类成员变量的值在所有对象之间共享；jvm加载类时初始化；可以由所在类创建的对象或类名来调用，推荐使用类名直接调用。

          没有static修饰的成员变量称为实例属性（又称非静态变量）：变量值只属于单个对象：jvm执行创建对象代码时初始化，只能使用对象来调用。

方法：

       static 修饰的方法称为类方法（又称静态方法）：此种方法被所有该类的对象共享；jvm加载类时为其分配入口地址；可以由所在类创建的对象或类名来调用，推荐使用类名直接调用。

        没有static修饰的方法称为实例方法（又称非静态方法）：此种方法对所有该类的对象都是独立的；jvm执行创建对象代码时为其分配入口地址并且只分配一次，只能使用对象来调用。

代码块：

      static 修饰的代码块称为静态代码块：jvm加载类时该类型代码执行并且只执行一次；

    没有static 修饰的代码称为非静态代码块：jvm执行创建对象代码时执行并且每创建一个对象执行一次。

注意：

      静态方法不能直接调用非静态方法，可以间接通过创建该方法（指非静态方法）所在类的对象来调用；非静态方法可以直接调用静态方法；

         静态代码块不能直接调用非静态方法；可以间接通过创建该方法（指非静态方法）所在类的对象来调用；静态代码块可以直接调用静态方法

        静态方法或者静态代码块不能直接使用非静态成员变量，可以间接通过创建该成员变量的对象来调用，静态方法或者静态代码块只能使用静态变量。

构造方法：

    有如下Teacher类：

public class Teacher{
    int age;//年龄
    String name;//姓名
    String position;//职位
    String education;//学历

    public static void main(String []args){
        return  "大家好！我是"+name+",我今年"+age+"岁，学历"+education+",目前的职位是"+position;
   }
}

Teacher类有太多属性，每次给属性赋值时非常麻烦：编码量大，无法重用给属性赋值的代码，有没有可能简化对象初始化代码。

什么是构造方法？

         1、构造方法负责初始化类中的实例变量

          2、构造方法是一种特殊的方法，这种方法必须满足以下语法规则：构造方法必须与类名相同；不包含返回值描述部分。

           3、构造方法不能有static 和final关键字修饰

如何使用构造方法？

    使用new关键字调用构造方法，即构造方法在创建对象（也称实例化对象）时被调用。

public Test{
      public static void main(String []args){
             Teacher teacher=new Teacher();//创建Teacher对象
      }
}

由于Teacher类没有显式构造方法，这时Teacher类就会有一个默认无参构造方法。

显式构造方法：  

            创建类时，如果没有显式定义构造方法，该类就会存在一个默认的无参构造方法；

            可以在类中声明一个或多个有参构造方法，但每个构造方法在参数个数或参数数据类型上要有所差异：

public class Test{

   String name;
   string education;
   int age;
   String position;
   
   public Test(String name){
        this.name=name;
   }
   
   public Test(int age){
       this.age=age;
   }

   public Test(String name,int age){
         this.age=age;
         this.name=name;

   }
}

       第一个构造函数和第二个参数个数相同，但参数数据类型不同

      第三个和前面两个在参数个数和参数数据类型上均不同

如果类中存在显式构造方法，则默认的无参构造方法将不存在，除非显式定义无参构造方法；

只有一个有参构造方法：

public class Student{

    String name;
    int age;

   public Student(String name,int age){
          this.name=name;
          this.age=age;
    }

    public static void main(String []args){
         Student stu=new Student();//代码报错
      }
}

在上面的代码中插入

public Student(){

}

即显式定义无参构造方法。

类中可以有多个构造方法，构造方法之间可以通过this实现调用，但必须将调用构造函数代码写在有效代码第一行

public class Student{
     String name;//姓名
     int age;//年龄

     public Student(String name){
           this.name=name;
    }
    public Student(String name,int age){
            this.age=age;
            this(name);
     }
}

上面的第二个构造函数换成：

public Student(String name,int age){
      this(name);
      this.age=age;
}

注意：普通方法不能使用this调用类中构造方法，例如：

public class Student{
    String name;
    int age;
    
    public Student(String name){   
          this.name=name;

     }
     public static void main(String[]args){

          this(name);//报错
    } 

}

    关键字this

        this代表对当前对象的一个引用。

public class Student{

    public void printInfo(){
         System.out.println(this);
    }
    public static void main(String[]args){
         Student stu=new Student();
         System.out.println(stu);
         stu.printInfo();
    }

}

     this在实例方法中通常被省略，除非实例化方法中包含于成员变量同名的局部变量时，访问成员变量需要使用this

    this关键字用于调用属性、方法及本类中的构造方法

对象初始化过程：

public class Student{
     String name="张三";
     //思考：执行非静态代码块时，对象已经创建了吗？
     {
        System.out.println("非静态代码块"+this.name);
     }
     //思考：调用构造方法时，对象已经存在了吗？
     public Student(String name){
          this.name=name;
          System.out.println("构造方法"+this.name);
     }
     //思考：先调用非静态代码块还是先调用构造方法？
     public static void main(String[]args){
           Student stu=new Student();
     }
}

     运行结果先输出张三，然后输出李四，可见一定先调用非静态代码块，再调用构造方法，并且调用非静态代码块时所创建的对象的实例属性值为初始化值，或者是默认值（如果没有初始化值）

用new创建并初始化对象的步骤：

      1、给对象的实例变量（非“常量”）分配内存空间，默认初始化值；

       2、成员变量声明时的初始化

      3、初始化块初始化（又称构造代码块或非静态代码块）

      4、构造方法初始化

               2、方法中的其他成分