JAVA构造器+继承+重载与重写+自动转型与多态

一、构造器：构造器主要用于构造类的对象并初始化对象的属性，与C++中的构造函数的作用一样

       格式： public   类名(参数表)  {}             以Sutdent类为例

[java] view plain copy

print ?

1. public class Student{     //Student类的声明  
          public Student(){}    //构造器（构造函数）

   public class Student{     //Student类的声明
       public Student(){}    //构造器（构造函数）
}

        构造器会在类的对象生成时被自动调用。如果用户没有创建构造器，那系统会自动辨别并创建一个无参版本的构造器。如果用户创建了一个带有参数的构造器，那么系统便不会再为用户创建无参版本的构造器，这时，类里面只有用户自己定义的构造器。但是如果这个类要作为父类被继承，所以必须要有一个无参版本的构造器来防止子类对象初始化时调用父类的默认构造器。因此一般情况下类里面都会有一个无参版本的构造器

二、继承：子类继承父类的特征和行为，使得子类的对象具有父类的属性和方法

       格式： public  class  子类名(参数表)   extends  父类名 {}         以Student类和University类为例

public  class  Student{    //父类的声明与定义  
     public  String  name;  
     public  int  age;  
  
     public Sutdent(){}    //构造器  
}  
public class UniversityStuden extends Student{   //子类的声明与定义  
     public String sex;        //子类所特有的特征属性  
     public void Study(){}     //子类所特有的方法函数  
}

public  class  Student{    //父类的声明与定义
     public  String  name;
     public  int  age;

     public Sutdent(){}    //构造器
}
public class UniversityStuden extends Student{   //子类的声明与定义
     public String sex;        //子类所特有的特征属性
     public void Study(){}     //子类所特有的方法函数
}

       extends就表示继承，extends前面就是要继承的类，后面就是被继承的类。继承之后，子类UniversityStuden的对象就有了父类Student的属性和方法。除了父类的属性和方法外，子类还可以拥有属于自己的特征属性和方法函数，其定义与普通的特征属性和方法函数的定义一样

三、方法重写与重载：方法的重载是指在同一个类中，多个方法的名称一样但是方法的参数不一样（参数的个数、类型、排列顺序）   

       格式：public 返回类型 函数名(参数表(不能相同)){}          以Student类为例

public class Student{  
     public String name;  
     public int age;  
  
     public void Study(String name){}  
     public void Study(int age){}                 //参数类型不同  
     public void Study(String name, int age){}    //参数个数不同  
     public void Sutdy(int age, String name){}    //参数排列顺序不同  
}  

public class Student{
     public String name;
     public int age;

     public void Study(String name){}
     public void Study(int age){}                 //参数类型不同
     public void Study(String name, int age){}    //参数个数不同
     public void Sutdy(int age, String name){}    //参数排列顺序不同
}

注意：构造方法的重载主要用于初始化当前对象的属性。如果重载了构造函数，则默认的构造函数不存在

        方法的重写实现不同的类，必须在继承的条件下实现，是指子类重写父类的方法，其中方法的返回类型、名称和参数表必须要一致，具体就是把父类继承的方法进行覆盖然后重写。可以说方法的重写只是子类与父类方法实现的不同，其余都一样 

        格式： public 返回类型  函数名(参数表){方法的实现不一样}          以Student类和UniversityStudent类为例

public class Student{  
      public String name;  
      public void Study(String name){  
      System.out.println("学生学习")}  
}  
  
public class UniversityStudent extends Student{  
      public String name;  
      public void Study(String name){                //重写后的返回类型、名称和参数表要一致  
      System.out.println("大学生学习")}  
}  

public class Student{
      public String name;
      public void Study(String name){
      System.out.println("学生学习")}
}

public class UniversityStudent extends Student{
      public String name;
      public void Study(String name){                //重写后的返回类型、名称和参数表要一致
      System.out.println("大学生学习")}
}

四、自动转型与多态：自动转型就是指子类的对象自动转型为父类的对象

        格式： 父类类型  对象名 = new  子类类型();          以Student类和UniversityStudent为例

public class Student{  
     public String name;  
     public void Study(){}   
}  
  
public class UniversityStudent extends{  
     public String name;  
     public void Study(){}   
}  
//主函数  
public class Test{  
     public static void main(String[] args){  
       Student stu = new UniversityStudent();    //子类的对象自动转型为父类类型的对象  
}

public class Student{
     public String name;
     public void Study(){} 
}

public class UniversityStudent extends{
     public String name;
     public void Study(){} 
}
//主函数
public class Test{
     public static void main(String[] args){
       Student stu = new UniversityStudent();    //子类的对象自动转型为父类类型的对象
}

       转型后的对象类型是父类的，转型后的对象调用父类的方法，如果这个方法在子类中被重写了，那么则调用子类中的方法，如果没有被重写，则调用父类本身的方法。

       多态：多态是指同一个对象调用方法是，执行不一样的过程。多态必须在继承、方法重写和自动转型的基础上实现。

以Student类和UniversityStudent类为例子

public class Student{  
     public void Study(){  
    System.out.prinltn("学生学习");  
}   
}  
  
public class UniversityStudent extends{  
     public void Study(){  
        System.out.prinltn("大学生学习");  
}   
}  
//主函数  
public class Test{  
     public static void main(String[] args){  
       Student stu = new UniversityStudent();    
       stu.Study();             //输出的是“大学生学习”                  
       Student stu1 = new Student();  
       stu1.Study();            //输出的是“学生学习”  
} 

public class Student{
     public void Study(){
    System.out.prinltn("学生学习");
} 
}

public class UniversityStudent extends{
     public void Study(){
        System.out.prinltn("大学生学习");
} 
}
//主函数
public class Test{
     public static void main(String[] args){
       Student stu = new UniversityStudent();  
       stu.Study();             //输出的是“大学生学习”                
       Student stu1 = new Student();
       stu1.Study();            //输出的是“学生学习”
}

     stu的本质是一个UniersityStudent的对象，并且UniversityStudent重写了Study方法，所以输出的是“大学生学习”

        小结：类的构造器、继承、重载、重写、自动转型和多态的实现相互之间都有着密切的关系，理清它们的关系更有利于自身的学习。正确的使用它们可以减轻代码的复杂度并且提高代码的效率。