java中的super和重写

发表于   |   分类于   |  

出现的问题

在Java实现打字母游戏那篇文章里，遇到一个很奇怪的现象。在下雪代码的48行，如果去掉super，就像是下雨一样，且背景是灰色。

解决问题

首先，super()是调用自己继承的父类的构造函数。
那么，这就牵涉到JPanel的paint()方法了，我是继承了JPanel并重写了paint()方法，如果不调用super，那么在main中执行的只是我的paint方法，原来父类JPanel中的paint方法并没有执行。所以在原来父类的默认构造以及原本的paint方法中可能存在相应处理代码。但是我查了一下JPanel的源码，并没有找到paint方法，很奇怪，它继承自JComponent，于是又看了一下JComponent的源码，看到了startPaint方法，额(⊙o⊙)…有点晕。

显然，上面除了super的问题还涉及到了方法的重写。
于是再来看看方法的重写。
首先强调一下重载和重写（覆盖）不是一个概念。
方法重载：如果有两个方法的方法名相同，但参数不一致，那么可以说一个方法是另一个方法的重载。

方法重写：如果在子类中定义一个方法，其名称、返回类型及参数签名正好与父类中某个方法的名称、返回类型及参数签名相匹配，那么可以说，子类的方法覆盖了父类的方法

写个简单的例子来说明方法的重写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class People 
{  
    public String getName() 
    {  
        return "people";  
    }  
 
}  
class Student extends People 
{  
      
    public String getName() 
    {  
        return "student";  
    }  
      
}  
public class MyTest
{
    public static void main(String[] args) 
    {
    	People p1 = new People();  
    	System.out.println(p1.getName());//运行结果为people  
    	    
    	Student s1 = new Student();  
    	System.out.println(s1.getName());//运行结果为student  
    	    
    	People p2 = new Student();  
    	System.out.println(p2.getName());//运行结果为student  
     
    } 
}

结果说明：子类重写了父类的方法，在使用多态实现父类new出子类时，调用相同函数时，调用的是子类重写后的方法。

但是当我们重写的不是方法，而是变量的，结果还是和上面的一样吗？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class People 
{  
    protected String name="people";     
}  

class Student extends People 
{  
    protected String name="student";  
}  
public class MyTest
{
    public static void main(String[] args) 
    {              
        People p1 = new People();  
        System.out.println(p1.name);//运行结果为people  
          
        Student s1 = new Student();  
        System.out.println(s1.name);//运行结果为student  
          
        People p2 = new Student();  
        System.out.println(p2.name);//运行结果为people  
     
    }
}

答案是：no！父类new的子类实例，调用变量时，调用的是父类的变量。

总结

一、 this()是调用自己其他的构造函数，super()是调用自己继承的父类的构造函数。
注意：

  1. 如果只想调用默认无参数的父类构造函数，不用在子类的构造函数当中写出来。在实际编程的时候，很容易就会忽略这一点。
  2. 如果父类的构造函数是带参数的，又没写默认的无参数构造函数，那么子类在写构造函数的时候必须引用super的含参构造。
  3. 两个关键字不能同时出现在子类的一个构造函数当中。

二、 只有方法的重写，没有变量的重写。方法的重写把具体对象抽象为一般对象的目的，从而实现了多态性。

本来还想总结一下多态的。看到这篇博客总结的不错，于是直接在这引用好了。以后忘了再来看一下。