java.面向对象.继承性
java.面向对象.继承性
* 关于java语言当中的继承
* 1.继承是面向对象三大特征之一
* 2.继承的基本作用是：代码复用。但是继承最重要的作用是：有了继承之后才有方法的覆盖、多态机制
* 3.继承语法格式：
* [修饰符列表] class 类名 extends 父类名{
* 类体 = 属性 + 方法
* }
* 4.java语言中的继承只支持单继承，一个类不能同时继承好多类。
* 5.关于继承中的一些术语：
* B类继承A类
* B类：子类、派生类
* A类：父类、基类、超类
* 6.子类继承那些？
* - 构造方法不继承
* - 私有的不继承
* - 其他数据均可继承
* 7.虽然Java语言中只支持单继承，但是一个类也可以间接继承其他类：
* A extends B ；
* C extends B ；
* 则C间接继承了A
* 8.在Java中，如果一个类没有显示继承任何类，那么他默认继承object类
父类
package 继承性;
//父类
public class Account {
//账号
private String actno;
//余额
private double balance;
public Account() {
super();
// TODO Auto-generated constructor stub
}
public Account(String actno, double balance) {
super();
this.actno = actno;
this.balance = balance;
}
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
}
这是一个无参构造器
super是关键字
public Account() {
super();
// TODO Auto-generated constructor stub
}
由于在现实生活中，每张信用卡都有唯一账户。账户可以是农行、建设、工商…所以我们把账户共有部分设为父类，信用卡设为子类，每个账户中都有账号、余额，而信用度是信用卡的特殊标识，所以在继承后不需要重建账户、余额，只需要新建信誉度。
子类
package 继承性;
//子类
public class CrediaAccount extends Account{
//信誉度
private double credits;
public CrediaAccount() {
super();
}
public double getCredits() {
return credits;
}
public void setCredits(double credits) {
this.credits = credits;
}
}
测试类
public class ExtendsTest {
/*
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//查找类型:ctrl+shift+t
//查找资源:ctrl+shift+r
ExtendsTest et = new ExtendsTest();
String s = et.toString();
System.out.println(s);//继承性.ExtendsTest@2e6e1408
CrediaAccount c = new CrediaAccount();
c.setActno("011");
c.setBalance(1000.0);
c.setCredits(99.0);
System.out.println(c.getActno()+"\n"+c.getBalance()+"\n"+c.getCredits());
}
}
结果：
继承性.ExtendsTest@5d888759
011
1000.0
99.0
由于采取了继承措施，所以子类将直接继承父类里的方法。也就是说在子类中无形的存在了父类里除构造方法以外的方法
c.setActno("011");
c.setBalance(1000.0);
c.setCredits(99.0);
继承性断点测试：宠物系统
public class Pet {
// 属性
private String name = "无名氏"; // 名字 默认值
private int health = 100; // 健康值 默认值
private int love = 0; // 亲密度 默认值
/**
* 无参构造方法
*/
public Pet(){
this.health = 95;
System.out.println("执行宠物的无参构造方法。");
}
/**
* 有参构造方法
* @author DELL 昵称
*/
public Pet(String name){
this.name = name;
}
/**
* 指定读取宠物的姓名
* @return
*/
public String getName() {
return name;
}
/**
* 指定读取宠物的健康信息
* @return
*/
public int getHealth() {
return health;
}
/**
* 指定读取宠物的亲密度信息
* @return
*/
public int getLove() {
return love;
}
/**
* 输出宠物的信息
*/
public void print() {
System.out.println("宠物的自白：\n我的名字叫" + this.name + ",健康值是" + this.health
+ ",和主人的亲密值是" + this.love + "。" );
}
}
public class Penguin extends Pet {
private String sex; // 性别
/**
* 有参构造方法
*
* @param name
* 昵称
* @param sex
* 性别
*/
public Penguin(String name, String sex) {
super(name); // 这里不能用 this.name=name
this.sex = sex;
}
public String getSex() {
return sex;
}
/**
* 重写父类中的print()方法
*/
public void print() {
super.print();
System.out.println("我是一只"+this.sex+"。");
}
}
public class Dog extends Pet {
private String strain; // 品种
/**
* 有参构造方法
*
* @param name
* 昵称
* @param strain
* 品种
*/
public Dog(String name, String strain) {
super(name); // 这里不能用 this.name=name
this.strain = strain;
}
public String getStrain() {
return strain;
}
/**
* 重写父类中的print()方法
*/
public void print() {
super.print();
System.out.println("我是一只"+this.strain+"。");
}
}
public class Text {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// 创建宠物对象
Pet pet = new Pet("贝贝");
pet.print();
// 创建狗狗对象
Dog d = new Dog("欧欧", "雪纳瑞");
d.print();
// 创建企鹅对象
Penguin p = new Penguin("喃喃", "Q妹");
p.print();
}
}
步骤一：添加断点
第二步：运行Debug
第三步：测试
F5(step into)：进入方法
F6(step over)：下一步
首先进入父类方法会在loadClass中返回一个值，F6进入下一步
返回之后再次进入到测试类，F5进入方法体内
显然，通过父类的构造器 Pet(String name)，我们将“贝贝”赋到属性name上,接着F6对其他属性进行赋值，由于未在测试类中赋予新的值，系统将采用创建属性时的默认值。
赋好之后，会跳出该行进入下一行，执行print()方法，同样的F5进入该方法
进入方法后，将执行方法体内代码块
