方法重载
方法重载，指同一个类中的多个方法
方法名相同
参数列表不同
（与返回值，访问修饰符无关）
构造重载函数
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.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.抽象方法必须在子类中被实现，除非子类也是一个抽象类
扫一扫
1246
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
