继承

2017-06-21 本文已影响0人醒醒Coco

概述：
多个类中存在相同的属性和行为时，可以把这些内容抽取到单独的一个类中。通过extends关键字可以实现继承.单独的这个类叫做父类，基类或者超类。多个类可以称为子类或者派生类。

作用：

提高了代码复用性
提高了代码的维护性
让类和类之间产生了关系，是多态的前提（其实也是继承的弊端，类的耦合性增加了）
开发的原则：低耦合，高内聚
耦合：类与类的关系
内聚：就是自己完成某件事情的能力

Java中继承的特点

Java中只支持单继承，不支持多继承
Java支持多层继承(继承体系)

继承的注意事项

子类只能继承父类所有非私有的成员方法和成员变量
子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法
不要为了部分功能而去继承
什么时候考虑使用继承？继承其实是一种关系"is a"

继承中成员变量的关系

子类中的成员变量和父类中的成员变量不一样
子类中的成员变量和父类中的成员变量一样。就近原则

super 和 this 的区别
this 代表本类对象的引用。super 代表父类存储空间的标识，可以理解为父类的引用。

成员变量的调用

  this.成员变量  调用本类的成员变量
  super.成员变量  调用父类的成员变量

构造方法的调用

  this(...)    调用本类的构造方法
  super(...)   调用父类的构造方法

成员方法的调用

  this.成员方法    调用本类得成员方法
  super.成员方法   调用父类得成员方法

ExtendsDemo

package coco.perm;
/**
 * Created by xingxingduan on 2016/5/2.
 * 继承概述：
 * 把多个类中相同的内容给提取出来定义到一个类中。
 * 如何实现继承呢?
 * Java提供了关键字：extends
 * 格式：
 *class 子类名 extends 父类名 {}
 *
 */

class Person{
    public void eat(){
        System.out.println("吃饭");
    }

    public void sleep() {
        System.out.println("睡觉");
    }
}

class Student1 extends Person{}
//通过继承关系，省去大量的代码。子类可以继承父类未被private修饰的成员变量和成员方法。

class Teacher extends Person{}

public class ExtendsDemo {
    public static void main(String[] args) {
        Student1 s = new Student1();
        s.eat();
        s.sleep();
        System.out.println("_________________________");

        Teacher t = new Teacher();
        t.eat();
        t.sleep();
    }
}

ExtendsDemo2

/**
 * Created by xingxingduan on 2016/5/2.
 * Java中继承的特点：
 * 1、Java中只支持单继承，不支持多继承
 *      有些语言支持多继承：格式：extends 类1,类2,...
 * 2、Java支持多层继承（继承体系）
 */

class GrandFather{
    public void show(){
        System.out.println("我是爷爷");
    }
}

class Father extends GrandFather{
    public void method(){
        System.out.println("我是老子");
    }
}

class Son extends Father{}

public class ExtendsDemo2 {
    public static void main(String[] args) {
        Son s = new Son();        
        s.method();
        s.show();
    }
}

ExtendsDemo3

package coco.perm;

/**
 * Created by xingxingduan on 2016/5/10.
 * 继承的注意事项：
 *      A:子类只能继承父类所有非私有(未被private关键字修饰的)的成员(成员方法和成员变量)
 *      B:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。
 *      C:不要为了部分功能而去继承  
 */
class Father{
    private int num = 10;
    public int num1 = 20;

    //私有方法，子类不能继承
    private void method(){
        System.out.println(num);
        System.out.println(num1);
    }

    public void show(){
        System.out.println(num);
        System.out.println(num1);
    }
}

class Son extends Father{
    public void function(){
        //子类不能继承父类的私有成员变量
        System.out.println(num1);
    }
}

public class ExtendDemo3 {
    public static void main(String[] args) {
        Son s = new Son();
        //之类不能继承父类的私有成员方法
        s.show();
        
    }
}

继承中构造方法的关系

子类中所有的构造方法默认都会访问父类中无参的构造方法
原因：因为子类会继承父类的数据，甚至还会使用父类的数据。所以，子类初始化前，一定要先完成父类的初始化
子类中每一个构造方法的第一个语句默认是 super()

class Father1 {
    public Father1() {
        System.out.println("这是Father的无参构造方法");
    }
    public Father1(String name) {
        System.out.println("这是Father的带参数构造方法");
    }
}
class Son1 extends Father1 {
    public Son1() {
        //子类的构造方法，默认第一天语句是super()
        //super();    //可写可以不写
        System.out.println("这是Son的无参构造方法");
    }
    public Son1(String name) {
        //super();
        System.out.println("这是Son的带参数构造方法");
    }
}
public class ExtendsDemo {

    public static void main(String[] args) {
        Son1 s = new Son1();
        System.out.println("-----------------");

        Son1 s1 = new Son1("xingxing");
    }
}

如果父类中没有无参构造方法，怎么办？
错误示例

class Father2{
    public Father2(String name){
        System.out.println("这是Father2的带参构造方法");
    }
}
class Son2 extends Father2{
    public Son2(){
        System.out.println("这是Son2的无参构造方法");
    }
    public Son2(String name){
        System.out.println("这是Son2的带参构造方法");
    }
}
public class ExtendDemo2 {
    public static void main(String[] args) {
        Son2 s = new Son2();
    }
}
程序报错：
Error:(11, 18) java: 无法将类 Father2中的构造器 Father2应用到给定类型;
  需要: java.lang.String
  找到: 没有参数
  原因: 实际参数列表和形式参数列表长度不同

解决方法：

在父类中加一个无参构造方法
通过使用super关键字去显示的调用父类中的带参构造方法
通过this去调用本类中的其他构造方法（子类中一定要有一个去访问了父类的构造方法，否则，父类的数据没有初始化）

class Father2{
    public Father2(String name){
        System.out.println("这是Father2的带参构造方法");
    }
}
class Son2 extends Father2{
    public Son2(){
        super("随便填");
        System.out.println("这是Son2的无参构造方法");
    }
    public Son2(String name){
        //super("随便填");
        this();
        System.out.println("这是Son2的带参构造方法");
    }
}
public class ExtendDemo2 {
    public static void main(String[] args) {
        Son2 s = new Son2();
        System.out.println("-----分割线--------");
        Son2 s2 = new Son2("coco");
    }
}
运行结果：
这是Father2的带参构造方法
这是Son2的无参构造方法
-----分割线--------
这是Father2的带参构造方法
这是Son2的无参构造方法
这是Son2的带参构造方法

继承中成员方法关系

子类中的方法和父类中的方法声明不一样

class Father1{
    public void show(){
        System.out.println("show Father");
    }
}
class Son1 extends Father1{
    public void method(){
        System.out.println("method Son");
    }
}
public class ExtendsDemo1 {
    public static void main(String[] args) {
        Son1 s = new Son1();
        s.show();
        s.method();
    }
}
运行结果:
show Father
method Son

子类中的方法和父类中的方法声明一样，先找子类本身，再找父类。

class Father1{
    public void show(){
        System.out.println("show Father");
    }
}
class Son1 extends Father1{
    public void show(){
        System.out.println("show Son");
    }
}
public class ExtendsDemo1 {
    public static void main(String[] args) {
        Son1 s = new Son1();
        s.show();
    }
}
输出结果：
show Son

方法重写

子类中出现了和父类中方法声明一摸一样的方法。
当子类中，需要使用父类的功能，而功能主题有自己持有内容时，可以重写父类中的方法。这样，既沿袭了父类的功能，又定义了子类持有的内容。可以通过super关键字调用。

class Phone{
     public void call(String name){
        System.out.println("给"+name+"打电话");
    }
}
class NewPhone extends Phone{
    public void call(String name){
        super.call(name);    //通过super关键字调用
        System.out.println("可以听天气预报了");
    }
}
public class ExtendsDemo3 {
    public static void main(String[] args) {
        NewPhone np = new NewPhone();
        np.call("xingxing");
    }
}

注意

父类中的私有方法，不能被重写。因为父类的私有方法，子类根本无法继承。
子类重写方法时，访问权限不能更低。只能大于等于父类的权限，最好一致。

问题：

override 和overload 的区别，能改变返回值类型吗？
方法重写（override）：在子类中出现和父类中一模一样的方法声明时。
方法重载（overload）：同一个类中，出现方法名相同，参数列表不同。方法重载可以改变返回值的类型，因为它与返回值类型无关。方法重写不可以。
this 和 super的区别？
this代表当前类的引用
super代表父类存储空间的标识（可以理解为父类的引用，通过这个访问父类的成员）

练习案例

/**
 * Created by v_xxingduan on 2015/6/22.
 * 学生和老师的案例
 */

class Person{
    //姓名
    private String name;
    //年龄
    private int age;

    public Person(){}

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
}


class Students extends Person{
    public Students(){}

    public Students(String name,int age){
        super(name,age);   //显示调用父类的带参构造
    }
}

class Teacher extends Person{
    public Teacher(){}

    public Teacher(String name,int age){
        super(name,age);
    }
}
public class ExtendsDemo4 {
    public static void main(String[] args) {
        Students s1 = new  Students();
        s1.setName("xingxing");
        s1.setAge(20);
        System.out.println(s1.getName()+"----"+s1.getAge());

        Teacher t1 = new Teacher("coco",21);
        System.out.println(t1.getName()+"----"+t1.getAge());
    }
}

/**
 * Created by xingxingduan on 2015/6/22.
 * 猫和狗的案例
 */

class Animal{
    //姓名
    private String name;
    //年龄
    private int age;
    //颜色
    private String color;

    //构造方法
    public Animal(){}

    public Animal(String name,int age,String color){
        this.name = name;
        this.age = age;
        this.color = color;
    }

    //成员方法
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getColor() {
        return color;
    }
}

class Cat extends Animal{
    public Cat(){}

    public Cat(String name,int age,String color){
        super(name,age,color);
    }

    public void playGame(){
        System.out.println("Cat PlayGame");
    }
}


class Dog extends Animal{
    String hobby;
    public Dog(){}

    public Dog(String name,int age,String color,String hobby){
        super(name,age,color);
        this.hobby = hobby;
    }

    public void lookDog(){
        System.out.println("LookDog");
    }
}

public class ExtendsDemo5 {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.setName("cat");
        c.setAge(2);
        c.setColor("balck");
        System.out.println("name："+c.getName()+"\tage:"+c.getAge()+"\tcolor:"+c.getColor());
        c.playGame();

        Dog d = new Dog("coco",3,"yellow","eat");
        System.out.println("name:"+d.getName()+"\tage:"+d.getAge()+"\tcolor"+d.getColor()+"\thobby:"+d.hobby);
        d.lookDog();
    }
}

继承

继承中构造方法的关系

继承中成员方法关系

方法重写

猜你喜欢

热点阅读