Java 面向对象之抽象

抽象

1、什么是抽象？抽取相同的、相似的东西出来

2、抽象方法：只有方法声明，而没有方法实现的方法，就是抽象方法

  　　在各个子类中，对于某个方法都有自己不同的实现，所以实现各不相同，无法抽取，只能抽取方法的声明上来，

　在父类中，方法就只有方法声明没有方法体。就是抽象方法。

　　定义格式：

  　　1、没有方法实现，连大括号都没有，直接在方法声明后面加上一个分号，表示方法定义结束

  　　2、为了将方法标记为抽象方法，需要在方法前面加上一个abstract关键字

 

3、抽象类：可以定义抽象方法的类

　　定义格式：　 abstract 类名{ }

4、抽象类的特点　

　　1、抽象类和抽象方法都需要使用abstract关键字修饰

  　　　　抽象类：abstract class {}

  　　　　抽象方法：public abstract void test();

　　2、抽象类和抽象方法的关系：

  　　　　抽象方法所在的类必须是抽象类

 　　　　 抽象类中未必一定都定义抽象方法，抽象类中未必存在抽象方法

　　3、抽象类的实例化（抽象类如何创建对象）

 　　　　 抽象类不能直接实例化

  　　　　定义抽象类的子类，由子类创建对象，调用方法

　　4、抽象类子类的前途

 　　　　 在子类中，将父类所有的抽象方法全部重写（实现），子类就成了一个普通类，就可以创建对象

 　　　　 在子类中，没有将父类中所有的抽象方法全部实现，子类就还是一个抽象类，还需要使用

　　　　abstract关键字修饰子类。

5、抽象类成员的特点

　　1、成员变量：可以定义变量、也可以定义常量，但不能被抽象

　　2、构造方法：虽然本类无法创建对象，但是抽象类一定有子类，子类会访问父类的抽象方法。

  　　　　　　　　是否有构造方法，不取决于是否可以创建对象，而是取决于是否可以定义成员变量。

　　　　　　　　 如果可以定义成员变量，那么就需要初始化成员变量，就是构造方法来完成的。

　　3、成员方法：既可以有抽象方法，也可以存在具体方法。

　　　　　　　　既然是抽象方法，必须让子类强制重写，如果子类没有重写，子类还是抽象类

 

/*
 * 模板方法模式：定义一个操作中的算法的骨架，将一些可变部分的实现延迟到子类中。
 * 模板算法模式使子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。
 */
public class Demo02 {

    public static void main(String[] args) {
        UserManager um = new UserManager();
        um.action("admin", "add");
    }

}

abstract class BaseManager{
    
    public void action(String name,String method) {
        if("admin".equals(name)) {
            test(method);
        }else {
            System.out.println("你没有操作权限，请联系管理");
        }
    }
    
    public abstract void test(String method);
}

class UserManager extends BaseManager{
    
    public void test(String method) {
        if("add".equals(method)) {
            System.out.println("执行了添加操作");
        }else if("del".equals(method)) {
            System.out.println("执行了删除操作");
        }
    }
    
}

 

接口

1、接口的定义 interface

　　格式 interface 接口名{ }

2、接口中只可以声明抽象方法

3、类可以去实现接口：implements

　　实现：接口中只定义方法名称，在类中真正实现

4、接口的实例化：不能直接实例化

　　定义类，实现接口，创建子类对象，调用方法

5、接口中成员的特点

　　1、成员变量：只能是常量 默认public static final

　　2、构造方法　　接口没有构造方法

　　3、成员方法　　只能是抽象方法，默认public abstract

6、类与类、类与接口、接口与接口的关系

　　类与类：单继承  多层继承

　　类与接口：类可以实现多个接口，如果没有实现，则是一个抽象类，它的子类必须实现，否则还是抽象类

　　接口与接口：可以单继承、也可以多继承、也可以多层继承　　

　　类和接口的区别：

　　　　抽象类：定义物体具有的固定属性和行为

　　　　接口：定义物体通过学习，扩展出来的行为

 

/*
 * 策略模式：定义一系列算法，将算法封装起来（隐藏在接口之后），并可以相互替换使用
 * 策略模式让算法独立于使用它的客户应用而独立变化
 * */
public class Demo01 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BaseService us = new UserSave();
        us.setIsave(new NetSave());
        us.add("user>>>");
    }

}
interface Isave{
    public abstract void save(String data);
}
class FileSave implements Isave{
    @Override
    public void save(String data) {
        System.out.println("存到文件中"+data);
    }
}
class NetSave implements Isave{
    @Override
    public void save(String data) {
        System.out.println("存到网络中"+data);
    }
}

abstract class BaseService{
    private Isave isave;
    public void setIsave(Isave isave) {
        this.isave = isave;
    }
    public void add(String data) {
        System.out.println("检查数据合法性");
        isave.save(data);
        System.out.println("数据保存完毕");
    }
}

class UserSave extends BaseService{
    
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

---恢复内容结束---