java面向对象基础之构造方法、方法重载

重写规则

• 参数列表必须与被重写方法完全相同
• 返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类
• 声明为 final 的方法不能被重写，声明为 static 的方法不能被重写，但是能够被再次声明。
• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
• 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
• 构造方法不能被重写

重载规则

• 被重载的方法必须改变参数列表（参数个数或类型不一样）
• 被重载的方法可以改变返回类型、访问修饰符
• 被重载的方法可以声明一个新的或更广的检查异常
• 无法以返回值类型作为重载函数的区分标准

重写和重载的区别

区别点	重载方法	重写方法
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做更严格的限制（可以降低限制）

重写是父类和子类多态性的表现，重载可以理解成多态的具体表现形式

创建实例的时候，我们经常需要同时初始化这个实例的字段

Person name = new Person();
name.setName("cheng");
name.setAge(18);

初始化对象实例需要3行代码，如果忘了调用setName()和setAge()，这个实例内部的状态就是不正确的。为了在创建对象实例时就把内部字段全部初始化为合适的值，就需要构造方法。

构造方法是如此特殊，所以构造方法的名称就是类名。构造方法的参数没有限制，在方法内部，也可以编写任意语句，但是和普通方法相比，构造方法没有返回值（也没有void），调用构造方法，必须用new操作符

//构造方法
public class Main {
    public static void main(String[] args) {
        Person name = new Person("cheng", 18);//创建Person实例时，一次性传入name和age,完成初始化
        System.out.println(name.getName());
        System.out.println(name.getAge());
    }
}
class Person{
    private String name;
    private int age;
    public Person(String name,int age){//构造方法来初始化实例
        this.age = age;
        this.name = name;
    }
    public int getAge(){
        return this.age;
    }
    public String getName(){
        return this.name;
    }
}

默认构造方法

任何类都有构造方法，如果一个类没有定义构造方法，编译器会自动生成一个默认构造方法，它没有参数，也没有执行语句。

Person name = new Person（）;

注意，如果我们自定义了一个构造方法，那么编译器就不再自动创建默认构造方法。

//构造方法
public class Main {
    public static void main(String[] args) {
        Person name = new Person();//编译错误：找不到这个构造方法
        System.out.println(name.getName());
        System.out.println(name.getAge());
    }
}
class Person{
    private String name;
    private int age;
    public Person(String name,int age){//构造方法来初始化实例
        this.age = age;
        this.name = name;
    }
    public int getAge(){
        return this.age;
    }
    public String getName(){
        return this.name;
    }
}

如果既要能使用带参数的构造方法，又想保留不带参数的构造方法，那么只能把两个构造方法都定义出来

//构造方法
public class Main {
    public static void main(String[] args) {
        Person name = new Person();//既可以调用无参数的构造方法
        Person name = new Person("cheng",18)//也可以调用带参数的构造方法
    }
}
class Person{
    private String name;
    private int age;
    public Person{
        
    }
    public Person(String name,int age){//构造方法来初始化实例
        this.age = age;
        this.name = name;
    }
    public int getAge(){
        return this.age;
    }

没有在构造方法中初始化字段时，引用类型的字段默认是null，int类型默认值是0，布尔类型默认值是false。

private String name;//默认初始化为null
    private int age;//默认初始化为0
    public Person{
    }

public class Puppy {
    int puppyAge;
    public Puppy(String name){
        System.out.println("小狗的名字是 "+name);
    }
    public void setAge(int age){
        puppyAge = age;
    }
    public int getAge(){
        System.out.println("小狗的年龄是 "+puppyAge);
        return puppyAge;
    }
    public static void main(String[] args){
        Puppy myPuppy = new Puppy("liang");
        //创建对象
        myPuppy.setAge(3);//通过方法设定age
        System.out.println(myPuppy.getAge());

    }
}

 

多构造方法

可以定义多个构造方法，在通过new操作符调用的时候，编译器通过构造方法的参数数量、位置和类型自动区分

class Person{
    private int age;
    private String name;
    public Person(){//如果调用new Person();会自动匹配到此构造方法
    }
    public Person(String name,int age){//如果调用new Person("cheng",18),会自动匹配到此构造方法
        this.age = age;
        this.name = name;
    }
    public Person(int age){//如果调用new Person(18),会自动匹配到此构造方法
        this.age = age;
        this.name = "dong";
    }
}

一个构造方法可以调用其他构造方法，这样做的目的是便于代码复用。调用其他构造方法的语法是this(..)

class Person{
    private int age;
    private String name;
    public Person(){//
        this("Unnamed");//调用另一个构造方法Person(String)
    }
    public Person(String name,int age){//如果调用new Person("cheng",18),会自动匹配到此构造方法
        this.age = age;
        this.name = name;
    }
    public Person(int age){//
        this("cheng",age);//调用另一个构造方法Person(String,int)
    }
}

方法重载

方法名相同，但各自的参数不同，称为方法重载（overload）。注意：方法重载的返回值类型通常都是相同的。方法重载的目的是，功能类似的方法使用同一名字，更容易记住，因此，调用起来更方便。

//方法重载
public class Main {
   public static void main(String[] args){
       String s = "Test string";
       int n1 = s.indexOf('t');//根据字符的unicode码查找
       int n2 = s.indexOf("st");//根据字符串查找
       int n3 = s.indexOf("st",4);//根据字符串查找，但指定起始位置
       System.out.println(n1);
       System.out.println(n2);
       System.out.println(n3);
   }
}