面向对象——继承

面向对象——继承

1、继承（extends）的概述及案例演示

概述：让类与类之间产生关系，子父类关系

public static void main(String[] args) {
        Cat c = new Cat();
        c.color = "黄色";
        c.leg = 4;
        c.sleep();
        c.eat();
        System.out.println(c.leg+"..."+c.color);
    }

}    
    
/**
 * 动物类，猫类，狗类
 * 定义两个属性（颜色，腿的个数），两个功能（吃饭，睡觉）
 * @author Administrator
 *
 */
class Animal{
    String color;         //动物的颜色
    int leg;            //腿的个数
    
    public void eat(){
        System.out.println("吃饭");
    }
    
    public void sleep(){
        System.out.println("睡觉");
    }
}

class Cat extends Animal{
        
}

class Dog extends Animal{
    
}

2、继承的好处和弊端

（1）好处

• 提高了代码的复用性
• 提高了代码的维护性
• 让类与类之间产生了关系，是多态的前提

（2）弊端

• 类的耦合性增强了

3、继承的特点

（1）Java只支持单继承，不支持多继承（一个儿子只能有一个爹）

（2）Java支持多层继承（继承体系）

（3）如果要用整个体系的所有功能，就用最底层的类创建对象

（4）整个体系的共用性功能，看最顶层的类

//继承体系
    public static void main(String[] args) {
        DemoC c = new DemoC();
        c.show();
        c.method();
        c.print();
    }

}    
    
class DemoA{
    public void show(){
        System.out.println("DemoA");
    }
}

class DemoB extends DemoA{
    public void method(){
        System.out.println("DemoB");
    }
}

class DemoC extends DemoB{
    public void print(){
        System.out.println("DemoC");
    }
}

4、继承的注意事项

（1）子类只能继承父类所有的非私有的成员（方法和变量）

（2）子类不能继承父类的构造方法，但是可以通过super关键字区访问父类构造方法

5、继承中成员变量的关系

（1）super

子类局部范围访问父类成员变量

（2）this和super的使用区别

①调用成员变量

this.成员变量　　调用本类的成员变量，也可以调用父类的成员变量

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

②调用构造方法

this（……）调用本类的构造方法

super（……）调用父类的构造方法

③调用成员方法

this.成员方法　　调用本类的成员方法，也可以调用父类的成员方法

super.成员方法　　调用父类的成员方法

public static void main(String[] args) {
        Son s = new Son();
        s.print();
    }

}

/**
 * a.不同名变量
 * b.同名变量
 *
 */
class Father{
    int num1 = 10;
    int num2 = 30;
}

class Son extends Father{
    int num2 = 20;
    public void print(){
        System.out.println(this.num1);   //this既可以调用本类，也可以调用父类
        System.out.println(this.num2);   //就近原则
        System.out.println(super.num2);  //调用父类
    }
}

6、继承中构造方法的关系

　　子类中所有的构造方法默认都会访问父类中空参数的构造方法，因为子类会继承父类的数据，可能还会使用父类的数据，所以子类初始化之前，一定要先完成父类数据的初始化。

 7、继承中成员方法的关系

public static void main(String[] args) {
        Son s = new Son();
        s.print();
        s.m();
    }

}
/**
 * a.不同名方法
 * b.同名方法
 * @author Administrator
 *    重写
 */

class Father{
    public void print(){
        System.out.println("父类输出");
    }
}

class Son extends Father{
    public void m(){
        System.out.println("子类方法");
    }
    
    public void print(){
        super.print();       //super可以调用父类成员方法
        System.out.println("子类输出");
    }
}

8、方法重写概述

（1）方法重写：子父类出现了一模一样的方法

（2）方法重写应用

　　当子类需要父类的功能，而功能主题子类有自己特有内容时，可以重写父类的方法。这样，既沿袭了父类的功能，又定义了子类特有的内容。

（3）案例

public static void main(String[] args) {
        Phone2 p = new Phone2();
        p.siri();
        p.call();
    }

}
/**
 * 方法重写
 * 
 */

class Phone{
    public void call(){
        System.out.println("打电话");
    }
    
    public void siri(){
        System.out.println("speak English");
    }
}

class Phone2 extends Phone{
    public void siri(){
        super.siri();   //保留父类方法
        System.out.println("说中文");  //重写父类方法
    }
}

（4）方法重写注意事项

• 父类中私有方法不能被重写
• 子类重写父类方法时，访问权限不能更低
• 父类中的静态方法，子类也必须通过静态方法进行重写

9、方法重写（Override）和方法重载（Overload）的区别：

• 方法重写：子类中出现了和父类中方法声明一模一样的方法；与返回值有关，返回值是一致的。
• 方法重载：本类中出现的方法名一样，参数列表不同的方法；与返回值类型无关。

10、final关键字修饰类，方法以及变量的特点

（1）修饰类：类不能被继承

（2）修饰变量：变量就变成了常量，只能被赋值一次

（3）修饰方法：方法不能被重写

11、final修饰局部变量

（1）基本类型：值不能被改变

（2）引用类型：地址值不能被改变，对象中的属性可以改变