java 继承的基本实现

继承的基本实现类的继承格式

在java中使用extends关键字完成类的继承关系，操作格式如下：

class 父类{}
class 子类 extends 父类{}

继承父类的功能，扩展子类的所有功能。

class Person{
    private String name;
    private int age;
    public void setName(String name){
    this.name = name;    
    }
    public void setInt(int age){
    this.age = age;    
    }
    public String getName(){
    return this.name;    
    }
    public int getAge(){
    return this.age;
    }
}
class student extends Person{
    //此处不添加任何代码
}
public class ExtDemo02{
    public static void main(String args[]){
    Student stu = new Student();
    stu.setName("张三");
    set.setAge(30);
    System.out.println(stu.getName()+stu.getAge());
    }
}

子类有时候也称之为派生类。

继承的进一步研究

子类对象的实例化过程

实例化子类对象：
1.先调用父类的构造->调用父类构造
2.再调用子类构造->调用子类构造

实例：

InstanceDemo.java

class Person{
    private String name;
    private int age;
    public Person(){
    System.out.println("父类Person中的构造方法");
    }
    public void setName(String name){
    this.name = name;    
    }
    public void setInt(int age){
    this.age = age;    
    }
    public String getName(){
    return this.name;    
    }
    public int getAge(){
    return this.age;
    }
}
class Student extends Person{
    private String school;
    public Student(){
    System.out.println("子类student中构造");
    }
}
public class InstanceDemo{
    public static void main(String args[]){
    Student stu = new Student();    
    }
}

//输出：父类Person中的构造
    子类Student中的构造

实际上此时隐含在Student的构造方法的第一行有以下代码：
    super();    //调用父类的构造函数
即代码相当于：

class Person{
    private String name;
    private int age;
    public Person(){
    System.out.println("父类Person中的构造方法");
    }
    public void setName(String name){
    this.name = name;    
    }
    public void setInt(int age){
    this.age = age;    
    }
    public String getName(){
    return this.name;    
    }
    public int getAge(){
    return this.age;
    }
}
class Student extends Person{
    private String school;
    public Student(){
    super();
    System.out.println("子类student中构造");
    }
}
public class InstanceDemo{
    public static void main(String args[]){
    Student stu = new Student();    
    }
}

注意点：在方法覆写时必须考虑到权限问题,即：被子类覆写的方法不能拥有比父类方法更加严格的访问权限。
访问权限一共有四种，现在只讲三种：
●private:只能被类内访问，权限最第
●default:相当于什么都不声明
●public:最大的访问权限
●大小关系：private<default<public

如果降低了访问权限时如Person使用public而Student使用default时，会产生以下错误：
print() in Student cannot override print() in Person; attempting to assign weaker access privileges; was public void print()
//表示错误的，降低了权限

子类会自动调用覆写的方法，但此时如果非要调用父类中的方法的话，使用super()关键字。
如:Student构造方法调用父类的方法可以进行以下修改：

class Person{
    private String name;
    private int age;
    public Person(){
    System.out.println("父类Person中的构造方法");
    }
    public void setName(String name){
    this.name = name;    
    }
    public void setInt(int age){
    this.age = age;    
    }
    public String getName(){
    return this.name;    
    }
    public int getAge(){
    return this.age;
    }
    public void print(){
    System.out.println("just a moment!");
    }
}
class Student extends Person{
    private String school;
    public Student(){
    super.print();
    System.out.println("子类student中构造");
    }
}
public class InstanceDemo{
    public static void main(String args[]){
    Student stu = new Student();    
    }
}

---------------------------------------------------------
问题：如果现在在父类中使用private 关键字声明了一个方法，那么在子类中使用default权限算是覆写吗？
答  ：不是覆写.
------------------------------------------------------

class Person{
    private String name;
    private int age;
    public void setName(String name){
    this.name = name;    
    }
    public void setInt(int age){
    this.age = age;    
    }
    public String getName(){
    return this.name;    
    }
    public int getAge(){
    return this.age;
    }
    private void print(){
    System.out.println("Person------>void print()");
    }
}
class Student extends Person{
    private String school;
    void print(){
    System.out.println("Student-------->void print()");
    }
}
public class InstanceDemo{
    public static void main(String args[]){
    Student stu = new Student();
    stu.print();
    }
}

输出：Student---------->void print()

此时，方法没有被覆写，而是相当于在子类中又重新定义了一个新的方法出来。

3.3 属性的覆写

在子类中声明了父类同名的属性。

class Person{
    public String name;
    private int age;
    public void setName(String name){
    this.name = name;    
    }
    public void setInt(int age){
    this.age = age;    
    }
    public String getName(){
    return this.name;    
    }
    public int getAge(){
    return this.age;
    }
    private void print(){
    System.out.println("Person------>void print()");
    }
}
class Student extends Person{
    public String name;
    void print(){
    System.out.println("父类中的属性："+super.info);
    System.out.println("子类中的属性："+this.info);
    }
}
public class OverrideDemo{
    public static void main(String args[]){
    Student stu = new Student();
    stu.print();
    }
}

3.4方法的覆写与的方法的重载

overloading                    overrideing
方法名称相同参数的类型或个数不同        方法名称参数的类型返回值类型全部相同
对权限没有要求                    被覆写的方法不能拥有更严格的权限
发生在一个类中                    发生在继承类中


3.5    super关键字
表示从子类调用父类中的指定操作，例如调用属性，方法，构造等。因为在子类实例化的时候会默认调用父类中的无参构造，如果现在希望调用有参构造方法，可以使用super方法传递参数。

class Person{
    private String name;
    private int age;
    public Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("父雷Person中的构造方法");
    }
    public void setName(String name){
    this.name = name;    
    }
    public void setInt(int age){
    this.age = age;    
    }
    public String getName(){
    return this.name;    
    }
    public int getAge(){
    return this.age;
    }
  }
class Student extends Person{
    private String school;
    public Student(String name,int age,String school){
        super(name,age);
        this.school = school;
        System.out.println("子类student中的构造方法");
    }
}
public class OverrideDemo{
    public static void main(String args[]){
    Student stu = new Student("张三",30,"山东大学");
    }
}

当子类调用无参构造方法时，父雷中不存在无参构造方法，此时就会报错。因为子类会在无参构造方法第一行隐含调用super方法，解决方法为：父类定义一个无参构造方法，或使用super调用父类存在参数的方法。

不管任何时候，子类实例化时候先去调用父类中的构造方法，默认调用无参构造。

总结：
使用 super 调用无参方法
1.建立含无参构造的类。
2.建立含无参构造子类，继承父类。
3.子类中构造第一行添加或不添加super

使用 super 调用含参数的方法
1.建立含参构造的类。
2.建立含参子类（覆写构造函数），继承父类。
3.子类中构造第一行添加super(内部参数同父类构造方法)

this与super的区别

this                                    super
属性访问：访问本类中的属性，如果本类没有这些属性则从父类中查找。    属性访问：访问父类中的属性
方法：访问本类中的方法，如果本类没有则从父类中查找。            方法：直接访问父类中的方法
调用构造：调用本类构造，必须放在构造方法首行。                调用构造：调用父类构造，必须放在子类构造方法的首行。
特殊：表示当前对象。                            特殊：无此概念

对于this和super本身都可以调用构造方法，而且调用的时候都必须放在构造方法首行，所以两个关键字不能同时出现。

疑问：如果在构造方法中（子类）使用了this，那么是不是就不调用父类中的构造方法？

  答：子类中不可能同时都调用this()方法，所以默认仍会调用父类的构造方法。