JAVA接口

最新推荐文章于 2024-04-18 14:35:37 发布

Namtheun

最新推荐文章于 2024-04-18 14:35:37 发布

阅读量80

点赞数

分类专栏： java 文章标签：抽象类 java 接口

本文链接：https://blog.csdn.net/Numtheun/article/details/117714902

版权

java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

JAVA接口

一，接口

1.1 什么是接口？

接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。

接口需要实现 : 实现类一旦实现一个接口,需要对接口中的抽象功能进行实现即对里面的抽象方法进行重写,然后才能使用

1.2 如何定义接口

[权限修饰符] interface 接口名 [extends 父接口1，父接口2…] {
    常量定义；
    抽象方法定义；//抽象方法不能有方法体
}

访问修饰符：只能是public或默认。
接口名：和类名采用相同的命名机制
extends：接口可以多继承
常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。
方法：接口中的方法只能是：public abstract。省略的话，也是public abstract.

1.3 使用接口的意义

类只能单继承,接口可以多实现
接口便于后期维护,更加灵活
接口实现解耦(高内聚低耦合)
定义开发规范

1.4 接口的使用

接口的使用：

1.不能实例化
2.接口需要被实现通过implements关键字进行实现
3.根据实现类对象使用
具体实现类 : 重写所有的抽象方法 + 按需新增
抽象实现类 : 按需重写抽象方法 + 按需新增
4.类只能单继承类,类可以多实现接口,需要重写多个抽象方法
5.类与接口之间只能是类实现接口,可以多实现
6.接口与接口之间,可以多继承
7.一个类需要先继承后实现

public class Class001_Interface {
    public static void main(String[] args) {
        //测试使用接口中的常量
        System.out.println(Interface1.PI);
        //Interface1.PI = 1.1;

        //通过实现类对象使用接口
        Impl i = new Impl();
        System.out.println(i.PI);
        i.test1();
        i.test2();
        i.haha();

    }
}
//具体实现类Impl
class Impl extends Object implements Interface1,ABC{
    @Override
    public void test1() {
        System.out.println("具体实现类test1");
    }

    @Override
    public void test2() {
        System.out.println("具体实现类test2");
    }

    void haha(){
        System.out.println("新增haha方法");
    }
	//ABC抽象方法的重写
    @Override
    public void a() {}
    @Override
    public void b() {}
    @Override
    public void c() {}
}

//抽象的实现类
abstract class Impl2 implements Interface1{

    @Override
    public void test1() {}
}

interface Interface1{
    //公共的静态的常量  public static final
     double PI= 3.14;

     void test1();
     void test2();
}
//A,B,C三个不同的接口
interface A{
    void a();
}
interface B{
    void b();
}

interface C{
    void c();
}
//相当于继承的多个接口中的功能的整合
interface ABC extends A,B,C{}

1.5 java 8 中对接口新增的内容

java 8对接口新增了方法

静态方法

public interface StaticMethod {
    //静态方法
    public static void testStatic(){
        System.out.println("静态的方法");
    }
}

静态方法只能通过类名.方法名调用

class Test{
    public static void main(String[] args) {
        //通过类名调用静态方法
        StaticMethod.testStatic();
    }
}

默认方法

public interface DefaultMethod {
    //默认方法
    public default void testDefault(){
        System.out.println("默认方法");
    }
}

接口方法中的default不是权限修饰符，能够被权限修饰符修饰

//定义具体子类实现接口
class ImplDemo implements DefaultMethod{
    //默认方法能被继承，也能被重写，但重写时default会重新转为权限修饰符
    @Override
    public void testDefault(){
        System.out.println("重写接口中的默认方法");
    }
}

class Test{
    public static void main(String[] args) {
        //实现类对象
        ImplDemo im = new ImplDemo();
        im.testDefault();
    }
}

二，类的设计原则

单一职责原则
里氏代换原则
依赖倒置原则
接口隔离原则
接口隔离原则
开闭原则

三，类与类之间的关系

继承关系
实现关系
依赖关系
关联关系
聚合关系
组合关系

四，设计原则

4.1 单例模式

某个类型只能拥有单个实例->单例模式

实现方式:

饿汉式 : 在类第一次加载完成之后,就创建实例,线程安全的,同步的,一般效率较低
懒汉式 : 在调用的时候, 创建实例 ,线程不安全的,不同步的,一般效率较高

步骤:

私有的构造器
私有的静态的该类的引用->(指向创建好的那个对象)
公共静态的访问方式->返回提供一个当前类型的实例

饿汉式

public class SingletonMode {
    public static void main(String[] args) {
        Hungry hun = Hungry.Fan();
        System.out.println(hun);
        System.out.println(Hungry.Fan());
    }
}

class Hungry{
    //私有的静态的引用
    private static Hungry hun = new Hungry();

    //私有的构造器
    private Hungry() {
        System.out.println("饿汉式");
    }

    //公共静态的访问方式
    public static Hungry Fan(){
        return hun;
    }
}

懒汉式

public class SingletonMode {
    public static void main(String[] args) {
        Lazy la = Lazy.Fan();
        System.out.println(la);
        System.out.println(Lazy.Fan());
    }
}

class Lazy{
    //私有的静态的引用
    private static Lazy la = null;

    //私有的构造器
    private Lazy() {
        System.out.println("懒汉式");
    }

    //公共的静态访问方式
    public static Lazy Fan(){
        if (la == null){
            la = new Lazy();
        }
        return la;
    }
}

4.2 代理模式

代理模式

静态代理 :
真实角色
代理角色
条件:
真实角色与代理角色要求实现相同的接口
代理角色需要持有真实角色的引用–>通过属性来维护
代理行为

减少与真实角色的沟通,让程序便于后期维护

public class StaticProxy {
    public static void main(String[] args) {
        //项目经理
        Manager manager  = new Manager();
        //Hr
        Hr hr = new Hr(manager);
        //开始招人
        hr.addUser();
    }
}

//招人
interface AddUser{
    void addUser();
}

//真实角色 项目经理
class Manager implements AddUser{

    @Override
    public void addUser() {
        System.out.println("录用了...");
    }
}


//代理角色
class Hr implements AddUser{
    //管理者
    Manager manager;

    public  Hr(Manager manager){
        this.manager = manager;
    }

    @Override
    public void addUser() {
        System.out.println("发布招聘信息...");
        System.out.println("预约面试");
        //项目经理面试
        manager.addUser();
        System.out.println("录用成功..谈薪资...");
    }
}

4.3 简单工厂模式

简单工厂模式
抽象产品角色 : 具体产品角色实现的接口|继承的父类
具体产品角色 : 抽象产品角色的实现类
工厂角色

public class Factory {
    public static void main(String[] args) {
        //接口多态
        Car car = factory("Benz");

        car.run();

    }

    //工厂角色
    public static Car factory(String type){
        if("Benz".equals(type)){
            return new Benz();
        }else if("BWM".equals(type)){
            return new BWM();
        }
        return null;
    }
}

//抽象产品角色
interface Car{
    void run();
}

//具体产品角色
class Benz implements Car{
    @Override
    public void run() {
        System.out.println("坐在副驾驶哭...");
    }
}

//具体产品角色
class BWM implements Car{
    @Override
    public void run() {
        System.out.println("趴在车底哭....");
    }
}