java--继承

4.类的继承的特点
每个子类只有一个直接父类。Java的继承通过extends来实现的，实现继承的类叫子类，被继承的类叫父类，也有叫基类，超类。父类和子类是一般跟特殊的关系，例如苹果是水果的子类，苹果是一种特殊的水果，水果是苹果的父类。
Java中继承的格式如下:
修饰符 class SubClass extends SuperClass{

}
其实就是在定义类上加 extends SuperClass 就行。
例：
/**
* 父类
*/
class Student {
public int age;//年龄
public void show() {
System.out.println(“我的年龄是：”+this.age);
}
}
/**
* 子类
*/
public class Test extends Student{
public static void main(String[] args) {
//创建Test对象
Test test=new Test();
//Test类并没有age属性，所以子类继承了父类的属性和方法可以使用父类的属性
//给父类的属性赋值
test.age=12;
//调用父类
test.show();
}
}
结果：
这里写图片描述
前面概念中解释过子类只能有一个直接父类，也就是说可以有多个间接父类
例：
/**
* 父类
*/
class Student {
public int age;//年龄
public void show() {
System.out.println(“我的年龄是：”+this.age);
}
}
/**
* 父类
*/
class Student1 extends Student {
public String name;//姓名
public void show1() {
System.out.println(“我的姓名是：”+this.name);
}
}
/**
* 子类
*/
public class Test extends Student1{
public static void main(String[] args) {
//创建Test对象
Test test=new Test();
//Test类并没有age属性，所以子类继承了父类的属性和方法可以使用父类的属性
//给Student父类的属性赋值
test.age=12;
//调用Student父类show方法
test.show();
//给Student1父类的属性赋值
test.name=”第二个父类”;
//调用Student1父类show1方法
test.show1();

}
结果：
这里写图片描述
以上Test的直接父类是Student1，间接父类是Student，结果表明，子类可以使用间接父类的属性和方法，也可以使用直接父类的属性和方法。从子类的角度看，子类扩展（extends）了父类，父类的角度看，父类派生了子类。

5.重写父类方法
当父类的方法并不是适合子类时，我们就需要进行方法重写。例如：鸟类都包含飞翔的方法，但是鸵鸟也属于鸟类，但是它并不会飞。
例：
父类：
public class Bird {
public void fly() {
System.out.println(“这是Bird的fly方法”);
}
}
子类继承父类
public class Ostrich extends Bird {
//重写父类的fly方法
public void fly() {
System.out.println(“这是Ostrich的fly方法”);
}
public static void main(String[] args) {
//创建Ostrich类
Ostrich os=new Ostrich();
//调用方法
os.fly();
}
}

结果：
这里写图片描述
从结果上看，子类不再调用父类方法，这种现象就叫方法重写，也叫方法覆盖。方法的重写要遵守“两同两小一大”规则，两同：方法名和形参列表相同；两小：子类的返回值类型和异常小于等于父类；一大：子类的访问修饰词大于等于父类。
注意: 1.不能对类方法进行重写。
2.父类的方法如果使用private进行修饰的，子类定义了一个分父类一样的方法则不属于重写
例如：报了一个警告信息
class BsseClass {
private void run() {}
}
public class SubClass {
public void run() {
}
}
这里写图片描述

6、Super的使用
子类继承父类后，父类的方法我们如果想进行使用的话，那就需要super进行调用，调用方式跟this使用差不多，但是super是在子类中使用。
例：

public class Ostrich extends Bird {
//重写父类的fly方法
public void fly() {
System.out.println(“这是Ostrich的fly方法”);
}
//调用父类的方法
public void baseFly() {
super.fly();
}
public static void main(String[] args) {
//创建Ostrich类
Ostrich os=new Ostrich();
//调用方法
os.fly();

    os.baseFly();
}

}
结果:
这是Ostrich的fly方法
这是Bird的fly方法
super使用方式还可以调用父类构造方法和成员变量
例如：
public class Bird {

protected int age;//鸟龄
protected String name;//鸟名
public void fly() {
    System.out.println("这是Bird的fly方法");
}   
/**
 *  构造方法
 * @param age 鸟龄
 * @param name 鸟名
 */
public Bird(int age, String name) {
    super();
    this.age = age;
    this.name = name;
}

}

public class Ostrich extends Bird {
public String name;//定义一个跟父类的属性
/**
* 父类的构造方法必须重写，否则报错
* 注意:父类只写了没有参数的构造方法，子类是不需要重写的，因为有一个默认的构造方法
* @param age
* @param name
*/
public Ostrich(int age, String name) {
//初始化父类数据
super(age, name);
}

public void show() {
    //打印父类的值        System.out.println(super.age+"_____"+super.name);
    //调用父类的方法
    super.fly();
}
public static void main(String[] args) {
    //创建Ostrich类
    Ostrich os=new Ostrich(12,"小鸟");
    os.show();
    // 父类的age值修改
    os.age=15;
    os.show();
}

}

扫描二维码关注公众号，回复： 2903388 查看本文章

结果：
12_____小鸟
这是Bird的fly方法
15_____小鸟
这是Bird的fly方法
在看一个代码如下：
class BaseClass {
public int age;

public BaseClass(int age) {
    this.age = age;
}

}

public class SubClass extends BaseClass {
private String name;
public SubClass(int age) {
super(age);
// TODO Auto-generated constructor stub
}
/**
* 构造方法重载，用于初始化数据
* @param age
* @param name
*/
public SubClass(int age, String name) {
super(age);
this.name = name;
}
public static void main(String[] args) {
SubClass sub = new SubClass(13, “测试”);
System.out.println(“age的值是：” + sub.age + “,name的值是:” + sub.name);
}

}

结果：
age的值是：13,name的值是:测试
我们重载了子类的构造方法，写入我们的一个name属性并初始化。
这里写图片描述
age是父类的属性，那么是子类的属性。

猜你喜欢