面向对象——抽象类和接口（笔记）

抽象类

抽象类快速入门

抽象类的介绍

抽象类使用的注意事项和细节讨论

public class test {
    public static void main(String[] args) {
        //抽象类，不能被实例化
//            new A();//报错
    }
}
//抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法
//，还可以有实现的方法。
abstract class A {
    public void hi() {
        System.out.println("hi");
    }
}
//一旦类包含了abstract方法,则这个类必须声明为abstract
abstract class B {
    public abstract void hi();
}
//abstract 只能修饰类和方法，不能修饰属性和其它的
class C {
//     public abstract int n1 = 1;//报错
}

public class test {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}
//抽象方法不能使用private、final 和 static来修饰，因为这些关键字都是和重写相违背的
abstract class H {
    public abstract void hi();//抽象方法
}
//如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
abstract class E {
    public abstract void hi();
}
abstract class F extends E {
}
class G extends E {
    @Override
    public void hi() { //这里相等于G子类实现了父类E的抽象方法，所谓实现方法，就是有方法体
    }
}
//抽象类的本质还是类，所以可以有类的各种成员
abstract class D {
    public int n1 = 10;
    public static String name = "java学习";
    public void hi() {
        System.out.println("hi");
    }
    public abstract void hello();
}

抽象类最佳实践-模板设计模式

基本介绍

模板设计模式能解决的问题

最佳实践

public class test {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.calculateTime(); //这里还是需要有良好的OOP基础，对多态
        BB bb = new BB();
        bb.calculateTime();
    }
}
abstract class Template { //抽象类-模板设计模式
    public abstract void job();//抽象方法
    public void calculateTime() {//实现方法，调用job方法
        //得到开始的时间
        long start = System.currentTimeMillis();
        job(); //动态绑定机制
        //得的结束的时间
        long end = System.currentTimeMillis();
        System.out.println("任务执行时间 " + (end - start));
    }
}
class AA extends Template {
    //计算任务   1+....+ 800000
    @Override
    public void job() { //实现Template的抽象方法job
        long num = 0;
        for (long i = 1; i <= 800000; i++) {
            num += i;
        }
    }
}
class BB extends Template {
    public void job() {//这里也去，重写了Template的job方法
        long num = 0;
        for (long i = 1; i <= 800000; i++) {
            num *= i;
        }
    }
}

接口

基本介绍

深入讨论

public class test {
    public static void main(String[] args) {
        MysqlDB mysqlDB = new MysqlDB();
        t(mysqlDB);
        OracleDB oracleDB = new OracleDB();
        t(oracleDB);
    }
    public static void t(DBInterface db) {
        db.connect();
        db.close();
    }
}
interface DBInterface { //项目经理
    public void connect();//连接方法
    public void close();//关闭连接
}
//A程序
class MysqlDB implements DBInterface {
    @Override
    public void connect() {
        System.out.println("连接mysql");
    }
    @Override
    public void close() {
        System.out.println("关闭mysql");
    }
}
//B程序员连接Oracle
class OracleDB implements DBInterface {
    @Override
    public void connect() {
        System.out.println("连接oracle");
    }
    @Override
    public void close() {
        System.out.println("关闭oracle");
    }
}

注意事项和细节

public class test {
    public static void main(String[] args) {
//        new IA();//1.接口不能被实例化
    }
}
//2.接口中所有的方法是 public方法,  接口中抽象方法，可以不用abstract 修饰
//3.一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用alt+enter来解决
//4.抽象类去实现接口时，可以不实现接口的抽象方法
interface IA {
    void say();//修饰符 public protected 默认 private
    void hi();
}
class Cat implements IA {
    @Override
    public void say() { }
    @Override
    public void hi() { }
}
abstract class Tiger implements IA {
}

public class test {
    public static void main(String[] args) {
        // 接口中的属性,是 public static final
        System.out.println(IB.n1);//说明n1 就是static
//        IB.n1 = 30; //说明n1 是 final ,不能再赋值
    }
}
interface IB {
    //接口中的属性,只能是final的，而且是 public static final 修饰符
    int n1 = 10; //等价 public static final int n1 = 10;
    void hi();
}
interface IC {
    void say();
}
//接口不能继承其它的类,但是可以继承多个别的接口
interface ID extends IB, IC { }
//接口的修饰符 只能是 public 和默认，这点和类的修饰符是一样的
interface IE { }
//一个类同时可以实现多个接口
class Pig implements IB, IC {
    @Override
    public void hi() {
    }
    @Override
    public void say() {
    }
}

实现接口 vs 继承类

public class test {
    public static void main(String[] args) {
        LittleMonkey wuKong = new LittleMonkey("悟空");
        wuKong.climbing();//悟空 会爬树...
        wuKong.swimming();//悟空 通过学习，可以像鱼儿一样游泳...
        wuKong.flying();//悟空 通过学习，可以像鸟儿一样飞翔...
    }
}
//猴子
class Monkey {
    private String name;
    public Monkey(String name) {
        this.name = name;
    }
    public void climbing() {
        System.out.println(name + " 会爬树...");
    }
    public String getName() {
        return name;
    }
}
//接口
interface Fishable {
    void swimming();
}
interface Birdable {
    void flying();
}
//继承
//小结:  当子类继承了父类，就自动的拥有父类的功能
//      如果子类需要扩展功能，可以通过实现接口的方式扩展.
//      可以理解 实现接口 是 对java 单继承机制的一种补充.
class LittleMonkey extends Monkey implements Fishable, Birdable {
    public LittleMonkey(String name) {
        super(name);
    }
    @Override
    public void swimming() {
        System.out.println(getName() + " 通过学习，可以像鱼儿一样游泳...");
    }
    @Override
    public void flying() {
        System.out.println(getName() + " 通过学习，可以像鸟儿一样飞翔...");
    }
}

接口的多态特性

public class test {
    public static void main(String[] args) {
        //接口的多态体现
        //接口类型的变量 if01 可以指向 实现了IF接口类的对象实例
        IF if01 = new Monster();
        if01 = new Car();
        //继承体现的多态
        //父类类型的变量 a 可以指向 继承AAA的子类的对象实例
        AAA a = new BBB();
        a = new CCC();
    }
}
interface IF {}
class Monster implements IF{}
class Car implements  IF{}
class AAA { }
class BBB extends AAA {}
class CCC extends AAA {}

public class test {
    public static void main(String[] args) {
        //多态数组 -> 接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();
        /*
        给Usb数组中，存放 Phone  和  相机对象，Phone类还有一个特有的方法call（），
        请遍历Usb数组，如果是Phone对象，除了调用Usb 接口定义的方法外，
        还需要调用Phone 特有方法 call
         */
        for (int i = 0; i < usbs.length; i++) {
            usbs[i].work();//动态绑定..
            //和前面一样，我们仍然需要进行类型的向下转型
            if (usbs[i] instanceof Phone_) {//判断他的运行类型是 Phone_
                ((Phone_) usbs[i]).call();
            }
        }
    }
}
interface Usb {
    void work();
}
class Phone_ implements Usb {
    public void call() {
        System.out.println("手机可以打电话...");
    }
    @Override
    public void work() {
        System.out.println("手机工作中...");
    }
}
class Camera_ implements Usb {
    @Override
    public void work() {
        System.out.println("相机工作中...");
    }
}

public class test {
    //演示多态传递现象
    public static void main(String[] args) {
        //接口类型的变量可以指向，实现了该接口的类的对象实例
        IG ig = new Teacher();
        //如果IG 继承了 IH 接口，而Teacher 类实现了 IG接口
        //那么，实际上就相当于 Teacher 类也实现了 IH接口.
        //这就是所谓的 接口多态传递现象.
        IH ih = new Teacher();
    }
}
interface IH {
    void hi();
}
interface IG extends IH { }
class Teacher implements IG {
    @Override
    public void hi() {
    }
}