10.方法重载，重写，继承
2017-08-15 21:28
423 查看
方法重载
方法重载，指同一个类中的多个方法
方法名相同
参数列表不同
（与返回值，访问修饰符无关）
构造重载函数
package com.jredu.ch11;
public class Ch01 {
//重载
public void avg(int a,int b){
}
public double avg(double a){
return a;
}
}
面向对象的优点
与人类的思维习惯一致
把人类解决问题的思维过程转变成为程序能够理解的过程
信息隐藏，提高了程序的可维护性和安全性
封装实现了模块化和信息隐藏
封装使得对象外部不能随意访问对象的属性和方法
提高了程序的可重用性
一个类可以创建多个对象实例，增加了重用性
继承
实例：
（父类Engineer）package com.jredu.oop.ch02;
/**
* 工程师类（被继承）
* @author 小花
*
*/
public class Engineer {
//共有的属性和放法
//protected子类可以继承
protected int id;
protected String name;
protected String enterTime;
public Engineer(int id, String name, String enterTime) {
super();
this.id = id;
this.name = name;
this.enterTime = enterTime;
}
public void showInfo(){
System.out.println("编号："+id+"\t姓名："+name+"\t入职时间："+enterTime);
}
}
（派生类SoftEnginee）package com.jredu.oop.ch02;
/**
* 软件工程师类
* 继承工程师类
* @author 小花
*
*/
public class SoftEngineer extends Engineer {
//独有的属性和方法
private String type;//语言类型
public SoftEngineer(int id, String name, String enterTime,String type) {
super(id, name, enterTime);
// TODO Auto-generated constructor stub
this.type=type;
}
public void coding(){
System.out.println("正在编程");
}
@Override//重写
public void showInfo() {
// TODO Auto-generated method stub
super.showInfo();
System.
1a862
out.println("语言是"+type);
}
}
（派生类TestEngineer ）package com.jredu.oop.ch02;
/**
* 测试工程师类
* 继承工程师类
* @author 小花
*
*/
public class TestEngineer extends Engineer {
//独有的属性和方法
private String level;
public TestEngineer(int id, String name, String enterTime,String level) {
super(id, name, enterTime);
// TODO Auto-generated constructor stub
this.level=level;
}
public void test(){
//两个同指一个id
super.id=10;
id=25;
System.out.println("正在测试");
}
/**
* 方法重写
* 默认行为是调用父类的方法内容
* 可以在子类中修改父类的方法内容
*/
public void showInfo(){
super.showInfo();
//System.out.println("编号："+id+"\t姓名："+name+"\t入职时间："+enterTime);
System.out.println("等级是"+level);
}
}
子类访问父类成员
使用super关键字
访问父类属性
super.name; (super代表父类对象)
访问父类方法
super.print();
继承后的初始化顺序
有些父类成员不能继承
子类不能访问父类private成员
子类与父类不在同包，使用默认访问权限的成员
构造方法（构造方法是绝对不可以被继承的
在 Java 中，无论是 explicit 还是 implicit 方式，都要求在子类的构造方法中调用其父类的构造方法。如果父类无构造方法（其实是一个默认无参的构造方法），那么子类的构造方法中会自动进行调用；如果 父类有自己的构造方法（这时父类不会有默认无参的构造方法），那么在子类的构造方法中，必须要调用父类的某个构造方法，而且必须是在构造方法的第一个语句 中进行调用。）
使用继承的情况：
继承与真实世界类似
继承是代码重用的一种方式
继承的实例：
package com.jredu.oop.ch02.exer7;
public abstract class Card {
protected int no;
protected int pwd;
protected String name;
protected double money;
public Card(int no, int pwd, String name, double money) {
super();
this.no = no;
this.pwd = pwd;
this.name = name;
this.money = money;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public int getPwd() {
return pwd;
}
public void setPwd(int pwd) {
this.pwd = pwd;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
public void search() {
System.out.println("您的银行卡余额是"+money);
}
public abstract boolean getMoney(int money);
}
package com.jredu.oop.ch02.exer7;
public class LocalCard extends
Card {
public LocalCard(int no, int pwd, String name, double money) {
super(no, pwd, name, money);
// TODO Auto-generated constructor stub
}
@Override
public boolean getMoney(int money) {
// TODO Auto-generated method stub
//本行卡取款不要钱
if(this.money-money>=0) {
this.money-=money;
return true;
}
return false;
}
public boolean changeMoney(int money) {
//本行卡转账不要钱
if(this.money-money>=0) {
this.money-=money;
}
return false;
}
}
package com.jredu.oop.ch02.exer7;
public class OtherCard extends
Card {
public OtherCard(int no, int pwd, String name, double money) {
super(no, pwd, name, money);
// TODO Auto-generated constructor stub
}
/**
* 传入钱数
*/
@Override
public boolean getMoney(int money) {
// TODO Auto-generated method stub
//非本行卡取款两元手续费
if(this.money-money-2>=0) {
this.money-=money;
sub();
return true;
}
return false;
}
/**
* 减少两元钱
*/
private void sub() {
money-=2;
}
}
package com.jredu.oop.ch02.exer7;
import java.util.Scanner;
public class CardTest {
Scanner in=new Scanner(System.in
);
public boolean check(Card card) {
for(int i=0;i<3;i++) {
System.out.print("请输入密码");
int pwd=in.nextInt();
if(pwd==card.getPwd()) {
return true;
} else {
System.out.println("密码不正确，您还有"+(2-i)+"次机会");
}
}
System.out.println("密码三次错误，卡片已被吞掉");
return false;
}
public Card chooseCard() {
System.out.print("请选择卡片类型(1.本行卡2.他行卡)");
int choose=in.nextInt();
if(choose==1) {
return new LocalCard(1, 111111, "张三", 20000);
} else {
return new OtherCard(2, 123456, "李四", 20000);
}
}
/**
* 选择菜单
* @param card
*/
public void chooseMenu(Card card) {
System.out.print("请选择功能");
if(card instanceof LocalCard) {
System.out.print("1.查询2.取款3.转账");
} else {
System.out.print("1.查询2.取款");
}
switch (in.nextInt()) {
case 1:
card.search();
break;
case 2:
chooseMoney(card, 2);
break;
case 3:
if(card instanceof LocalCard) {
chooseMoney(card, 3);
} else {
System.out.println("抱歉，您没有该项功能使用权限");
}
break;
}
}
/**
* 选择金额
* @param card
* @return
*/
public void chooseMoney(Card card,int type) {
String code="";
do{
System.out.println("请输入0到6任意数字选择对应钱数:");
System.out.println("0.手动输入\t1.100元\t2.300元\t3.500元");
System.out.println("4.1000元\t5.3000元\t6.5000元");
code=in.next();
boolean repeat=true;
switch (code) {
case "0":
System.out.println("请输入金额(必须是100的倍数，最小 100，最高1000)");
int money=in.nextInt();
if(money%100==0&&money>0&&money<1100) {
repeat=checkMoney(money, type, card);
} else {
System.out.println("选择金额错误");
}
break;
case "1":
repeat=checkMoney(100, type, card);
break;
case "2":
repeat=checkMoney(300, type, card);
break;
case "3":
repeat=checkMoney(500, type, card);
break;
case "4":
repeat=checkMoney(1000, type, card);
break;
case "5":
repeat=checkMoney(3000, type, card);
break;
case "6":
repeat=checkMoney(5000, type, card);
break;
default:
//输入错误
System.out.println("输入错误");
break;
}
if(repeat) {
break;
}
System.out.println("是否继续(y/n)");
String code2=in.next();
if(!code2.equals("y")) {
System.out.println("谢谢使用，请取卡");
break;
}
} while(true);
}
/**
* 取款或者转账
* @param money
* @param code
* @param card
* @return boolean true 代表余额为0，false代表余额还有剩余
*/
public boolean checkMoney(int money,int type,Card card) {
switch (type) {
case 2:
//取款
if(card.getMoney(money)) {
System.out.println("取款成功");
} else {
System.out.println("取款失败");
}
break;
case 3:
//转账
if(((LocalCard)card).changeMoney(money)) {
System.out.println("转账成功");
} else {
System.out.println("转账失败");
}
break;
}
if(card.getMoney()==0) {
System.out.println("余额为0，谢谢使用，请取卡");
return true;
}
return false;
}
public static void main(String[] args) {
CardTest cardTest=new CardTest();
Card card=cardTest.chooseCard();
if(cardTest.check(card)) {
cardTest.chooseMenu(card);
}
}
}
访问修饰符
protected：
可以修饰属性和方法
本类，同包，子类可以访问
方法重写
方法重写的规则：
1.在继承关系的子类中
2.重写的方法名、参数、返回值类型必须和父类相同
@Override重写
3.私有方法不能继承因而无法重写
抽象的方法
abstract---抽象方法
1.抽象的方法没有方法体，即不能被实例化
2.抽象的方法必须在抽象类里
3.抽象方法必须在子类中被实现，除非子类也是一个抽象类
方法重载，指同一个类中的多个方法
方法名相同
参数列表不同
（与返回值，访问修饰符无关）
构造重载函数
package com.jredu.ch11;
public class Ch01 {
//重载
public void avg(int a,int b){
}
public double avg(double a){
return a;
}
}
面向对象的优点
与人类的思维习惯一致
把人类解决问题的思维过程转变成为程序能够理解的过程
信息隐藏，提高了程序的可维护性和安全性
封装实现了模块化和信息隐藏
封装使得对象外部不能随意访问对象的属性和方法
提高了程序的可重用性
一个类可以创建多个对象实例，增加了重用性
继承
实例：
（父类Engineer）package com.jredu.oop.ch02;
/**
* 工程师类（被继承）
* @author 小花
*
*/
public class Engineer {
//共有的属性和放法
//protected子类可以继承
protected int id;
protected String name;
protected String enterTime;
public Engineer(int id, String name, String enterTime) {
super();
this.id = id;
this.name = name;
this.enterTime = enterTime;
}
public void showInfo(){
System.out.println("编号："+id+"\t姓名："+name+"\t入职时间："+enterTime);
}
}
（派生类SoftEnginee）package com.jredu.oop.ch02;
/**
* 软件工程师类
* 继承工程师类
* @author 小花
*
*/
public class SoftEngineer extends Engineer {
//独有的属性和方法
private String type;//语言类型
public SoftEngineer(int id, String name, String enterTime,String type) {
super(id, name, enterTime);
// TODO Auto-generated constructor stub
this.type=type;
}
public void coding(){
System.out.println("正在编程");
}
@Override//重写
public void showInfo() {
// TODO Auto-generated method stub
super.showInfo();
System.
1a862
out.println("语言是"+type);
}
}
（派生类TestEngineer ）package com.jredu.oop.ch02;
/**
* 测试工程师类
* 继承工程师类
* @author 小花
*
*/
public class TestEngineer extends Engineer {
//独有的属性和方法
private String level;
public TestEngineer(int id, String name, String enterTime,String level) {
super(id, name, enterTime);
// TODO Auto-generated constructor stub
this.level=level;
}
public void test(){
//两个同指一个id
super.id=10;
id=25;
System.out.println("正在测试");
}
/**
* 方法重写
* 默认行为是调用父类的方法内容
* 可以在子类中修改父类的方法内容
*/
public void showInfo(){
super.showInfo();
//System.out.println("编号："+id+"\t姓名："+name+"\t入职时间："+enterTime);
System.out.println("等级是"+level);
}
}
子类访问父类成员
使用super关键字
访问父类属性
super.name; (super代表父类对象)
访问父类方法
super.print();
继承后的初始化顺序
有些父类成员不能继承
子类不能访问父类private成员
子类与父类不在同包，使用默认访问权限的成员
构造方法（构造方法是绝对不可以被继承的
在 Java 中，无论是 explicit 还是 implicit 方式，都要求在子类的构造方法中调用其父类的构造方法。如果父类无构造方法（其实是一个默认无参的构造方法），那么子类的构造方法中会自动进行调用；如果 父类有自己的构造方法（这时父类不会有默认无参的构造方法），那么在子类的构造方法中，必须要调用父类的某个构造方法，而且必须是在构造方法的第一个语句 中进行调用。）
使用继承的情况：
继承与真实世界类似
继承是代码重用的一种方式
继承的实例：
package com.jredu.oop.ch02.exer7;
public abstract class Card {
protected int no;
protected int pwd;
protected String name;
protected double money;
public Card(int no, int pwd, String name, double money) {
super();
this.no = no;
this.pwd = pwd;
this.name = name;
this.money = money;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public int getPwd() {
return pwd;
}
public void setPwd(int pwd) {
this.pwd = pwd;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
public void search() {
System.out.println("您的银行卡余额是"+money);
}
public abstract boolean getMoney(int money);
}
package com.jredu.oop.ch02.exer7;
public class LocalCard extends
Card {
public LocalCard(int no, int pwd, String name, double money) {
super(no, pwd, name, money);
// TODO Auto-generated constructor stub
}
@Override
public boolean getMoney(int money) {
// TODO Auto-generated method stub
//本行卡取款不要钱
if(this.money-money>=0) {
this.money-=money;
return true;
}
return false;
}
public boolean changeMoney(int money) {
//本行卡转账不要钱
if(this.money-money>=0) {
this.money-=money;
}
return false;
}
}
package com.jredu.oop.ch02.exer7;
public class OtherCard extends
Card {
public OtherCard(int no, int pwd, String name, double money) {
super(no, pwd, name, money);
// TODO Auto-generated constructor stub
}
/**
* 传入钱数
*/
@Override
public boolean getMoney(int money) {
// TODO Auto-generated method stub
//非本行卡取款两元手续费
if(this.money-money-2>=0) {
this.money-=money;
sub();
return true;
}
return false;
}
/**
* 减少两元钱
*/
private void sub() {
money-=2;
}
}
package com.jredu.oop.ch02.exer7;
import java.util.Scanner;
public class CardTest {
Scanner in=new Scanner(System.in
);
public boolean check(Card card) {
for(int i=0;i<3;i++) {
System.out.print("请输入密码");
int pwd=in.nextInt();
if(pwd==card.getPwd()) {
return true;
} else {
System.out.println("密码不正确，您还有"+(2-i)+"次机会");
}
}
System.out.println("密码三次错误，卡片已被吞掉");
return false;
}
public Card chooseCard() {
System.out.print("请选择卡片类型(1.本行卡2.他行卡)");
int choose=in.nextInt();
if(choose==1) {
return new LocalCard(1, 111111, "张三", 20000);
} else {
return new OtherCard(2, 123456, "李四", 20000);
}
}
/**
* 选择菜单
* @param card
*/
public void chooseMenu(Card card) {
System.out.print("请选择功能");
if(card instanceof LocalCard) {
System.out.print("1.查询2.取款3.转账");
} else {
System.out.print("1.查询2.取款");
}
switch (in.nextInt()) {
case 1:
card.search();
break;
case 2:
chooseMoney(card, 2);
break;
case 3:
if(card instanceof LocalCard) {
chooseMoney(card, 3);
} else {
System.out.println("抱歉，您没有该项功能使用权限");
}
break;
}
}
/**
* 选择金额
* @param card
* @return
*/
public void chooseMoney(Card card,int type) {
String code="";
do{
System.out.println("请输入0到6任意数字选择对应钱数:");
System.out.println("0.手动输入\t1.100元\t2.300元\t3.500元");
System.out.println("4.1000元\t5.3000元\t6.5000元");
code=in.next();
boolean repeat=true;
switch (code) {
case "0":
System.out.println("请输入金额(必须是100的倍数，最小 100，最高1000)");
int money=in.nextInt();
if(money%100==0&&money>0&&money<1100) {
repeat=checkMoney(money, type, card);
} else {
System.out.println("选择金额错误");
}
break;
case "1":
repeat=checkMoney(100, type, card);
break;
case "2":
repeat=checkMoney(300, type, card);
break;
case "3":
repeat=checkMoney(500, type, card);
break;
case "4":
repeat=checkMoney(1000, type, card);
break;
case "5":
repeat=checkMoney(3000, type, card);
break;
case "6":
repeat=checkMoney(5000, type, card);
break;
default:
//输入错误
System.out.println("输入错误");
break;
}
if(repeat) {
break;
}
System.out.println("是否继续(y/n)");
String code2=in.next();
if(!code2.equals("y")) {
System.out.println("谢谢使用，请取卡");
break;
}
} while(true);
}
/**
* 取款或者转账
* @param money
* @param code
* @param card
* @return boolean true 代表余额为0，false代表余额还有剩余
*/
public boolean checkMoney(int money,int type,Card card) {
switch (type) {
case 2:
//取款
if(card.getMoney(money)) {
System.out.println("取款成功");
} else {
System.out.println("取款失败");
}
break;
case 3:
//转账
if(((LocalCard)card).changeMoney(money)) {
System.out.println("转账成功");
} else {
System.out.println("转账失败");
}
break;
}
if(card.getMoney()==0) {
System.out.println("余额为0，谢谢使用，请取卡");
return true;
}
return false;
}
public static void main(String[] args) {
CardTest cardTest=new CardTest();
Card card=cardTest.chooseCard();
if(cardTest.check(card)) {
cardTest.chooseMenu(card);
}
}
}
访问修饰符
protected：
可以修饰属性和方法
本类，同包，子类可以访问
方法重写
方法重写的规则：
1.在继承关系的子类中
2.重写的方法名、参数、返回值类型必须和父类相同
@Override重写
3.私有方法不能继承因而无法重写
抽象的方法
abstract---抽象方法
1.抽象的方法没有方法体，即不能被实例化
2.抽象的方法必须在抽象类里
3.抽象方法必须在子类中被实现，除非子类也是一个抽象类
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 类的继承，抽象类，接口，方法重写和重载
- 笔记整理 静态与非静态 继承哪一些 继承链 重写 属性方法重载 PDO
- 方法的重载与重写的关系（区别）；static关键字；单例设计模式；继承；
- JavaDay06--Homework（方法重载和重写的区别，构造方法，继承类）
- 类的继承/方法重写/重载
- JAVA中继承时方法的重载(overload)与重写/覆写(override)
- 关于继承中，方法的重写和重载（摘抄）
- 面向对象的特征之—继承(方法重载 vs 方法重写)
- 第二节类的继承、方法的重载、方法的重写、对象的引用和构造器
- 构造器、方法重载、继承、方法重写、自动转型、多态课堂笔记
- JAVA基础再回首（六）——父与子的继承、super关键字、方法重写、方法重载
- 杰神之Java代码块和方法的继承(方法重载和方法重写)
- JAVA【类】析构器、重载与继承、方法的重写、自动转型、多态、方法与类的分类、接口继承
- Objective-c 类的继承 方法重写 方法重载
- Objective-C 类的继承、方法的重写和重载
- java笔记(三)[java中的继承&java中的方法重载,重写,重构&java中的向上转型和乡下转型&java中的抽象类和接口&java中的接口向上转型]
- 类、对象、继承、封装、多态、方法的重载和重写、Java的访问修饰符与其它关键字
- java代码-------继承的方法----重写还是重载
- java重载方法重写、继承封装
- C#中继承实现父类方法、重写、重载