1 package com.bytezero.inherit;
 2 
 3 /*
 4  * 面向对象的特征二：继承性
 5  * 
 6  * 一.继承性的好处：
 7  * ①减少了代码的冗余，提供了代码的复用性
 8  * ②便于功能的拓展
 9  * ③为之后的多态性，提供了前提
10  * 
11  * 
12  * 二.继承性的格式  class A extends B{}
13  *   A:子类  派生类   subclass
14  *   B:父类  超类  基类  superclass
15  *   
16  *   体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的：属性，方法
17  *        特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了
18  *     父类中的私有结构。
19  *   
20  *   只是因为封装性的影响，使得子类不能直接调用父类的结构而已。
21  *   
22  *   子类继承父类以后，还可以声明自己的属性和方法，实现功能的拓展。
23  *   
24  *   子类和父类的关系，不同于集合和子集的关系。
25  *   
26  *   extends：延展，拓展
27  *   
28  * 三.Java中关于继承性的规定
29  *    1.一个类可以被多个子类继承
30  *    2.单继承：一个类只能有一个父类   （C++可以多继承）
31  *    3.子父类是相对的概念。多层继承
32  *    4.子类直接继承的父类，成为：直接父类    
33  *      子类间接继承的父类为：简介父类
34  *    5.子类继承父类以后，就获取了直接父类以及所有间接父类声明的属性和方法
35  *    
36  *  四.1.如果我们没有显示的声明一个父类的话，则此类继承与 java.long.Object类
37  *     2.所有的Java类（除 java.long.Object类外），都直接或间接的继承 java.long.Object类.
38  *     3.意味着，所有Java类具有 java.long.Object类声明的功能。
39  * 
40  */
41 public class ExtendsTest 
42 {
43   public static void main(String[] args)
44   {
45       Person p1 = new Person();
46      // p1.age = 1;
47       p1.eat();
48       //p1.sleep();
49     
50       p1.setAge(30);
51       System.out.println(p1.getAge());
52       
53       
54       
55       
56       
57       Student s1 = new Student();
58       s1.eat();
59       //s1.sleep();
60       s1.name = "Tom";
61       s1.setAge(10);
62       System.out.println(s1.getAge());
63       
64       s1.study();
65       s1.breath();
66       
67       
68       Creature c = new Creature();
69       c.toString();
70     
71   }
72   
73   
74   
75   
76   
77   
78   
79   
80   
81   
82   
83   
84   
85   
86   
87   
88   
89   
90 }
1 package com.bytezero.inherit;
2 
3 public class Creature   //这个类 的父类是 java.long
4 {
5     public void breath()
6     {
7         System.out.println("呼吸");
8     }
9 }
 1 package com.bytezero.inherit;
 2 
 3 public class Person extends Creature
 4 {
 5     String name;
 6     
 7     //私有
 8     private int age;
 9     
10     public Person()
11     {
12         
13     }
14     public Person(String name ,int age)
15     {
16         this.name = name;
17         this.age = age;
18     }
19     
20     public void eat()
21     {
22         System.out.println("吃饭");
23         sleep();//调用 私有方法  同类中可以调用
24     }
25     
26     //私有
27     private void sleep()
28     {
29         System.out.println("睡觉");
30         
31     }
32     
33     
34     public int getAge() {
35         return age;
36     }
37     public void setAge(int age) {
38         this.age = age;
39     }
40     
41     
42     
43     
44 }
 1 package com.bytezero.inherit;
 2 
 3 
 4 public class Student extends Person
 5 {
 6 //    String name;
 7 //    int age;
 8     String major; 
 9     
10     public Student()
11     {
12         
13     }
14     
15     public Student(String name,int age,String major)
16     {
17         //this.age = age;
18         setAge(age);
19         this.name = name;
20         this.major = major;
21     }
22     
23 //    public void eat()
24 //    {
25 //        System.out.println("吃饭");
26 //    }
27 //    public void sleep()
28 //    {
29 //        System.out.println("睡觉");
30 //    }
31     
32     public void study()
33     {
34         System.out.println("学习");
35     }
36     public void show()
37     {
38         System.out.println("name:"+name+",age:"+getAge());
39     }
40     
41     
42     
43     
44 }

Java 关于继承小练习_子类