多态
一.可以使用instanceof运算符判断一个对象是否可以转换为指定的类型
代码：
public class TestInstanceof
{
public static void main(String[] args)
{
//声明hello时使用Object类，则hello的编译类型是Object，Object是所有类的父类
//但hello变量的实际类型是String
Object hello = "Hello";
//String是Object类的子类，所以返回true。
System.out.println("字符串是否是Object类的实例：" + (hello instanceof Object));
//返回true。
System.out.println("字符串是否是String类的实例：" + (hello instanceof String));
//返回false。
System.out.println("字符串是否是Math类的实例：" + (hello instanceof Math));
//String实现了Comparable接口，所以返回true。
System.out.println("字符串是否是Comparable接口的实例：" + (hello instanceof Comparable));
String a = "Hello";
//String类既不是Math类，也不是Math类的父类，所以下面代码编译无法通过
//System.out.println("字符串是否是Math类的实例：" + (a instanceof Math));
}
}
结果截图：
修改后的程序：
二.下列语句哪一个将引起编译错误?为什么?哪一个会引起运行时错误?为什么?
Mammal m=null ;
Dog d=new Dog();
Cat c=new Cat();
m=d;
d=m;
d=(Dog)m;
d=c;
c=(Cat)m;
第二句和第三句会引起编译错误。原因：子类对象可以直接赋给基类变量。基类对象要赋给子类对象变量,必须执行类型转换,其语法是:子类对象变量=(子类名)基类对象名;第五句会引起运行错误。原因：转换混乱。
三.
1.左边的程序运行结果是什么？
2. 你如何解释会得到这样的输出？
前两个都是parent和child分别调用的自己方法，输出自己的值。第三个parent引用子类child类的对象则调用child的方法。第四个是parent里面的Value加一，但是child里面的Value并没有加1还是调用child的方法，值不会变。第五个进行了类型转换，结果是child里面的Value+1输出结果为201。
3. 计算机是不会出错的，之所以得 到这样的运行结果也是有原因的，那么从这些运行结果中，你能总结出Java的哪些语法特性？
总结：当子类与父类拥有一样的方法，并且让一个父类变量引用一个子类对象时，到底调用哪个方法，由对象自己的“真实”类型所决定，这就是说：对象是子类型的，它就调用子类型的方法，是父类型的，它就调用父类型的方法。如果子类与父类有相同的字段,则子类中的字段会代替或隐藏父类的字段，子类方法中访问的是子类中的字段（而不是父类中的字段）。如果子类方法确实想访问父类中被隐藏的同名字段，可以用super关键字来访问它。
如果子类被当作父类使用,则通过子类访问的字段是父类的!
四. javap查看编译器为TestPolymorphism.java生成的字节码指令，然后通过互联网搜索资料，尝试从底层开始理解Java编译器是如何为多态代码生成字节码指令，在程序运行过程中，多态特性又是如何实现的。
代码：
class parent
{
public int value=100;
public void Introduce()
{
System.out.println("I'm father");
}
}
class Son extends parent
{
public int value=101;
public void Introduce()
{
System.out.println("I'm son");
}
}
class Daughter extends parent
{
public int value=102;
public void Introduce()
{
System.out.println("I'm daughter");
}
}
public class TestPolymorphism
{
public static void main(String args[])
{
parent p=new parent();
p.Introduce();
System.out.println(p.value);
p=new Son();
p.Introduce();
System.out.println(p.value);
p=new Daughter();
p.Introduce();
System.out.println(p.value);
}
}
结果截图：
在 java 语言中，多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。
（1）编译时多态
在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法。
（2）运行时多态
由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。程序
中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用
子类的方法。
重写方法的调用原则(为重点)：java 运行时系统根据调用该方法的实例，来决定调用哪个方法。
对子类的一个实例，如果子类重写了父类的方法，则运行时系统调用子类的方法；如果子类继承了
父类的方法（未重写），则运行时系统调用父类的方法。
五.zoo1
代码：
public class Zoo
{
public static void main(String args[])
{
Feeder f = new Feeder("小李");
// 饲养员小李喂养一只狮子
f.feedLion(new Lion());
// 饲养员小李喂养十只猴子
for (int i = 0; i < 10; i++)
{
f.feedMonkey(new Monkey());
}
// 饲养员小李喂养5只鸽子
for (int i = 0; i < 5; i++)
{
f.feedPigeon(new Pigeon());
}
}
}
class Feeder
{
public String name;
public Feeder(String name)
{
this.name = name;
}
public void feedLion(Lion l)
{
l.eat();
}
public void feedPigeon(Pigeon p)
{
p.eat();
}
public void feedMonkey(Monkey m)
{
m.eat();
}
}
class Lion
{
public void eat()
{
System.out.println("我不吃肉谁敢吃肉！");
}
}
class Monkey
{
public void eat()
{
System.out.println("我什么都吃，尤其喜欢香蕉。");
}
}
class Pigeon
{
public void eat()
{
System.out.println("我要减肥，所以每天只吃一点大米。");
}
}
结果截图
public class Zoo
{
public static void main(String args[])
{
Feeder f = new Feeder("小李");
// 饲养员小李喂养一只狮子
f.feedLion(new Lion());
// 饲养员小李喂养十只猴子
for (int i = 0; i < 10; i++)
{
f.feedMonkey(new Monkey());
}
// 饲养员小李喂养5只鸽子
for (int i = 0; i < 5; i++)
{
f.feedPigeon(new Pigeon());
}
}
}
class Feeder
{
public String name;
public Feeder(String name)
{
this.name = name;
}
public void feedLion(Lion l)
{
l.eat();
}
public void feedPigeon(Pigeon p)
{
p.eat();
}
public void feedMonkey(Monkey m)
{
m.eat();
}
}
class Lion
{
public void eat()
{
System.out.println("我不吃肉谁敢吃肉！");
}
}
class Monkey
{
public void eat()
{
System.out.println("我什么都吃，尤其喜欢香蕉。");
}
}
class Pigeon
{
public void eat()
{
System.out.println("我要减肥，所以每天只吃一点大米。");
}
}
结果截图：
zoo2：
代码：
public class Zoo
{
public static void main(String args[])
{
Feeder f = new Feeder("小李");
//饲养员小李喂养一只狮子
f.feedAnimal(new Lion());
//饲养员小李喂养十只猴子
for (int i = 0; i < 10; i++)
{
f.feedAnimal(new Monkey());
}
//饲养员小李喂养5只鸽子
for (int i = 0; i < 5; i++)
{
f.feedAnimal(new Pigeon());
}
}
}
class Feeder
{
public String name;
Feeder(String name)
{
this.name = name;
}
public void feedAnimal(Animal an)
{
an.eat();
}
}
abstract class Animal
{
public abstract void eat();
}
class Lion extends Animal
{
public void eat()
{
System.out.println("我不吃肉谁敢吃肉！");
}
}
class Monkey extends Animal
{
public void eat()
{
System.out.println("我什么都吃，尤其喜欢香蕉。");
}
}
class Pigeon extends Animal
{
public void eat()
{
System.out.println("我要减肥，所以每天只吃一点大米。");
}
}
结果截图：
zoo3：
代码：
public class Zoo {
public static void main(String args[]) {
Feeder f = new Feeder("小李");
Animal[] ans = new Animal[16];
//饲养员小李喂养一只狮子
ans[0] = new Lion();
//饲养员小李喂养十只猴子
for (int i = 0; i < 10; i++) {
ans[1 + i] = new Monkey();
}
//饲养员小李喂养5只鸽子
for (int i = 0; i < 5; i++) {
ans[11 + i] = new Pigeon();
}
f.feedAnimals(ans);
}
}
class Feeder {
public String name;
Feeder(String name) {
this.name = name;
}
public void feedAnimals(Animal[] ans) {
for (Animal an : ans) {
an.eat();
}
}
}
abstract class Animal {
public abstract void eat();
}
class Lion extends Animal {
public void eat() {
System.out.println("我不吃肉谁敢吃肉！");
}
}
class Monkey extends Animal {
public void eat() {
System.out.println("我什么都吃，尤其喜欢香蕉。");
}
}
class Pigeon extends Animal {
public void eat() {
System.out.println("我要减肥，所以每天只吃一点大米。");
}
}
结果截图：
zoo4：
代码：
import java.util.Vector;
public class Zoo {
public static void main(String args[]) {
Feeder f = new Feeder("小李");
Vector<Animal> ans = new Vector<Animal>();
//饲养员小李喂养一只狮子
ans.add(new Lion());
//饲养员小李喂养十只猴子
for (int i = 0; i < 10; i++) {
ans.add(new Monkey());
}
//饲养员小李喂养5只鸽子
for (int i = 0; i < 5; i++) {
ans.add(new Pigeon());
}
f.feedAnimals(ans);
}
}
class Feeder {
public String name;
Feeder(String name) {
this.name = name;
}
public void feedAnimals(Vector<Animal> ans) {
for (Animal an : ans) {
an.eat();
}
}
}
abstract class Animal {
public abstract void eat();
}
class Lion extends Animal {
public void eat() {
System.out.println("我不吃肉谁敢吃肉！");
}
}
class Monkey extends Animal {
public void eat() {
System.out.println("我什么都吃，尤其喜欢香蕉。");
}
}
class Pigeon extends Animal {
public void eat() {
System.out.println("我要减肥，所以每天只吃一点大米。");
}
}
结果截图：
五.用多态方法模拟ATM操作流程
代码：
import java.util.Scanner;
class cout1 extends Account{
cout1(String kahao,String name,String Date,int mima,double yue){
super(kahao,name,Date,mima,yue);
}
void qukuan(){
yue=yue-100;
if(yue>=0){
setyue(yue);
}
else
System.out.println("余额不足！");
}
}
class cout2 extends Account{
cout2(String kahao, String name, String Date, int mima, double yue) {
super(kahao, name, Date, mima, yue);
}
void qukuan(){
yue=yue-500;
if(yue>=0){
setyue(yue);
}
else
System.out.println("余额不足！");
}
}
class cout3 extends Account{
cout3(String kahao, String name, String Date, int mima, double yue) {
super(kahao, name, Date, mima, yue);
}
void qukuan(){
yue=yue-1000;
if(yue>=0){
setyue(yue);
}
else
System.out.println("余额不足！");
}
}
class cout4 extends Account{
cout4(String kahao, String name, String Date, int mima, double yue) {
super(kahao, name, Date, mima, yue);
}
void qukuan(){
yue=yue-1500;
if(yue>=0){
setyue(yue);
}
else
System.out.println("余额不足！");
}
}
class cout5 extends Account{
cout5(String kahao, String name, String Date, int mima, double yue) {
super(kahao, name, Date, mima, yue);
}
void qukuan(){
yue=yue-2000;
if(yue>=0){
setyue(yue);
}
else
System.out.println("余额不足！");
}
}
class cout6 extends Account{
cout6(String kahao, String name, String Date, int mima, double yue) {
super(kahao, name, Date, mima, yue);
}
void qukuan(){
yue=yue-5000;
if(yue>=0){
setyue(yue);
}
else
System.out.println("余额不足！");
}
}
class cout7 extends Account{
cout7(String kahao, String name, String Date, int mima, double yue) {
super(kahao, name, Date, mima, yue);
}
void qukuan(){
Scanner in = new Scanner(System.in);
System.out.println("请输入取款金额：");
int d=in.nextInt();
yue=yue-d;
if(yue>=0){
setyue(yue);
}
else
System.out.println("余额不足！");
}
}
class Account {
private String kahao;
private String name;
private String Date;
private int mima;
protected double yue;
Account(String kahao,String name,String Date,int mima,double yue){
this.kahao=kahao;
this.name=name;
this.Date=Date;
this.mima=mima;
this.yue=yue;
}
public void setkahao(String kahao){
this.kahao=kahao;
}
public String getkahao(){
return kahao;
}
public void setname(String name){
this.name=name;
}
public String getname(){
return name;
}
public void setDate(String Date){
this.Date=Date;
}
public String getDate(){
return Date;
}
public void setmima(int mima){
this.mima=mima;
}
public int getmima(){
return mima;
}
public void setyue(double yue){
this.yue=yue;
}
public double getyue(){
return yue;
}
void menu(){
System.out.println("欢迎使用ATM自助取款机，请选择功能");
System.out.println("1、存款");
System.out.println("2、取款");
System.out.println("3、转账");
System.out.println("4、修改密码");
System.out.println("5、查询余额");
System.out.println("6、退出程序");
}
void cunkuan(){
Scanner in = new Scanner(System.in);//定义一个Scanner对象
Scanner in1 = new Scanner(System.in);
System.out.println("请输入存款金额：");
double yu1 = in.nextInt();
yue=yue+yu1;
setyue(yue);
}
void qukuan(){}
void mima(){
Scanner in = new Scanner(System.in);
System.out.println("请输入修改的密码：");
int mi=in.nextInt();
setmima(mi);
System.out.println("修改成功！");
}
void zhuanzhang(){
System.out.println("请输入转账帐号：");
Scanner in = new Scanner(System.in);
String b=in.next();
System.out.println("请输入转账金额：");
int c=in.nextInt();
setyue(yue-c);
System.out.println("转账成功");
}
void chaxun(){
System.out.println("余额："+getyue());
}
}
public class Atm {
public static void main(String[] args) {
// TODO 自动生成的方法存根
System.out.println("请输入密码：");
Scanner input = new Scanner(System.in);
int ma=input.nextInt();
Account A=new Account("12345678901","xieshiyu","20161111",123456,2000);
if(ma==A.getmima()){
int i=1;
while(i==1){
Scanner in = new Scanner(System.in);
A.menu();
int n = in.nextInt();
if(n==1)
A.cunkuan();
if(n==2){
System.out.println("请输入取款金额：");
System.out.println("请输入选项：（1：100 2：500 3：1000 4：1500 5：2000 6：5000 7：其他金额）");
int a=input.nextInt();
double yu=A.getyue();
if(a==1)
{
yu=A.getyue();
A=new cout1("12345678901","xieshiyu","20161111",123456,yu);A.qukuan();
}
if(a==2)
{ yu=A.getyue();
A=new cout2("12345678901","xieshiyu","20161111",123,yu);A.qukuan();}
if(a==3)
{ yu=A.getyue();
A=new cout3("12345678901","xieshiyu","20161111",123456,yu);A.qukuan();}
if(a==4)
{ yu=A.getyue();
A=new cout4("12345678901","xieshiyu","20161111",123456,yu);A.qukuan();}
if(a==5)
{ yu=A.getyue();
A=new cout5("12345678901","xie","20161111",123456,yu);A.qukuan();}
if(a==6)
{ yu=A.getyue();
A=new cout6("12345678901","xieshiyu","20161111",123456,yu);A.qukuan();}
if(a==7)
{ yu=A.getyue();
A=new cout7("12345678901","xieshiyu","20161111",123456,yu);A.qukuan();}
}
if(n==3)
A.zhuanzhang();
if(n==4)
A.mima();
if(n==5)
A.chaxun();
if(n==6)
{
i=0;
System.out.println("退卡成功");
}
}
}
else
System.out.println("密码错误,登录失败");
}
}
结果截图：
