Java基础 第七章 面向对象编程（基础）（第三部分）

重载

• 基本介绍：

  Java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致。

• 重载的好处：

  （1）减轻了起名的麻烦

  （2）减轻了记名的麻烦

• 快速入门：

  分别计算两个整数的和，一个整数，一个double的和，以及三个整数的和

public class OverLoad01{
     public static void main(String[] args){
        T res = new T();
        System.out.println(res.calculate(1,2));
        System.out.println(res.calculate(1,2.5));
        System.out.println(res.calculate(1,2,3));
    }
}
class T{//以下三个方法构成了重载
    public int calculate(int n1, int n2){
    return n1 + n2;    
    }
    public double calculate(int n1,double n2){
        return n1 + n2;
    }
    public int calculate(int n1,int n2,int n3){
        return n1 + n2 + n3;
    }
}

注意事项

（1）方法名：必须相同

（2）形参列表：必须不同（形参类型或个数或顺序，至少有一样不同，参数名无要求）

（3）返回类型也无要求

• 例：

  （1）与 void show ( int a, char b, double c){}构成重载的有（ b c d e）

  （a）void show (int x, char y, double z){}//不构成重载，因为形参列表相同

  （b）int show(int a, double c, char b){}//构成重载，形参列表顺序不同，返回值不要求，满足重载要求

  （c）void show(int a, double c, char b){}//构成重载

  （d）boolean show(int c, char b){}//构成重载，形参个数不同

  （e）void show(double c){}//构成重载

  （f）double show(int x, char y, double z){}//不构成重载，形参列表一致

  （g）void shows(){}//不构成，方法名不一样

（2）在Methods类，定义三个重载方法max(),第一个方法，返回两个int值中的最大值，第二个方法，返回两个double值中的最大值，第三个方法，返回三个double值中的最大值，并分别调用三个方法。

public class OverLoad02{
   public static void main(String[] args){
        Methods num = new Methods();
        System.out.println(num.max(1.0,5));
        System.out.println(num.max(1.0,5.0));
        System.out.println(num.max(1.0,5.5,5.7));
    }
}
class Methods{
    public int max(int n1, int n2){
        return n1 > n2 ? n1 : n2;
    }
    public double max(double n1, double n2){
        return n1 > n2 ? n1 : n2;
    }
    public double max(double n1, double n2, double n3){
        double max1 = n1 > n2 ? n1 : n2;
        return max1 > n3 ? max1 : n3;
    }
}

可变参数

• 基本概念：

  Java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。

• 例：在类HspMethod中，使用方法sum（可以计算2个数的和，3个数的和，4个数的和......）

public class VarParameter01{
      public static void main(String[] args){
        HspMethod m = new HspMethod();
        m.sum(1,4,6);
    }
}
class HspMethod{//使用可变参数时，可以当作数组来使用，即nums 可以当作数组来使用
    public void sum(int...nums){
        int res = 0;
        for(int i = 0;i < nums.length;i++){
           res += nums[i];           
        }
        System.out.println(res);
    }
}

细节

（1）可变参数的实参可以为0个或任意多个

（2）可变参数的实参可以为数组

（3）可变参数的本质就是数组

（4）可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后

（5）一个形参列表中只能出现一个可变参数

• 例：有三个方法，分别实现返回姓名和两门课成绩（总分），返回姓名和三门课成绩（总分），返回姓名和五门课成绩（总分）。封装成一个可变参数的方法

public class VarParameterExercise{
     public static void main(String[] args){
        HspMethod m = new HspMethod();
        System.out.println(m.showScore("小明",120,110,119));
    }
}
class HspMethod{
    public String showScore(String name, double ...sums){
        double num = 0;
        for(int i = 0;i < sums.length;i++){
           num += sums[i];           
        }
        return name + "有" + sums.length + "门课的总成绩为"+num;
    }
}

作用域

• 基本使用

  （1）在java编程中，主要的变量就是属性（成员变量）和局部变量

  （2）我们说的局部变量一般是指在成员方法中定义的变量

  （3）java中作用域的分类

  全局变量：也就是属性，作用域为整个类体

  局部变量：除了属性之外的其他变量，局部变量必须赋值后，才能使用。因为局部变量没有默认值

注意

全局变量可以不赋值，直接使用，局部变量必须赋值后才能使用

• 注意事项：

  （1）属性和局部变量可以重名，访问时遵循就近原则

  （2）在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名

  （3）属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量，声明周期短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。

public class Bian{
    public static void main(String[] args){
        
    }
}
class Person{
    String name = "jack";
    public void say(){
        String name = "king";
        System.out.println("输出的名字是" + name);//结果：输出的名字是king，就近原则
    }
}

（4）作用域范围不同

全局变量/属性：可以被本类使用，或其他类使用（通过对象调用）

局部变量：只能在本类中对应的方法中使用

（5）修饰符不同

全局变量/属性可以加修饰符

局部变量不可以加修饰符

构造方法/构造器(Constructor)

• 基本介绍：构造方法又叫构造器，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化，它的特点有：

  （1）方法名和类名相同

  （2）没有返回值

  （3）在创建对象时，系统会自动的调用该类的构造器完成对对象的初始化

• 快速入门：

  现在我们就用构造方法来完成刚才提出的问题：在创建人类的对象时，就直接指定这个对象的年龄和姓名

public class Constructor{
    public static void main(String[] args){
        Person p1 = new Person("小明",18);
        System.out.println(p1.name+p1.age);
    }
} 
class Person{
    String name;
    int age;
    //构造器没有返回值，不能写void
    //构造器的名称和类一样
    public Person(String Pname,int Page){
        name = Pname;
        age = Page;
    }
}

注意事项

（1）一个类可以定义多个不同的构造器，即构造器重载

（2）构造器名和类名要相同

（3）在创建对象时，系统自动的调用该类的构造方法

（4）如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器（Scanner MyScanner = new Scanner();）

(5)一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显式的再定义一下

• 课堂练习

（1）在定义的Person类中添加两个构造器：

（2）第一个无参构造器：利用构造器设置所有人的age属性初始值为18

（3）第二个带pName 和pAge两个参数的构造器

（4）使得每次创建Person对象的同时初始化对象的age属性值和name属性值

public class ConstructorExercise{
       public static void main(String[] args){
        Person p1 = new Person();
        System.out.println("p1的信息是"+"age="+p1.age+"name="+p1.name);
        Person p2 = new Person("小明",23);
        System.out.println("p2的信息是"+p2.name +" "+p2.age);
    }
}
class Person{
    String name;
    int age;
    public Person(){
        age = 18;
    }
    public Person(String pName,int pAge){
        name = pName;
        age = pAge;
    }
}

this关键字

Java虚拟机会给每个对象分配this，代表当前对象。

例：

public class ThisExercise{
 public static void main(String[] args){
        Dog dog1 = new Dog("大壮",13);
        System.out.println(dog1.name+dog1.age);
        dog1.info();
    }
}
class Dog{
    String name;
    int age;
    public Dog(String name, int age){
        name = name;
        age = age;
    }
    public void info(){
        System.out.println("this.hashcode = "+this.hashCode());
    }
}

• 细节

（1）this关键字可以用来访问本类的属性，方法，构造器

（2）this用于区分当前类的属性和局部变量

（3）访问成员方法的语法：this.方法名（参数列表）；

（4）访问构造器语法：this（参数列表）；注意只能在构造器中使用（即只能在构造器中访问另外一个构造器，并且一定要放在第一条语句）

（5）this不能在类定义的外部使用，只能在类定义的方法中使用

• 练习：

  定义Person类，里面有name，age属性，并提供compareTo比较方法，用于判断是否和另一个人相等，提供测试类TestPerson用于测试，名字和年龄完全一样，就返回true，否则返回false

public class TestPerson{
     public static void main(String[] args){
        Person p1 = new Person("小明",12);
        Person p2 = new Person("小王",13);
        System.out.println(p1.compareTo(p2));
    }
}
class Person{
    String name;
    int age;
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public boolean compareTo(Person p){
        return this.name.equals(p.name) && this.age == p.age;
    }
}