分类

继承

JAVA学习网 2017-09-11 10:06:05

1 继承的概述

  • 先观察如下代码
package java007;

/**
 * 2017/9/9
 * 说明：学生
 */
public class Student {
    String name;
    int age;

    public void study(){
        System.out.print("我叫"+name+",今年"+age+"，我是一名学生，正在学习");
    }
}
package java007;

/**
 * 2017/9/9
 * 说明：工人
 */
public class Worker {
    String name;
    int age;

    public void work(){
        System.out.print("我叫"+name+",今年"+age+"，我是一名工人，正在工作");
    }
}
package java007;

/**
 * 2017/9/9
 * 说明：
 */
public class StudentAndWorkderTest {
    public static void main(String[] args) {
        Student s = new Student();
        s.name = "张三";
        s.age = 15;
        s.study();

        Worker w = new Worker();
        w.name = "李四";
        w.age = 34;
        w.work();
    }
}
    • 我们可以发现学生类和工人类中都有姓名和年龄属性，属于重复字段，那么如何解决？，且看如下代码。　　
package java007;

/**
 * 2017/9/9
 * 说明：
 */
public class Person {
    String name;
    int age;
}
package java007;

/**
 * 2017/9/9
 * 说明：学生
 */
public class Student extends Person {

    public void study(){
        System.out.print("我叫"+name+",今年"+age+"，我是一名学生，正在学习");
    }
}
package java007;

/**
 * 2017/9/9
 * 说明：工人
 */
public class Worker extends Person{

    public void work(){
        System.out.print("我叫"+name+",今年"+age+"，我是一名工人，正在工作");
    }
}
package java007;

/**
 * 2017/9/9
 * 说明：
 */
public class StudentAndWorkderTest {
    public static void main(String[] args) {
        Student s = new Student();
        s.name = "张三";
        s.age = 15;
        s.study();

        Worker w = new Worker();
        w.name = "李四";
        w.age = 34;
        w.work();
    }
}

 

  • 继承的好处：
    • ①提高了代码的复用性。
    • ②让类与类之间产生关系，给第三个特征多态提供了前提。　　

 

2 继承的特点

  • Java中支持单继承（一个子类只能有一个父类），不直接直接多继承，支持多层继承。

 

3 super关键字

  • 当本类的成员变量和局部变量同名的时候，使用this区分。
  • 当子父类的成员变量同名的时候，使用super区分父类。
  • this和super的用法很相似。

 

  • 示例1：本类的成员变量和局部变量同名的时候
package java007;

/**
 * 2017/9/9
 * 说明：
 */
class Fu{
    private int age = 20;
    public void show(){
        int age = 10;
        System.out.print("局部变量："+age+",成员变量："+this.age);

    }
}
public class ExtendsDemo {
    public static void main(String[] args) {
        Fu f = new Fu();
        f.show();
    }

}

    • 解释说明：
      • ①先使用javac ExtendsDemo.java命令将ExtendsDemo编译成class文件，当然，顺便将Fu.java也编译成class文件。
      • ②使用java ExtendsDemo命令，虚拟机会从方法区中，将main()方法识别，并加载到栈中。
      • ③执行了new Fu()；会在堆内存中开辟一个空间，（将Fu(){}加载到栈内存中，因为这一部分对本程序而言不是很重要，所以省略相关描述），用来存储对象，并初始化age=0。然后执行到private int age = 20;的时候，就将20赋值给age，此时age在堆内存中是20。
      • ④Fu f = new Fu();main()方法所在的栈内存中，开辟了一个引用变量f，然后将堆内存中的对象的地址赋值给f,那么此时f就指向堆内存中的对象。
      • ⑤f.show();从方法区将show()方法加载到栈中，此时，注意的是，show()方法内部就包含了this关键字，同时f变量的地址值给了this，因为this表示的是当前对象的引用，而调用show()方法的恰恰是f，所有this和f此时的值是相同的，那么show()方法也指向了堆内存中的对象，然后在show()方法内部开辟了一个age变量，这个age变量是栈内存中show()方法内部的局部变量，而想获取堆内存中的age变量，只能通过show()方法内存的this关键字了。　　

 

  • 示例2：子类和父类的成员变量不同的时候
package java007;

/**
 * 2017/9/9
 * 说明：
 */
class Fu{
     int age1 = 20;

}
class Zi extends Fu{
    int age2 = 30;
    public void show(){
        System.out.print(age1+" "+age2);
    }
}
public class ExtendsDemo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }

}

    • 解释说明：通过上面的程序貌似可以这样解释，第一，变量名是不一样的，第二，子类是继承了父类，而子类中没有age1成员变量，所以从父类中继承（拷贝）了age1成员变量。　　

 

  • 示例3：子父类的成员变量相同的时候
package java007;

/**
 * 2017/9/9
 * 说明：
 */
class Fu{
     int age = 20;

}
class Zi extends Fu{
    int age = 30;
    public void show(){
        System.out.print(age);
    }
}
public class ExtendsDemo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }

}
package java007;

/**
 * 2017/9/9
 * 说明：
 */
class Fu{
     int age = 20;

}
class Zi extends Fu{
    int age = 30;
    public void show(){
        System.out.print(age+" "+super.age);
    }
}
public class ExtendsDemo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }

}
    • 解释说明：通过上面的程序貌似可以这样解释，子类和父类成员变量相同的时候，子类可以将父类相同成员变量覆盖，其实不然，且看下面分解。　　

 

4 函数覆盖（重写）

  • 示例：子父类中的方法名不同
package java007;

/**
 * 2017/9/10
 * 说明：
 */
class Fu{
    public void show1(){
        System.out.print("Fu的show1方法");
    }
}
class Zi extends Fu{
    public void show2(){
        System.out.print("Zi的show2方法");
    }
}
public class ExtendsDemo2 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show1();
        z.show2();
    }
}

 

  • 示例：子父类中的方法名同名
package java007;

/**
 * 2017/9/10
 * 说明：
 */
class Fu{
    public void show(){
        System.out.print("Fu的show方法");
    }
}
class Zi extends Fu{
    public void show(){
        System.out.print("Zi的show方法");
    }
}
public class ExtendsDemo2 {
    public static void main(String[] args) {
        Zi z = new Zi();
       z.show();
    }
}

 

  • 当子类中出现成员函数和父类的一样的时候，会运行子类的成员函数，从表现上看。好像是子类的成员函数“覆盖”了父类的成员函数，这种现象，被称为重写或者覆盖。
  • 函数的两个特性：
    • 重载。同一个类中。
    • 覆盖。子类中，也称为重写。　　　　
  • 重写的注意事项：子类方法覆盖父类方法时，子类方法的权限必须>=父类方法的权限。

 

5 子类的实例化过程

  • 示例：
package java007;

/**
 * 2017/9/10
 * 说明：
 */
class Fu{
   public Fu(){
       System.out.println("Fu的构造方法");
   }
}
class Zi extends Fu{
    public Zi(){
        System.out.println("Zi的构造方法");
    }

}
public class ExtendsDemo2 {
    public static void main(String[] args) {
        Zi z = new Zi();

    }
}

 

  • 在子类构造对象的时候，发现，访问子类构造函数的时候，父类也运行了。这是为什么？因为，在子类构造方法中的第一行有一个默认的隐式语句：super();j如下代码所示。　
package java007;

/**
 * 2017/9/10
 * 说明：
 */
class Fu{
   public Fu(){
       System.out.println("Fu的构造方法");
   }
}
class Zi extends Fu{
    public Zi(){
        super();//调用的是父类的默认的空参数构造函数
        System.out.println("Zi的构造方法");
    }

}
public class ExtendsDemo2 {
    public static void main(String[] args) {
        Zi z = new Zi();

    }
}

  • 示例：
package java007;

/**
 * 2017/9/10
 * 说明：
 */
class Fu{
    public Fu(){
        show();
    }
    public void show(){
        System.out.print("fu show");
    }

}
class Zi extends Fu{
   int num = 8;
   public Zi(){

   }
   public void show(){
       System.out.print("zi show:"+num);
   }


}
public class ExtendsDemo2 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();

    }
}

    • 解释：先将父类进行初始化，再将子类进行初始化。　　

 

6 final关键字

  • final可以修饰类、方法和变量。
  • final修饰的类不可以被继承。
  • final修饰的方法不可以被重写。
  • final修饰的变量是一个常量，只能被赋值一次。
  • 内部类只能访问被final修饰的局部变量。

 

  • 示例：final修饰变量，变为常量
class Person{
    private final int age = 10;
}
  • 示例：final修饰变量，变为常量
class Person{
    private final int age ;
    {
        age = 20;
    }
}
  • 示例：final修饰变量，变为常量
class Person{
    private final int age ;
    public Person(int age){
        this.age = age;
    }
}

 

阅读(750) 评论(0)