class Person
{
  private String name;
Perosn (String name)
{
     this.name = name;

}
void show(){}

}

class Student extends Person
{
   Student(String name)
{
   super(name);
}
void method()
{
  super.show();
}

}

好抽象啊 这个

Student类继承了Person类，表示Person类中的除了private修饰的东西都是可以继承的，super(name)表示的是继承了父类的构造方法Person(String name) 类推suuper.show()继承了父类的show()方法

1. public class Person {
   
2.         private String name;
   
3. 
   
4.         // 父类的有参构造
   
5.         public Person(String name) {
   
6.                 super();
   
7.                 this.name = name;
   
8.         }
   
9. 
   
10.         // 父类自己定义的show()方法   public修饰可以继承
    
11.         public void show() {
    
12. 
    
13.                 System.out.println("person");
    
14.         }
    
15. }
    

复制代码

1. /*
   
2. * 子类必须通过super关键字调用父类的构造函数　和方法
   
3. * */
   
4. public class Student extends Person {
   
5. 
   
6.         public Student(String name) {
   
7.                 // super 显示代表调用了父类有参构造
   
8.                 super(name);
   
9.         }
   
10. 
    
11.         // 子类自己的方法
    
12.         public void method() {
    
13.                 // super 代表调用了父类的show（）方法
    
14.                 super.show();
    
15.         }
    
16. 
    
17. }

复制代码

在子类父类的继承问题上，其实显示生活中的情景是一致的。比如，人与学生，可以说，这个人叫张三，这个学生叫李四，。也可以说这个人叫李四，这个学生叫李四，但是不能说这个学生叫张三。所以，父类的属性子类是不能覆盖的。另外，人与学生都有吃饭的方法，但是吃饭的方式是不同的。这就存在了方法的覆盖，比如：人 张三 = 学生 张三，调用人的吃饭方法，与调用张三那的吃饭方法，都是张三在吃饭，所以这就是方法的覆盖。注意：一切私有的东西【好吧，就叫东西】都是不能被别人调用，覆盖的。表达能力有限，附上代码以供参考

1. package com.chenkf.study;
   
2. 
   
3. public class Student extends Person{
   
4.         public String name = "李四";
   
5.         private int age;
   
6. 
   
7.         public static void main(String[] args) {
   
8.                 Person student = new Student(); //student 人的引用，实际上就是一个学生对象
   
9.                 System.out.println(student.name);//打印出父类【人】的属性值
   
10.                 Student s = (Student) student;//因为我们知道，这个人就是学生，就可以强制把人变为学生。
    
11.                 System.out.println(s.name);//打印的是学生的名字
    
12.                 System.out.println(student.getAge());//打印的是0，因为，子类覆盖了父类的getAge()方法
    
13.                 student.eat();//调用的是子类的方法。
    
14.                 //student.privateTest();//这个方法是不能调用的，因为是父类的私有方法
    
15.                 s.privateTest();//调用本类的私有方法。ok
    
16.                 //想要调用父类已被子类覆盖的方法，可以使用super关键字，因为在static与this，super不能同时存在，所有只能在写个非静态方法
    
17.                 s.test();
    
18.                
    
19.                
    
20.         }
    
21. 
    
22.         public int getAge() {
    
23.                 return age;
    
24.         }
    
25. 
    
26.         public void setAge(int age) {
    
27.                 this.age = age;
    
28.         }
    
29.        
    
30.         @Override
    
31.         public void eat() {
    
32.                 System.out.println("子类吃饭。");
    
33.         }
    
34.        
    
35.         public void test(){
    
36.                 super.eat();//调用父类的吃饭的方法。
    
37.         }
    
38.        
    
39.         private void privateTest(){
    
40.                 System.out.println("我是李四");
    
41.         }
    
42. }
    
43. 
    
44. class Person{
    
45.         public String name = "张三";//父类的属性
    
46.        
    
47.         private int age = 10;
    
48. 
    
49.         public int getAge() {
    
50.                 return age;
    
51.         }
    
52. 
    
53.         public void setAge(int age) {
    
54.                 this.age = age;
    
55.         }
    
56.        
    
57.         private void privateTest(){
    
58.                 System.out.println("我是张三");//只能被本类方法调用。
    
59.         }
    
60.        
    
61.         public void eat(){
    
62.                 System.out.println("父类吃饭。");
    
63.         }
    
64. }
    

复制代码