当前位置： 移动技术网 > IT编程>开发语言>Java > 10 接口

10 接口

2019年05月08日  | 移动技术网IT编程  | 我要评论

 

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模块预留的接口即可

 

 

 

 

抽象类和接口的比较

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

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{
    
}

 

 

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

public class outer {

    class inner{
        
    }
}

 

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();

    }
}

 

您可能感兴趣的文章:

如对本文有疑问， 点击进行留言回复！！

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网