欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页  >  IT编程

10 接口

程序员文章站 2022-08-10 07:57:51
1.2 接口 1.2.1 接口的概念 接口是一种数据类型，引用数据类型。interface定义接口。 1.1.1 接口的特性 [1] 接口中所有变量都是static final 类型，且都是默认都是public访问权限。 [2] 接口没有构造方法 => 接口不能实例化。 [3] 接口中所有的方法都是 ......

 

1.2 接口

1.2.1 接口的概念

接口是一种数据类型，引用数据类型。interface定义接口。

public interface 接口名{

}

 

1.1.1 接口的特性

[1] 接口中所有变量都是static final 类型，且都是默认都是public访问权限。

public interface myinterface {
    int count = 10;
    public static final int count2 = 2;
}

 

[2] 接口没有构造方法 => 接口不能实例化。

[3] 接口中所有的方法都是抽象方法(public abstract)。

public interface ainterface {
    
     // void showinfo();
     // public abstract void showinfo();
     
    // 推荐写法
     // public void showinfo();
}

[4] a接口中定义的抽象方法可以被一个b类实现。

类b称为a接口的实现类(implement class)

ð 实现类必须实现接口中的抽象方法

public class implclass implements ainterface {

    @override
    public void showainfo() {
        
    }
}

 

一个实现类可以实现多个接口。

public class implclass implements ainterface,binterface{

    @override
    public void showainfo() {
        system.out.println("实现a接口的方法");
    }

    @override
    public void showbinfo() {
        system.out.println("实现b接口的方法");
    }
}

 

一个类可以继承一个类，实现多个接口。继承在前，实现在后。

public class implclass extends abstractclass implements ainterface,binterface{

    @override
    public void showainfo() {
        system.out.println("实现a接口的方法");
    }

    @override
    public void showbinfo() {
        system.out.println("实现b接口的方法");
    }

    @override
    public void test() {
        // todo auto-generated method stub
        
    }
}

如果抽象父类定义的方法和接口定义的方法同名时，优先实现父类的同名抽象方法。实际开发规则此现象发生。

 

[5] 接口可以实现多继承，实现类如果实现了多继承的接口，需要把其他接口中的方法都实现。

public interface cinterface extends ainterface,binterface{
    public void test();
}
public class implclass implements cinterface{

    @override
    public void showainfo() {
        // todo auto-generated method stub
        
    }

    @override
    public void showbinfo() {
        // todo auto-generated method stub
        
    }

    @override
    public void test() {
        // todo auto-generated method stub
        
    }

}

 

总结:

接口定义了一些抽象方法。

ð 实现类实现接口中所有的抽象方法

ð 实现类具有了接口中定义的行为 => 实现类 has a 接口中定义的能力。

ð 接口拓展了实现类的能力

 

1.1 接口的应用

[1]接口可以实现多态

public class test01 {
    public static void main(string[] args) {
        
        driveinterface driveinterface = null;
        
        // 接口new实现类 
        driveinterface = new student("二狗");
        driveinterface.drive();
        
        driveinterface = new teacher("kallen");
        driveinterface.drive();
        
    }
}

 

[2] 接口描述的是一种能力，提现在接口的方法上。

接口中定义的能力都是抽象方法。本身不提供任何实现。

ð 接口本身不关心方法如何实现，完全取决于实现类。

public class facedoor extends door implements lockinterface{

    @override
    public void open() {
        system.out.println("自动开门...");
    }

    @override
    public void close() {
        system.out.println("自动关门");
    }
    
    @override
    public void lock() {
        system.out.println("刷脸上锁!");
    }

    @override
    public void unlock() {
        system.out.println("刷脸开锁!");
    }

}

思考:接口描述一种能力，有何用？

 1.1 面向接口编程(a)

public class test01 {
    public static void main(string[] args) {
        
        inkboxinterface inkboxinterface = null;
        inkboxinterface = new colorfulinkbox();
        
        paperinterface paperinterface = null;
        paperinterface = new a4paper();
        
        paperinterface = new b3paper();
        
        writer writer = new writer(paperinterface,inkboxinterface);
        writer.print();
    }
}

 

 

接口也表示一种约定(规范)，约定实现类应该具备什么能力。

接口更关心实现类具备什么能力，而不关心实现类如何实现。

面向接口编程

当完成一个系统性的工程时，需要多个模块之间进行配合实现。如果一个模块a需要模块b、c… 组合实现a模块的功能时，a模块需要预留出接口，约定支持模块应该具备的能力。

当b、c等模块不在满足系统需要时，在更换模块时，新模块只需要实现a模块预留的接口即可

 

10 接口

 

 

 

抽象类和接口的比较

  • 抽象类和接口都是引用数据类型，他们都不能创建对象。
  • 他们都可以定义抽象方法，都可以实现多态。但是抽象可以定义非抽象方法，而接口中定义的都是抽象方法。
  • 抽象类和接口都具有传递性。抽象类是单根性（单继承），而接口是多继承。
  • 在概念上，都可以重写抽象方法。子类重写抽象类，实现类实现接口
  • 抽象类和子类解决的是模块内的问题（代码重用,重写,多态）而接口解决的是模块间的问题 => 高内聚，低耦合。

1.1 object

object类是java的所有类的根类。

一个类如果没有继承任何类，默认继承object

 

1.1.1 tostring

返回对象的字符串表示形式。

public class test01 {
    public static void main(string[] args) {
        student student = new student("二狗", 20);
        // 当直接输出对象时，默认调用tostring方法
        system.out.println(student);
        system.out.println(student.tostring());
    }
}

如果要自定义对象的输出信息时，可以重写tostring()方法。通过代码生成即可。

 

1.1.1 equals

一般用于比较两个对象是否内容相等。object默认提供的是比较内存地址是否相等。如果要比较内容是否相等，一定要重写equals()方法。

两个对象的内容相等的标准:属性值都相等。

 

@override
    public boolean equals(object obj) {
        if (this == obj)
            return true;

        if (obj == null)
            return false;

        if (getclass() != obj.getclass())
            return false;

        student other = (student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;

        if (no == null) {
            if (other.no != null)
                return false;
        } else if (!no.equals(other.no))
            return false;

        return true;
    }

 

1.1 内部类

类组织关系

[1] 平行关系。可以在一个文件中定义两个类。如果是一个文件定义两个类，一定有一个是主类(public 修饰)。主类一定和文件名保持一致。

public class student {
    
}

class teacher{
    
}

 

10 接口

 

[2] 包含关系。可以在一个类中定义另外一个类。

public class outer {

    class inner{
        
    }
}

10 接口

 

1.1.1 成员内部类

inner类可以作为outer类的成员而存在。inner是outer类的成员内部类，可以根据业务需要加访问修饰符。

 

public class outer {
    
    class inner{
        
        public void showinfo() {
            system.out.println("我是inner:showinfo");
        }
    }
}

 

[1] 创建成员内部类对象

package cn.sxt12.inner;

import cn.sxt12.inner.outer.inner;

public class test01 {
    public static void main(string[] args) {
        
        // 【1】创建外部类对象
        outer outer = new outer();
        
        // 【2】创建内部类对象
        inner inner = outer.new inner();
        inner.showinfo();
    }
}

 

[2] 成员内部类可以直接访问外部类的私有属性(a)。

public class outer {
    
    private string name = "outer";
    
    class inner{
        
        public void showinfo() {
            system.out.println("我是inner:showinfo");
            
            system.out.println(name);
        }
    }
}

 

[3]如果内部类定义了和外部类同名的私有属性时(c)。

public class outer {
    
    private string name = "outer";
    
    class inner{
        
        private string name = "inner";
        
        public void showinfo() {
            system.out.println("我是inner:showinfo");
            
            system.out.println(name);
            system.out.println(this.name);
            
            // 访问外部类的私有属性
            system.out.println(outer.this.name);
        }
    }
}

 

1.1.1 静态内部类

如果一个内部类被static修饰，就变成了静态内部类。

public class outer {
    
    static class inner{
        public void showinfo() {
            system.out.println("我是inner:static showinfo");
        }
    }
}

 

[1] 创建静态内部类对象

package cn.sxt12.staticinner;

import cn.sxt12.staticinner.outer.inner;

public class test01 {
    public static void main(string[] args) {
        
        inner inner = new outer.inner();
        inner.showinfo();
    }
}

 

[2] 静态内部类中可以直接访问外部类的(私有)静态成员。(a)

 

public class outer {
    
    static string name  = "outer";

    static class inner{
        public void showinfo() {
            system.out.println("我是inner:static showinfo");
            system.out.println(name);
        }
    }
}

 

[3] 静态内部类定义了和外部类同名的静态属性时(c)

 

public class outer {
    
    static string name  = "outer";

    static class inner{
        
        static string name  = "inner";
        
        public void showinfo() {
            system.out.println("我是inner:static showinfo");
            
            // 默认访问内部类
            system.out.println(name);
            system.out.println(inner.name);
            
            system.out.println(outer.name);
        }
    }
}

 

1.1.1 方法内部类

如果一个类定义方法中，这个类称为方法内部类。

 

public class outer {
    
    public void test() {
        
        class inner{
            
            public void showinfo() {
                system.out.println("method:inner class");
            }
            
        }
        
    }
    
}

 

[1] 创建方法内部类对象

public class outer {
    
    public void test() {
        
        class inner{
            
            public void showinfo() {
                system.out.println("method:inner class");
            }
        }
        
//        inner inner = new inner();
//        inner.showinfo();
        
        // 匿名对象（只使用一次的对象）
        new inner().showinfo();
    }    
}

 

[2]方法内部类中的方法可以直接访问方法的局部变量。

public class outer {
    
    public void test() {
        // 方法的局部变量
        int a = 10;
        
        class inner{
            
            public void showinfo() {
                system.out.println("method:inner class");
                
                system.out.println("a="+a);
                
                // a = 100;(error)
            }
        }

        new inner().showinfo();
    }
    
}

 

 

总结：

在方法中的局部变量进入方法内部类时被加了final修饰。在方法内部类中只能读取方法的局部变量，不能修改。

思考:在方法内部类中定义同名的局部变量时，该如何访问？(c)

 

1.1.1 匿名内部类(a)

当一个类只使用一次时，可以把这个类声明为匿名类。

匿名类一般在方法中使用，形成方法匿名内部类，简称匿名内部类。

匿名内部类一般只使用一次。

匿名内部类在形式上一定会出现:实现接口（implement）

 

public class outer {
    
    
    public void test() {
        
        /*
        class inner implements myinterface{

            @override
            public void showinfo() {
                system.out.println("showinfo");
            }
            
        }
        
        new inner().showinfo();
        */
        
        // 匿名内部类
        new myinterface(){

            @override
            public void showinfo() {
                system.out.println("showinfo");
            }
            
        }.showinfo();

    }
}

 

上一篇： cropper js基于vue的图片裁剪上传功能的实现代码

下一篇： Python 使用with上下文实现计时功能

推荐阅读