2019-03-12多态、抽象、接口

多态

• 多态（一种事物不同形态，对同一消息不同响应）：是一种编程的策略

1.要有泛化（继承，实现）关系
2.要有上溯造型，父类引用指向子类对象
3.要方法的重写
优点：解耦合（拓展性强，易维护）

    int id;
    String name;
    public void buy(TrainStation ts) {}
}

public class Student  extends Customer{
    public Student() {}
    public Student(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    @Override
    public void buy(TrainStation ts) {
        System.out.println(name+"是一个学员，打五折，收费"+ts.price*0.5);
    }
}

public class Criminal extends Customer{
    public Criminal() {}
    public Criminal(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    @Override
    public void buy(TrainStation ts) {
        System.out.println(name+"是一个罪犯，打骨折");
    }
}

public class Teacher extends Customer{
    public Teacher() {}
    public Teacher(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    @Override
    public void buy(TrainStation ts) {
        System.out.println(name+"是一个讲师，打八折，收费"+ts.price*0.8);
    }
}

public class TrainStation {
    int price = 100;
    public void saleTicket(Customer c) {
        TrainStation ts1 = this;
        c.buy(ts1);
    }
}

public class Test {
    public static void main(String[] args) {
        Customer s = new Student(1001, "小翟");
        Customer t = new Teacher(9527, "大翟");
        Customer c = new Criminal(1011011, "老翟");
        Customer e = new Employee(1, "老翟1111");
        
        TrainStation ts = new TrainStation();
        ts.saleTicket(s);
        ts.saleTicket(t);
        ts.saleTicket(c);
        ts.saleTicket(e);
    }
}

• 在Java中的体现：

重载------编译时多态
重写------运行时多态

接口

接口（interface）：弥补单继承的
接口中只能定义
1.常量 存在默认public static final
2.抽象方法 public abstract
3.意义提供方法

public interface News {
    // 发布新闻
    void releaseNews();
}

/**
 * 体育板块
 * @author Administrator
 */
public class Sports implements News{
    @Override
    public void releaseNews() {
        System.out.println("发布了一条体育新闻");
    }
}

/**
 * 娱乐板块
 * @author Administrator
 */
public class Entertainment  implements News{
    public void releaseNews() {
        System.out.println("发布了一条娱乐新闻");
    }
}

/**
 * 政治板块
 * @author Administrator
 */
public class Polity implements News{
    @Override
    public void releaseNews() {
        System.out.println("发布了一条政治新闻");
    }
}

public class TestDemo1 {
    public static void main(String[] args) {
        while(true) {
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入要发布的新闻类型");
            System.out.println("1--------体育新闻");
            System.out.println("2--------政治新闻");
            System.out.println("3--------娱乐新闻");
            System.out.println("4----------退出");
            int num = scan.nextInt();
            // 上溯
            News n = null;
            if(num < 1 || num > 4) {
                System.out.println("无此选项");
            }else {
                switch(num) {
                    case 1:
                        n = new Sports();
                        break;
                    case 2:
                        n = new Polity();
                        break;
                    case 3:
                        n = new Entertainment();
                        break;
                    case 4:
                        System.out.println("再见");
                        return;
                }
                n.releaseNews();
            }
        }
    }
}

接口与抽象类

接口：不能实例化，也没有构造器,只能有常量和抽象方法 ，多实现
抽象类：不能实例化，有构造器，可以有非抽象方法，变量
类与类单继承
类与接口是多实现
接口与接口多继承（接口不能实现任何）

接口使用问题;

1.如果一个类使用一个以上的接口，接口不能同名同参

总结：

多态：解耦（拓展性强，意维护 ）

1.要有泛化关系（继承，实现）
2.上溯造型
3.方法重写

final：可以修饰类（不能被继承）方法（不能被重写）属性（运行不能被改变）
abstract：抽象方法没有方法体，一个类中有抽象方法，这个类是抽象类
一个类继承抽象类，必须实现父类的所有抽象方法
2. 抽象类：不能实例化（不能创建对象）
3. 接口： 不能实例化（不能创建对象）

final

能修饰，方法，属性（常量）
final类不能被继承
final方法不可以被重写
final 属性常量不可以改变

abstract 抽象

可以修饰的类和方法
抽象类不能实例化（不成创建对象，但是有构造器），可以作为父类出现
抽象方法，没有方法体（{}），如果一个类中有抽象方法，这个类必须是抽象类
抽象类可以写非抽象方法
如果一个类继承了一个抽象类，就必须实现父类所有抽象方法，除非这个子类也是抽象类
*/
String str
str.equals 在if中相当于 ==