Java 继承

Java 继承

Java 中的继承
注意:
1.Java 只允许单继承(多继承可以使用接口来间接实现)
2.Java 中允许多层继承

Java 中最顶层父类(最基础类) Object 类
如果类没有写继承哪个父类,默认就是继承 Object 类

继承的特点:
1.减少代码量
2.让类与类之间产生关联(产生父与子的关系)

继承的弊端:
父类中添加一个属性,子类中就继承了这个属性

注意:
1.继承时可以把多个类中相同的功能或方法抽取出来
  重新构造一个类出来,把这些类建立继承关系
2.建立继承关系的同时,一定要符合逻辑(切记不要为了继承而继承)
  如果是继承关系,一定要符合子类是父类(例如:程序员是员工)
  继承使用关键字: extends 和 implements(为类继承接口,变相的是 java 据用多继承的特性)

继承写法:
class 子类 extends 父类{

}

子类继承父类的方法和属性

例如:
public class Demo {
    public static void main(String[] args) {
        // 创建猫
        Cat cat = new Cat();
        cat.name = "汤姆";
        cat.color = "蓝猫";
        cat.sleep();
    }

}

// 动物
class Animal{
    String name;    // 名字
    String color;   // 颜色
    String kind;    // 种类

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

// 猫
class Cat extends Animal{
    // 抓老鼠
    public void catchTheMouse() {
        System.out.println("抓老鼠");
    }
}

// 狗
class Dog extends Animal{
    // 啃骨头
    public void gnawBones() {
        System.out.println("啃骨头");
    }
}

例如:
    // 多层继承
class A{
    String name;
}

class B extends A{

}

class C extends B{
    public void name() {
        System.out.println("叫");
    }
}

注意:
构造方法不能被继承
为了保证继承的完整性,在创建子类对象的时候
如果不主动去调用父类的构造方法那么系统默认会去调用父类无参构造方法

例如:
public class Demo {

    public static void main(String[] args) {
        Son son = new Son();
        son.name = "儿子";
        son.sayHi();

        Son son2 = new Son("名");
        son2.sayHi();
    }

}

class Father{
    String name;
    // 无参
    public Father() {
        System.out.println("father 无参");
    }
    // 有参
    public Father(String name) {
        this.name = name;
        System.out.println("father 有参");
    }
    public void sayHi() {
        System.out.println(name);
    }
}

class Son extends Father{
    // 无参
    public Son() {
        // 如果没有在子类的构造方法中调用父类的构造方法
        // 系统会默认给子类构造方法中添加一行代码
        super();// 调用父类的无参构造方法
        // super 相当于父类的对象
        System.out.println("son 无参");
    }
    // 有参
    public Son(String name) {
        super();// 系统默认调用父类的构造方法
        this.name = name;
        System.out.println("son 有参");
    }
}

super 关键字

super 代表的是父类的对象

super 调用对象: super. 对象
super 调用方法: super. 方法

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

例如:
public class Demo {
    public static void main(String[] args) {
        TestB testB = new TestB();
        testB.fun();
    }
}

class TestA{
    int num1 = 10;
    int num2 = 20;
}

class TestB extends TestA{
    int num1 = 30;

    public void fun() {
        // 使用 this 时,会先在本类中寻找该属性,没找到再去父类中寻找
        System.out.println(this.num1);
        System.out.println(this.num2);
        System.out.println(super.num1);
    }
}

例如:
class Phone {
    String name;

    // 无参
    public Phone() {

    }
    // 有参
    public Phone(String name) {
        this.name = name;
    }
}

class MI extends Phone{

    // 无参
    public MI() {
        // 子类的构造方法中,如果什么都不写,会默认掉父类无参构造方法
        // 如果父类没有无参构造方法,就证明父类中一定有有参构造方法
        // 无论有参还是无参,在子类的构造方法中,必须要调用一个,必须手动指定一个有参构造方法去调用
        super("Note2");
    }
    // 有参
    public MI(String name) {
        super(name);
        this.name = name;
    }
}

Override(重写) 和 Overload(重载) 的区别

思考:父类和子类的方法能不能重名?
答案:可以,方法重写

注意:
1.方法声明完全一致的时候,叫方法重写
1.方法的重写建立在类与类之间有继承关系(子类重写父类的方法)

Override(重写) 和 Overload(重载) 的区别:
1.重写前提:需要继承关系
  重载前提:在同一个类中
2.重写需要方法的声明完全一致
  重载只跟参数有关

例如:
public class Demo {
    public static void main(String[] args) {
        IOS8 ios8 = new IOS8();
        ios8.siri();

        // 如果直接打印对象,相当于系统在打印时会自动调用 toString() 方法
        System.out.println(ios8);
        System.out.println(ios8.toString());
    }
}

class IOS7{
    public void call() {
        System.out.println("打电话");
    }
    public void siri() {
        System.out.println("说英文");
    }
}

class IOS8 extends IOS7{

    @Override // 注解,标识这个方法是重写父类方法
    public void siri() {
        // 调不调父类的方法要根据实际情况
        super.siri();
    }

    /*
    // 方法的重写:对父类的方法进行功能上的升级
    public void siri() {
        super.siri();// 调用父类的方法
        System.out.println("说中文");
    }
    */

    // 重写 toString() 方法
    @Override
    public String toString() {
        return " ";
    }
}

/*
 * 老师类 学生类  
 * 无参 有参构造 set/get方法 成员变量私有化 介绍自己的方法属性:姓名,年龄
 * 行为:吃饭
 * 老师有特有的方法:讲课
 * 学生有特有的方法:学习
 */
public class Demo {
    public static void main(String[] args) {
        Teacher teacher = new Teacher("王", 16);
        System.out.println(teacher);
        Student student = new Student("酒", 20, 2018060606);
        System.out.println(student);

    }
}

class People{
    // 继承中 private 修饰的变量是不能直接访问的
    private String name;// 姓名
    private int age;// 年龄

    // 无参
    public People() {

    }
    // 有参
    public People(String name, int age) {
        this.age = age;
        this.name = name;
    }
    // get/set
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

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

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "我叫" + name + "年龄" + age;
    }
}

class Teacher extends People{

    // 无参
    public Teacher() {
        super();
    }
    // 有参
    public Teacher(String name, int age) {
        super(name, age);
    }

    // 讲课
    public void teacher() {
        System.out.println("讲课");
    }
}

class Student extends People{
    //特有属性
    private int num;

    // 无参
    public Student() {
        super();
    }
    // 有参
    public Student(String name, int age, int num) {
        // 直接调用父类的构造方法完成初始化
        // 为了保证继承的完整性在子类构造方法中
        // 第一行必须调用父类的构造方法(无参有参都行)
        super(name, age);
        // 特有属性,直接赋值就行
        this.num = num;
    }
    // 讲课
    public void study() {
        System.out.println("学习");
    }
    @Override
    public String toString() {
        // 可以在父类的基础上添加自己特有的属性去打印
        return super.toString() + "学号" + num;
    }
}

http://blog.csdn.net/huzongnan/article/list