java继承

.继承的概念

继承就是字面的理解就好，子继承父的一些特性，并且还可能发生一些“基因突变”，可以包含一些父类没有的方法或者属性。正所谓“青出于蓝而胜于蓝”。

为什么要用继承呢？一方面继承可以向上抽取父类，使代码重用率提高。比如Teacher类和Student类都可以继承person类，另一方面继承可以引出多态，是面向对象的重要特性。

一个例子：

[java]  view plain copy

1. class Person  
2. {  
3.     String name;  
4.     Person(String name)  
5.     {  
6.         this.name = name;  
7.         System.out.println("Person is Constructed");  
8.     }  
9.     public void eat()  
10.     {  
11.         System.out.println("I am a person. I can eat!");  
12.     }  
13. }  
14.   
15. class Student extends Person  
16. {  
17.     String num;//学号  
18.     Student(String num,String name)  
19.     {  
20.         //调用父类构造函数  
21.         super(name);  
22.           
23.         this.num = num;   
24.         System.out.println("Student is Constructed");  
25.     }  
26.     public void study()  
27.     {  
28.         System.out.println("I am a student. I can sutdy");  
29.     }  
30. }  
31.   
32.   
33. public class InheritsTest1 {  
34.     public static void main(String[] args)  
35.     {  
36.         //创建一个学生对象  
37.         Student student1 = new Student("zhang","111");  
38.         //调用父类的吃饭方法  
39.         student1.eat();  
40.         //调用学习方法  
41.         student1.study();  
42.           
43.     }  
44.       
45. }  

输出的结果如下：

要点：

1.继承的语法  class 子类  extends  父类 {}

2.子类自动拥有父类public 和protected的成员。

3.关于权限问题：

    public 外界可以无限制访问  

private类外不可访问，只能类内部访问

protected 继承的子类可以访问（在不同的包中也可以） 

default即没写权限，默认同一包中的类可以访问。

4.super()调用父类的构造函数，这句话需要在子类构造函数中作为第一句话！！！

二.子类与父类间方法的关系

子类与父类中方法之间有几种关系，第一种就如上面的例子，子类直接继承父类的方法，不进行改变，可以直接调用父类的方法，子类也可以对父类的方法进行扩充，即增加新的方法。如person会eat，student继承了person类，他也会eat，但是又增加了study方法。

后两种关系都发生在子类的方法和父类重名的情况下。

1.子类覆盖父类的方法

例子：

[java]  view plain copy

1. class Person  
2. {  
3.     String name;  
4.     Person(String name)  
5.     {  
6.         this.name = name;  
7.         System.out.println("Person is Constructed");  
8.     }  
9.     public void eat()  
10.     {  
11.         System.out.println("I am a person. I can eat 饭!");  
12.     }  
13. }  
14.   
15. class Student extends Person  
16. {  
17.     String num;//学号  
18.     Student(String num,String name)  
19.     {  
20.         //调用父类构造函数  
21.         super(name);  
22.           
23.         this.num = num;   
24.         System.out.println("Student is Constructed");  
25.     }  
26.     public void eat()  
27.     {  
28.         System.out.println("I am a student .I can eat 脑白金");  
29.     }  
30.     public void study()  
31.     {  
32.         System.out.println("I am a student. I can sutdy");  
33.     }  
34. }  
35.   
36.   
37. public class InheritsTest1 {  
38.     public static void main(String[] args)  
39.     {  
40.         //创建一个学生对象  
41.         Student student1 = new Student("zhang","111");  
42.         //覆盖了父类的eat饭方法，调用子类的eat脑白金方法  
43.         student1.eat();  
44.         //调用学习方法  
45.         student1.study();  
46.           
47.     }  
48.       
49. }  

结果：

可见，子类覆盖了父类的方法。在调用子类的时候，调用eat方法，执行的不是父类的“eat饭”方法，而是子类的"eat脑白金"方法。

2.子类重载父类的方法

[java]  view plain copy

1. class Person  
2. {  
3.     String name;  
4.     Person(String name)  
5.     {  
6.         this.name = name;  
7.         System.out.println("Person is Constructed");  
8.     }  
9.     public void eat()  
10.     {  
11.         System.out.println("I am a person. I can eat 饭!");  
12.     }  
13. }  
14.   
15. class Student extends Person  
16. {  
17.     String num;//学号  
18.     Student(String num,String name)  
19.     {  
20.         //调用父类构造函数  
21.         super(name);  
22.           
23.         this.num = num;   
24.         System.out.println("Student is Constructed");  
25.     }  
26.     public void eat(String food)  
27.     {  
28.         if (food.equals("naobaijin"))  
29.         System.out.println("I am a student .I can eat 脑白金");  
30.     }  
31.     public void study()  
32.     {  
33.         System.out.println("I am a student. I can sutdy");  
34.     }  
35. }  
36.   
37.   
38. public class InheritsTest1 {  
39.     public static void main(String[] args)  
40.     {  
41.         //创建一个学生对象  
42.         Student student1 = new Student("zhang","111");  
43.         //调用父类的eat饭方法  
44.         student1.eat();  
45.         //调用子类重载的eat脑白金方法  
46.         student1.eat("naobaijin");  
47.         //调用学习方法  
48.         student1.study();  
49.     }  
50.       
51. }  

结果如下：

这样student既可以吃饭，也可以吃脑白金，不同就在与eat方法接受的参数不同，如果是没有参数，那么他就执行父类的eat饭方法，如果有参数，那就执行子类重载的eat脑白金方法，吃脑白金。

要点：

1.子类和父类之间的方法关系有扩充关系（直接调用父类方法或者扩充新方法），覆盖关系（子类与父类方法重名，子类方法覆盖父类方法），重载关系（子类方法与父类方法参数不同，调用时根据参数选择调用哪个方法）

2.覆盖时不能覆盖静态方法，也不能覆盖final方法。

3.覆盖方法的允许访问范围不能小于原方法，覆盖方法抛出的异常不能比原方法多。

4.在子类中可以调用父类的方法，被覆盖的也可以。即用super关键字

例子如下：

[java]  view plain copy

1. class Person1  
2. {  
3.     public void eat()  
4.     {  
5.         System.out.println("I am a person. I can eat 饭!");  
6.     }  
7. }  
8.   
9. class Student1 extends Person1  
10. {  
11.     public void eat()  
12.     {  
13.         //在子类中可以使用super关键字调用父类的方法，包括被覆盖的方法  
14.         super.eat();  
15.         System.out.println("I am a student .I can eat 脑白金");  
16.     }  
17.     public void study()  
18.     {  
19.         System.out.println("I am a student. I can sutdy");  
20.     }  
21. }  
22.   
23.   
24. public class InheritsTest2 {  
25.     public static void main(String[] args)  
26.     {  
27.         //创建一个学生对象  
28.         Student1 student1 = new Student1();  
29.         //调用子类的eat方法  
30.         student1.eat();  
31.     }  
32.       
33. }  

结果：

三.final关键字与Object类

final关键字是java中用的很多的一个修饰词，大致可以根据字面理解，最终，就是不变的意思。

关于final有这几种用法：

1.final修饰的类不可以被继承，即“只读”的不可变类，防止在继承的时候随意修改类。eg: final class 类名{}

2.final修饰的方法不可以被覆盖。 final 返回值 方法名（）{}

3.final修饰的变量不可以修改，即常量。通常用大写字母 eg：MAX_VALUE

关于Object类，它是java中所有类的基类。如果一个类没有继承其他的类，那么它默认继承Object类。Object类提供了若干方法，我们之前也用过一些

诸如toString(),equals()方法。