实训20190806

Java的异常是通过5个关键字来实现的：try（执行可能产生异常的代码），catch（捕获异常），finally（无论是否发生异常，代码总能执行），throw（声明方法可能要抛出的各种异常），throws（手动抛出异常）

捕获异常，声明异常，抛出异常

三种情况：1.没有出现异常

 

1. 出现异常：try→产生异常对象→异常匹配类型→进入catch块→程序继续执行

          3.异常类型不匹配：try→产生异常对象→异常类型不匹配→异常中断执行

 

 

printStackTrace的堆栈跟踪功能显示出程序运行到当前类的执行流程。

 

在try-catch块后加入finally

1.是否发生异常都执行

2.不执行的唯一情况：有异常，catch块有System.exit(1)，中断程序，退出Java虚拟机

存在return的try-catch-finally块：出现异常：try→产生异常对象→异常匹配类型→进入catch块→执行finally块→执行return退出方法

多重catch块：

引发多种类型的异常：1.排列catch语句的顺序：先子类后父类；2.发生异常时按顺序逐个匹配；3.只执行第一个与异常类型匹配的catch语句。 

 

声明异常，在一个方法中抛出了异常，如何通知调用者

 

除了系统自动抛出异常外，有些问题需要程序员自行抛出异常：

 

 

接口：实现防盗门的功能：将门定义为抽象类，锁定义为接口，防盗门继承门，实现锁的借口。

Interface修饰接口，对于接口当中所有方法都是public abstract，所以可以省略。

接口的特性：1.不可以被实例化 2.实现类必须实现接口的所有方法 3.实现类可以实现多个接口，由此实现多继承 4.接口中的变量都是静态常量  5 接口之间可以通过extends实现继承关系，一个接口可以继承多个接口，但接口不能继承类。

根据需求设计方法，实现所有方法，用多态的方式使用

接口是一种能力，关心实现类有何能力，而不关心类的实现细节。

 作业：

1.请说明下面的代码中存在什么问题，该如何解决。

public interface Utility {

}

public class Phone implements Utility {

void use(){

System.out.println("using phone");

}

}

public class Test {

public static void main(String[] args) {

Utility util = new Phone();

util.use();

}

}

util.use();出错，父类直接调用了子类特有的方法，而父类中并没有该方法。

将Utility util = new Phone();改成Phone p = new Phone();即可，再调用sue()方法。

2.阅读如下代码，指出其中存在的错误，并说明其原因。

public interface Constants {

int MAX = 100000;

int MIN = 1;

 

}

public class Test {

public static void main(String[] args) {

Constants con  = new Constants();//不能实例化接口

System.out.println(con.MAX);//不能实例化后调用属性

int i = 50;

if(i>Constants.MAX){//不能用接口名调用属性

Constants.MAX = i;//全局静态常量不能被修改

}

}

}

 3.阅读如下Java代码，给出运行结果。

public interface Animal {

void shout();

}

 

public class Cat implements Animal {

 

@Override

public void shout() {

System.out.println("M M！");

}

}

 

public class Dog implements Animal {

 

@Override

public void shout() {

System.out.println("w w!");

}

}

 

public class Stores {

public static Animal get(String choice){

if(choice.equalsIgnoreCase("dog")){

return new Dog();

}else{

return new Cat();

}

}

}

 

public class AnimalTest {

 

public static void main(String[] args) {

Animal a1 = Stores.get("dog");

a1.shout();

}

}

运行结果：

w w!

4.在第三题的基础上进行功能扩展，要求如下。

增加一种新的动物类型：Pig（猪），实现shout()方法。

修改Store类的get()方法：如果传入的参数是字符串dog，则返回一个Dog对象；如果传入的参数是字符串pig，则返回一个Pig对象；否则，返回一个Cat对象。

在测试类Test中加以测试：向Store类的get()方法中传入参数“pig”，并在返回的对象调用shout()方法，看看与预期的结果是否一致。

 

public class Pig implements Animal {
    @Override
    public void shout() {
        System.out.println("h h!");
    }
}

 

public class Stores {
    public static Animal get(String choice){
        if(choice.equalsIgnoreCase("dog")){
            return new Dog();
        }else if(choice.equalsIgnoreCase("pig")){
            return new Pig();
        }else{
            return new Cat();
        }
    }
}

public class AnimalTest {

    public static void main(String[] args) {
        Animal a1 = Stores.get("pig");
        a1.shout();
    }
}

5.对贯穿本书的案例电子宠物系统的类结构进行重构，要求如下。

定义Eatable接口，在接口中定义eat()方法，表示吃饭功能。

定义FiyingDiscCatchable接口，在接口中定义catchingFiyDisc()方法，表示接飞盘功能。

定义Swimmable接口，在接口中定义swim()方法，表示游泳功能。

定义抽象类Pet，包括宠物名称（name），健康值（health）和与主人亲密度（love）属性，并提供抽象类方法print()，用来输出宠物信息。

定义狗类Dog，继承Pet类，实现Eatable、FlyDiscCatchable接口，并重写或实现各个方法。

定义企鹅类Penguin和继承Pet，实现Eatable和Swimmable接口，并重写或实现各个方法。

编写测试类，实现狗吃饭，企鹅游泳和狗玩接飞盘游戏的功能，并输出企鹅信息。

public interface Eatable {
    /**
     * 吃饭功能
     */
    void eat();
}

public interface FiyingDiscCatchable {
    /**
     * 接飞盘
     */
    void catchingFiyDisc();

}

public interface Swimmable {
    /**
     * 游泳方法
     */
    void swim();

}

public abstract class Pet {
    protected String name;
    protected int health;
    protected int love;
    
    
    public Pet(String name, int health, int love) {
        super();
        this.name = name;
        this.health = health;
        this.love = love;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getHealth() {
        return health;
    }
    public void setHealth(int health) {
        this.health = health;
    }
    public int getLove() {
        return love;
    }
    public void setLove(int love) {
        this.love = love;
    }
    public abstract void print();

}

public class Dog extends Pet implements Eatable, FiyingDiscCatchable {
    
    

    public Dog(String name, int health, int love) {
        super(name, health, love);
    }

    @Override
    public void catchingFiyDisc() {
        System.out.println("我在接飞盘...");

    }

    @Override
    public void eat() {
        System.out.println("我在吃饭饭...");

    }

    @Override
    public void print() {
        System.out.println("宠物的自白：");
        System.out.print("我的名字叫"+super.getName()+"，健康值为"+super.getHealth()
                +"，和主人的亲密度是"+super.getLove());
        
    }

}

public class Penguin extends Pet implements Eatable,Swimmable{

    public Penguin(String name, int health, int love) {
        super(name, health, love);
    }

    @Override
    public void swim() {
        System.out.println("我在游泳...");
        
    }

    @Override
    public void eat() {
        System.out.println("我在吃饭饭...");
        
    }

    @Override
    public void print() {
        System.out.println("宠物的自白：");
        System.out.print("我的名字叫"+super.getName()+"，健康值为"+super.getHealth()
                +"，和主人的亲密度是"+super.getLove());
        
    }

}

public class Test {

    public static void main(String[] args) {
        Dog d=new Dog("多多",60,3);
        d.eat();
        d.catchingFiyDisc();
        Penguin p = new Penguin("落落",60,5);
        p.swim();
        p.print();

    }

}