Java面向对象（四）

一、面向对象特征（三）---多态

父类引用指向子类的对象，从而产生多种形态
例： Animal dog = new Dog();
同一种事物，在不同的时刻表现不同的状态

前提：二者存在直接或间接的继承关系时，

/*
       //装狗
        public void putDog(Dog dog){
            System.out.println("把狗装进冰箱");
        }
        //装猫
        public void putCat(Cat cat){
            System.out.println("把猫装进冰箱");
        }

        传统方法，不利于程序扩展，每添加一个动物就需要添加一个方法，如果动物多了很麻烦

        //装动物
        public void putAnimal(Animal animal){
            System.out.println("把"+animal+"装进冰箱");
        }
        用父类类型表示任意的子类类型对象，利于程序扩展
    */

父类引用子类的对象，即形成多态

用法：先用父类类型定义子类类型的对象
然后就可以用用父类类型表示任意的子类类型对象
利于程序扩展

对于成员方法：
    Animal dog =new Dog();
    Animal cat = new Cat();
    dog.eat();//编译时调用的是Animal的方法，因为定义的是Animal类
    // 实际运行的时候调用的是dog/cat的方法，因为将Dog/Cat new出来了
    //编译看左边（Animal），运行看右边（new Dog();）
    cat.eat();
    不能调用子类本身有的，但父类没有的方法
对于静态成员方法
全都看左边，只能调用父类的静态成员方法（因为静态不存在重写）

对于成员变量：
只调用父类的成员变量

/*
        虽然多态理由扩展，但也存在问题：
            一旦转为父类类型，就调用不了子类本身特有的方法，只能调用父类的方法
            可以数据转换弥补（向下转型） Dog d = (Dog) dog;
            需要有继承关系
            需要注意的是，在方法中强制转换时，需要注意的时其他子类无法转换成同级子类
            可以在方法中使用if控制语句
            //
            public void putAnimal(Animal animal){
                System.out.println("把"+animal+"装进冰箱");
                animal.eat();//Animal类的方法
                if(animal instanceof Dog){//判断
                    Dog dog=(Dog)animal;//强制转换
                    dog.lookHome();//DOg类的方法
                    }
             }
             //
             instanceof 表示父类类型中持有的实际类型（animal）是否为子类类型（Dog）
             父类与子类类型相同返回true 不同返回false

         */

二、final 关键字

final int a=10;定义常量{属性（成员变量）}、修饰类、方法、参数
final修饰类：不能被定义为抽象类或接口，不能被继承
            例如：java.String类被final修饰，不能被继承
final修饰方法：不能被重写
final修饰参数：初始赋值后不能再被改变
            情况1、在类确定时值就确定，则直接赋值，赋值后值无法改变
                  所以建议用static修饰：final static 数据类型 成员变量
            情况2、在类定义时值不明确，需要在构造方法中对其赋值
                  因为成员变量值不能改变，所以成为常量
                  final int COUNT;
                     public Final(){
                  this.COUNT=10;
                  }
                  public Final(int count){
                     this.COUNT=count;
                  }
常量一般建议全部使用大写字母，多个字母使用下划线（例 MAX_VALUE）

三、接口

接口可以看作一种特殊的抽象类，里面也可以包含抽象方法
接口不能被创建对象，被其它类实现，重写抽象方法
主要也是用来定义功能的
java中的接口如何定义：jdk8之后可以定义常量、抽象方法、静态方法、默认方法

public interface InterfaceDemo {
    int num=10;//常量 public static final int num=10;
    void eat();//默认为public abstract void eat();
    public static void test(){
        //可以直接通过接口名调用
        System.out.println("可以直接通过接口名调用");
    }
    default void test1(){
        //默认方法 被子类继承后调用
    }
}

类通过 implements关键字实现接口，并且将抽象方法重写
类实现接口，要不重写接口的抽象方法，要么定义成抽象类，由他的子类再去实现

public class Class implements InterfaceDemo{

    @Override
    public void eat() {

    }
}

一个接口可以继承多个接口，一个类可以实现多个接口
public interface Interface3 extends Interface,Interface2{
}

默认方法被子类继承使用

public class Demo implements Interface3{
        @Override
        public void eat() {

    }

    @Override
    public void sleep() {

    }

    @Override
    public void test1() {

    }

    public static void main(String[] args) {
        Demo demo=new Demo();
        demo.test1();
    }
}

四、练习

1.按要求编写一个Java应用程序： (1)定义一个接口CanCry，描述会吼叫的方法 void cry(); (2)分别定义狗类（Dog）和猫类（Cat），实现CanCry接口。实现方法的功能分别为：打印输出“我是狗，我的叫声是汪汪汪”、“我是猫，我的叫声是喵喵喵”。 (3)定义一个主类Test， ①定义一个void makeCry(CanCry c)方法，其中让会吼叫的动物吼叫。 ②在main方法中创建狗类对象（dog）、猫类对象（cat）、Test类对象（t），用t调用makecry方法，让狗和猫吼叫。

//接口 CanCry
package com.wbc.oop.homework.day4;

public interface CanCry {
    void cry();
}
//Dog类
package com.wbc.oop.homework.day4;

public class Dog implements CanCry{
    @Override
    public void cry() {
        System.out.println("我是狗，我的叫声是汪汪汪");
    }
}
//Cat类
package com.wbc.oop.homework.day4;

public class Cat implements CanCry{

    @Override
    public void cry() {
        System.out.println("我是猫，我的叫声是喵喵喵");
    }
}
//Test类
package com.wbc.oop.homework.day4;

public class Test {
    public void makeCry(CanCry c){
        c.cry();
    }

    public static void main(String[] args) {
        CanCry dog = new Dog();
        CanCry cat = new Cat();
        Test t =new Test();
        t.makeCry(dog);
        t.makeCry(cat);
    }
}

2.根据所给类图关系定义类即可

//Interface接口
package com.wbc.oop.homework.day4.TeacherStudent;

public interface Interface {
    void working();
    void rest();
    void show();
}
//Person 类
package com.wbc.oop.homework.day4.TeacherStudent;

public abstract class Person {
    private String name;
    private char sex;
    private int age;

    public Person() {
    }

    public Person(String name, char sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public abstract void saying();
}
//Student类
package com.wbc.oop.homework.day4.TeacherStudent;

public class Student extends Person implements Interface{
    private String id;

    public Student() {
    }

    public Student(String id) {
        this.id = id;
    }

    public Student(String name, char sex, int age, String id) {
        super(name, sex, age);
        this.id = id;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public void working() {

    }

    @Override
    public void rest() {

    }

    @Override
    public void show() {

    }

    @Override
    public void saying() {

    }

    public void reading(){

    }
}
//Teacher 类
package com.wbc.oop.homework.day4.TeacherStudent;

public class Teacher extends Person implements Interface{
    private String department;

    public Teacher() {
    }

    public Teacher(String department) {
        this.department = department;
    }

    public Teacher(String name, char sex, int age, String department) {
        super(name, sex, age);
        this.department = department;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    @Override
    public void working() {

    }

    @Override
    public void rest() {

    }

    @Override
    public void show() {

    }

    @Override
    public void saying() {

    }

    public void teaching(){

    }
}

3.设计一个英雄抽象类, 类中属性:姓名,性别类中有各种攻击的抽象方法例如: 出拳,脚踢...(自己发挥)

 再设计出多个具体英雄子类(自己想象)继承英雄类,重写抽象方法
  
 再设计出一个游戏类供玩家使用,该类可以提供方法启动游戏
 启动后可以输入序号选择英雄人物,
 选择人物后开始游戏, 可以在控制台输入序号(序号个数与英雄类中定义的方法对应)调用英雄具体攻击方法

//Hero 类
package com.wbc.oop.homework.day4.Hero;

public abstract class Hero {
    private String name;
    private String gender;

    public Hero() {
    }

    public Hero(String name, String gender) {
        this.name = name;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public abstract void throwPunch();//出拳
    public abstract void shoot();//开枪
    public abstract void retreat();//撤退
    public abstract void toBeHurt(String name);
}
//Scout类
package com.wbc.oop.homework.day4.Hero;

public class Scout extends Hero{
    //侦察兵

    private String career;
    private int health;//生命值
    private int defenseValue;//防御力

    public Scout(String name, String gender) {
        super(name, gender);
        health = 100;
        defenseValue = 30;
        career ="侦察兵";
    }

    @Override
    public void throwPunch() {
        System.out.println(getName()+"出拳");
    }

    @Override
    public void shoot() {
        System.out.println(getName()+"开枪");
    }

    @Override
    public void retreat() {
        System.out.println(getName()+"撤退");
    }

    public int getHealth() {
        return health;
    }

    public int getDefenseValue() {
        return defenseValue;
    }

    public void toBeHurt(String name){
        System.out.println(name+"伤害了"+getName());
        health=getHealth()-30;
        defenseValue=getDefenseValue()-10;
        if(getDefenseValue()<=0){
            health-=10;
            defenseValue=0;
        }
        if(health<=0){
            System.out.println(career+getName()+"死了");
            health=0;

        }
        else{
            System.out.println(career+getName()+"被伤害了，生命力："+getHealth()+"防御力："+getDefenseValue());
        }

    }

}
//Tank类
package com.wbc.oop.homework.day4.Hero;

public class Tank extends Hero{
    private String career;
    private int health;//生命值
    private int defenseValue;//防御力

    public Tank(String name, String gender) {
        super(name, gender);
        health = 100;
        defenseValue = 100;
        career ="坦克";
    }

    @Override
    public void throwPunch() {
        System.out.println(getName()+"撞过去了");
    }

    @Override
    public void shoot() {
        System.out.println(getName()+"开炮");
    }

    @Override
    public void retreat() {
        System.out.println(getName()+"撤退");
    }

    public int getHealth() {
        return health;
    }

    public int getDefenseValue() {
        return defenseValue;
    }

    public void toBeHurt(String name){
        System.out.println(name+"伤害了"+getName());
        health=getHealth()-15;
        defenseValue=getDefenseValue()-20;
        if(getDefenseValue()<=0){
            health-=10;
            defenseValue=0;
        }
        if(health<=0){
            System.out.println(career+getName()+"炸毁了");
            health=0;

        }
        else{
            System.out.println(career+getName()+"被伤害了，生命力："+getHealth()+"防御力："+getDefenseValue());
        }

    }
}
//StartGame类
package com.wbc.oop.homework.day4.Hero;
import java.util.Scanner;
public class StartGame {



    public void startGame() {
        System.out.println("欢迎进入游戏！请选择您的英雄角色：");
        System.out.println("1. 侦察兵");
        System.out.println("2. 坦克");

        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();

        Hero hero = null;

        switch (choice) {
            case 1:
                hero = new Scout("Jack", "男");
                break;
            case 2:
                hero = new Tank("虎式坦克", null);
                break;
            default:
                System.out.println("请选择正确的英雄角色！");
                return;
        }
        Hero enemy=null;
        System.out.println("您选择了 " + hero.getName() + "，开始游戏！");
        if(hero instanceof Scout){
            enemy = new Tank("虎式坦克", null);
        }
        else if(hero instanceof Tank){
            enemy = new Scout("Jack", "男");
        }

        while (true) {
            System.out.println("请选择您要执行的操作：");
            System.out.println("1. 近身攻击");
            System.out.println("2. shoot");
            System.out.println("3. 撤退");
            System.out.println("4. 被攻击");

            int action = scanner.nextInt();

            switch (action) {
                case 1:
                    hero.throwPunch();
                    break;
                case 2:
                    hero.shoot();

                    break;
                case 3:
                    hero.retreat();
                    break;
                case 4:
                    if(hero instanceof Scout){
                        hero = (Scout) hero;
                        hero.toBeHurt(enemy.getName());
                    }
                    else if(hero instanceof Tank){
                        hero=(Tank)hero;
                        hero.toBeHurt(enemy.getName());
                    }
                default:
                    System.out.println("请输入正确的操作！");
                    break;
            }
        }
    }
}
//Test类
package com.wbc.oop.homework.day4.Hero;

public class Test {
    public static void main(String[] args) {
        StartGame game1 =new StartGame();
        game1.startGame();
    }
}