java 继承的基本实现

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

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

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

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

[java] view plaincopyprint?

1. class Person{  
2.     private String name;  
3.     private int age;  
4.     public void setName(String name){  
5.     this.name = name;      
6.     }  
7.     public void setInt(int age){  
8.     this.age = age;      
9.     }  
10.     public String getName(){  
11.     return this.name;      
12.     }  
13.     public int getAge(){  
14.     return this.age;  
15.     }  
16. }  
17. class student extends Person{  
18.     //此处不添加任何代码  
19. }  
20. public class ExtDemo02{  
21.     public static void main(String args[]){  
22.     Student stu = new Student();  
23.     stu.setName("张三");  
24.     set.setAge(30);  
25.     System.out.println(stu.getName()+stu.getAge());  
26.     }  
27. }  

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

继承的进一步研究

子类对象的实例化过程

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

实例：

InstanceDemo.java

[java] view plaincopyprint?

1. class Person{  
2.     private String name;  
3.     private int age;  
4.     public Person(){  
5.     System.out.println("父类Person中的构造方法");  
6.     }  
7.     public void setName(String name){  
8.     this.name = name;      
9.     }  
10.     public void setInt(int age){  
11.     this.age = age;      
12.     }  
13.     public String getName(){  
14.     return this.name;      
15.     }  
16.     public int getAge(){  
17.     return this.age;  
18.     }  
19. }  
20. class Student extends Person{  
21.     private String school;  
22.     public Student(){  
23.     System.out.println("子类student中构造");  
24.     }  
25. }  
26. public class InstanceDemo{  
27.     public static void main(String args[]){  
28.     Student stu = new Student();      
29.     }  
30. }  

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

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

[java] view plaincopyprint?

1. class Person{  
2.     private String name;  
3.     private int age;  
4.     public Person(){  
5.     System.out.println("父类Person中的构造方法");  
6.     }  
7.     public void setName(String name){  
8.     this.name = name;      
9.     }  
10.     public void setInt(int age){  
11.     this.age = age;      
12.     }  
13.     public String getName(){  
14.     return this.name;      
15.     }  
16.     public int getAge(){  
17.     return this.age;  
18.     }  
19. }  
20. class Student extends Person{  
21.     private String school;  
22.     public Student(){  
23.     super();  
24.     System.out.println("子类student中构造");  
25.     }  
26. }  
27. public class InstanceDemo{  
28.     public static void main(String args[]){  
29.     Student stu = new Student();      
30.     }  
31. }  

注意点：在方法覆写时必须考虑到权限问题,即：被子类覆写的方法不能拥有比父类方法更加严格的访问权限。
访问权限一共有四种，现在只讲三种：
●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构造方法调用父类的方法可以进行以下修改：

[java] view plaincopyprint?

1. class Person{  
2.     private String name;  
3.     private int age;  
4.     public Person(){  
5.     System.out.println("父类Person中的构造方法");  
6.     }  
7.     public void setName(String name){  
8.     this.name = name;      
9.     }  
10.     public void setInt(int age){  
11.     this.age = age;      
12.     }  
13.     public String getName(){  
14.     return this.name;      
15.     }  
16.     public int getAge(){  
17.     return this.age;  
18.     }  
19.     public void print(){  
20.     System.out.println("just a moment!");  
21.     }  
22. }  
23. class Student extends Person{  
24.     private String school;  
25.     public Student(){  
26.     super.print();  
27.     System.out.println("子类student中构造");  
28.     }  
29. }  
30. public class InstanceDemo{  
31.     public static void main(String args[]){  
32.     Student stu = new Student();      
33.     }  
34. }  

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

[java] view plaincopyprint?

1. class Person{  
2.     private String name;  
3.     private int age;  
4.     public void setName(String name){  
5.     this.name = name;      
6.     }  
7.     public void setInt(int age){  
8.     this.age = age;      
9.     }  
10.     public String getName(){  
11.     return this.name;      
12.     }  
13.     public int getAge(){  
14.     return this.age;  
15.     }  
16.     private void print(){  
17.     System.out.println("Person------>void print()");  
18.     }  
19. }  
20. class Student extends Person{  
21.     private String school;  
22.     void print(){  
23.     System.out.println("Student-------->void print()");  
24.     }  
25. }  
26. public class InstanceDemo{  
27.     public static void main(String args[]){  
28.     Student stu = new Student();  
29.     stu.print();  
30.     }  
31. }  

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

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

3.3 属性的覆写

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

[java] view plaincopyprint?

1. class Person{  
2.     public String name;  
3.     private int age;  
4.     public void setName(String name){  
5.     this.name = name;      
6.     }  
7.     public void setInt(int age){  
8.     this.age = age;      
9.     }  
10.     public String getName(){  
11.     return this.name;      
12.     }  
13.     public int getAge(){  
14.     return this.age;  
15.     }  
16.     private void print(){  
17.     System.out.println("Person------>void print()");  
18.     }  
19. }  
20. class Student extends Person{  
21.     public String name;  
22.     void print(){  
23.     System.out.println("父类中的属性："+super.info);  
24.     System.out.println("子类中的属性："+this.info);  
25.     }  
26. }  
27. public class OverrideDemo{  
28.     public static void main(String args[]){  
29.     Student stu = new Student();  
30.     stu.print();  
31.     }  
32. }  

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

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


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

[java] view plaincopyprint?

1. class Person{  
2.     private String name;  
3.     private int age;  
4.     public Person(String name,int age){  
5.         this.name = name;  
6.         this.age = age;  
7.         System.out.println("父雷Person中的构造方法");  
8.     }  
9.     public void setName(String name){  
10.     this.name = name;      
11.     }  
12.     public void setInt(int age){  
13.     this.age = age;      
14.     }  
15.     public String getName(){  
16.     return this.name;      
17.     }  
18.     public int getAge(){  
19.     return this.age;  
20.     }  
21.   }  
22. class Student extends Person{  
23.     private String school;  
24.     public Student(String name,int age,String school){  
25.         super(name,age);  
26.         this.school = school;  
27.         System.out.println("子类student中的构造方法");  
28.     }  
29. }  
30. public class OverrideDemo{  
31.     public static void main(String args[]){  
32.     Student stu = new Student("张三",30,"山东大学");  
33.     }  
34. }  

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

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

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

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

this与super的区别

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

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

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

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