Java基础之继承性与super
作者：互联网
super 关键字的使用
super 理解为父类可以调属性方法构造器
super 的使用
在子类的方法或构造器中使用。通过“super.属性”或者“super.方法”的方式显示的调用
在父类中声明的属性或者方法。但是，通常情况下习惯省略super关键字
当子类和父类中定义了同名的属性时，想要调用父类的属性需要使用“super.属性”调用父类中的属性
当子类重写父类方法后想在子类中调用父类的方法就需要“super.方法名”调用父类的方法
super 构造器的调用
可以在子类的构造器中显示的使用“super（形参列表）”调用父类的构造器
“super（形参列表）”的使用必须出现在，子类构造器的首行
在构造器中只能调一次父类的构造器针对“this（形参列表）”与super（形参列表）只能二选一
在构造器的首行没有声明“this(形参类别)”或“super(形参列表)”，默认调用的时父类中空参构造器“super（）”
在类的多个构造器中至少有一个类的构造器使用了super（构造器），调用父的构造器
子类对象实例化的全过程
1.从结果上来看（继承性）
子类继承父类后，就获取了父类中声明的属性与方法
创建子类对象在堆空间中加载所有父类中声明的属性和对象
2.过程上来看
通过子类的构造器创建子类对象时，一定会直接或者间接调用父类的构造器，进而调用父类的父类的构造器
直到调用了java.lang.Object类中空参构造器为止，正因为加载过所有父类的结构，所以才可以看到内存中所有父类
的结构、子类对象才可以考虑调用
虽然创建子类对象时，调用了父类的构造器，但自始至终只创建一个对象
super调方属性的测试
父类
package com.chenxi.java3;
public class Person {
String name ;
int age;
int id= 1001;
public Person(){
}
public Person(String name){
this.name= name;
}
public Person(int age){
this.age= age;
}
public Person(String name,int age){
this.age=age;
this.name= name;
}
public void ead(){
System.out.println("四圣汇诛仙");
}
public void walk(){
System.out.println("人走路");
}
}
子类
package com.chenxi.java3;
public class Student extends Person{
String major;
int id =1002;
public Student(){
}
public Student(String major){
this.major=major;
}
public void ead(){
System.out.println("分辨忠与奸");
}
public void study(){
System.out.println("哪吒");
}
public void show(){
//name 表示当前对象。age表示调父类中对象
System.out.println(this.name+super.age);
System.out.println(id);//子类属性ID
System.out.println(super.id);//super父类属性中ID
}
}
测试类
package com.chenxi.java3;
/*
super 关键字的使用
1.super理解为父类的
2.super 可以调用属性方法构造器
*/
public class StudentTewst {
public static void main(String[] args) {
Student s1 = new Student();
s1.show();
}
}
测试
null0
1002
super 调父类方法测试、
父类
package com.chenxi.java3;
public class Person {
String name ;
int age;
int id= 1001;
public Person(){
}
public Person(String name){
this.name= name;
}
public Person(int age){
this.age= age;
}
public Person(String name,int age){
this.age=age;
this.name= name;
}
public void ead(){
System.out.println("四圣汇诛仙");
}
public void walk(){
System.out.println("人走路");
}
}
子类
package com.chenxi.java3;
public class Student extends Person{
String major;
int id =1002;
public Student(){
}
public Student(String major){
this.major=major;
}
public void ead(){
System.out.println("分辨忠与奸");
}
public void study(){
System.out.println("哪吒");
super.ead();//父类方法
this.ead();//子类方法
}
public void show(){
//name 表示当前对象。age表示调父类中对象
// System.out.println(this.name+super.age);
System.out.println(id);//子类属性ID
System.out.println(super.id);//super父类属性中ID
}
}
测试类
package com.chenxi.java3;
/*
super 关键字的使用
1.super理解为父类的
2.super 可以调用属性方法构造器
*/
public class StudentTewst {
public static void main(String[] args) {
Student s1 = new Student();
s1.show();
s1.study();
}
}
父类
package com.chenxi.java3;
public class Person {
String name ;
int age;
int id= 1001;
public Person(){
}
public Person(String name){
this.name= name;
}
public Person(int age){
this.age= age;
}
public Person(String name,int age){
this.age=age;
this.name= name;
}
public void ead(){
System.out.println("四圣汇诛仙");
}
public void walk(){
System.out.println("人走路");
}
}
子类
package com.chenxi.java3;
public class Student extends Person{
String major;
int id =1002;
public Student(){
}
public Student(String name,int age,String major){
super(name,age);//表示调用父类的参数构造器name和age
this.major=major;
}
public Student(String major){
this.major=major;
}
public void ead(){
System.out.println("分辨忠与奸");
}
public void study(){
System.out.println("哪吒");
super.ead();//父类方法
this.ead();//子类方法
}
public void show(){
//name 表示当前对象。age表示调父类中对象
// System.out.println(this.name+super.age);
System.out.println(id);//子类属性ID
System.out.println(super.id);//super父类属性中ID
System.out.println("父类age"+super.age+"父类name"+super.name);
}
}
测试类
public class StudentTewst {
public static void main(String[] args) {
// Student s1 = new Student();
// s1.show();
// s1.study();
Student s2 = new Student("chenxi",9,"玉虚法术");
s2.show();
}
}
测试结果
1002
1001
父类age9父类namechenxi
账户项目测试
子类
package com.chenxi.java3;
public class Account {
private int id;
private double balance;
private double annualInterestRate;
public Account (int id, double balance, double annualInterestRate ){
this.id= id;
this.balance= balance;
this.annualInterestRate=annualInterestRate;
}
// public Account(){
//
// }
public int getId(){
return id;
}
public double getBalance() {
return balance;
}
public double getAnnualInterestRate() {
return annualInterestRate;
}
public void setId(int id) {
this.id = id;
}
public void setBalance(double balance) {
this.balance = balance;
}
public void setAnnualInterestRate(double annualInterestRate) {
this.annualInterestRate = annualInterestRate;
}
public double getMonthlylnterest(){
return annualInterestRate/12;
}
/**
*
* @param amount
* 取款操作
*/
public void withdraw(double amount){
if (balance >= amount){
balance-=amount;
}else {
System.out.println("余额不足！");
}
}
public void deposit(double amount){
balance+=amount;
System.out.println("存钱成功，存入金额"+amount+"共计"+balance);
}
}
父类
package com.chenxi.java3;
/*
、创建 Account 类的一个子类 CheckAccount 代表可透支的账户，
该账户中定义一个属性 overdraft 代表可透支限额。
在 CheckAccount 类中重写 withdraw 方法，其算法如下：
如果（取款金额<账户余额），
可直接取款 如果（取款金额>账户余额），
计算需要透支的额度 判断可透支额 overdraft 是否足够支付本次透支需要，
如果可以 将账户余额修改为 0，
冲减可透支金额 如果不可以 提示用户超过可透支额的限额
*/
public class CheckAccount extends Account{
private double overdraft;//可透支限额
// public CheckAccount(){
//
// }
public CheckAccount(int id, double balance, double annualInterestRate ,double overdraft){
super(id,balance,annualInterestRate);//super构造器的调用
this.overdraft= overdraft;
}
public void withdraw(double amount){
if (getBalance()>=amount){
setBalance(getBalance()-amount);
}
else if((overdraft+getBalance())>=amount){
// setBalance(0);
overdraft -= amount;
overdraft += getBalance();
setBalance(0);
// return;
}
// else if (overdraft>=amount-getBalance()){
// overdraft-= (amount-getBalance());
// setBalance(0);
// }
else {
System.out.println("账户余额不足，取款失败");
}
}
public double getOverdraft() {
return overdraft;
}
public void setOverdraft(double overdraft) {
this.overdraft = overdraft;
}
// public void deposit(double amount) {
// overdraft+=amount;
//
// setBalance();
// }
}
测试类
package com.chenxi.java3;
public class CheckAccountTest {
public static void main(String[] args) {
CheckAccount checkAccount= new CheckAccount(1122,20000,0.0089,5000);
checkAccount.withdraw(21000);
System.out.println("账户余额为"+checkAccount.getBalance());
System.out.println("可透支余额为"+checkAccount.getOverdraft());
}
}
测试结果
账户余额为0.0 可透支余额为4000.0
标签：Java,name,age,void,继承性,父类,super,public 来源： https://www.cnblogs.com/rdchenxi/p/14631207.html