JAVA迅猛式语法总结（十三）

9.接口

接口是只有一堆方法的定义，没有具体的方法，这是为了实现约束和实现分离。就犹如在自定义游戏角色时，你可以选择任何职业，但是选完之后你必须得选择它的性别、肤色等等，这些必选项就想一个契约一样，是整个程序必须执行的一步。

package com.cabin.test03;

public interface Character {
    void sex(String sex);
}



package com.cabin.test03;

public interface Weapon {
    void chooseWeapon(String weapon);
}




package com.cabin.test03;

public class Arrow implements Character,Weapon{

    @Override
    public void sex(String sex) {
        System.out.println("you selected "+sex);
    }

    @Override
    public void chooseWeapon(String weapon) {
        System.out.println("you selected a "+ weapon);
    }
}



package com.cabin.test03;

public class App {
    public static void main(String[] args) {
        Arrow arrow = new Arrow();
        arrow.sex("woman");
        arrow.chooseWeapon("sword");
    }
}

关键字是interface和implement，可以在声明类时以逗号隔开进行方法多继承，也可以交java的伪多继承。

接口的意义就是在与不同的对象可以重写同一个约束，实现不同的功能，其中要注意以下几个地方：

1. 接口中的方法默认隐藏了关键字 public abstract，而常量默认隐藏了public static final关键字。
2. 接口内的方法必须在被继承后重写才能正常调用。
3. 接口不能实例化，没有构造方法。

10. 内部类

内部类主要有四种：

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类

首先是成员内部类：

public class Outer {

    public void out(){
        System.out.println("out");
    }

    public class Inner{
        public void in(){
            System.out.println("in");
        }
    }
}

既在类的里面再定义一个类，与方法同级，注意一点时内部class前面的修饰词作用也和方法的相同，什么都不写时默认是public。

还有一种情况是在外部类的大括号外面写新的类，这是注意一点，这个类不能加public修饰：

public class A{
    
}
class B{
    //主要用作测试类
}

成员内部类的调用：

public class App {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.in();
    }
}

即是实例化外部内来调用内部类。

还有一点就是内部类的方法可以调用外部类的私有属性。

然后是静态内部类：

public static class Inner{
        public void in(){
            System.out.println("in");

        }
        public void get(){
            System.out.println(age);
        }
    }

静态内部类就是由static修饰的内部类，注意一点是，静态的不能访问非静态的，这和之前static详解时是统一的。

然后是局部内部类：

本质上就是在方法里面定义类

public class Corner {
    public void method(){
        
        class In{
            public void in(){
                
            }
        }
    }
}

局部类和局部变量类似，只能在方法类起作用。

最后是匿名内部类：

public class None {
    public static void main(String[] args) {
        new Apple().eat();
		
        @Override
        new Mellon(){
            public void a(){
            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("a");
    }
}
interface Mellon{
    void a();
}

一种是在new一个类的时候可以不把他加入变量，而是直接调用方法，这在只使用某些类成员方法时比较实用。

其次时对于接口来说，直接new接口（之前说不能实例化接口）的本质不是实例化，而是重写接口里面的方法，注意一点是new完接口后大括号后面是需要添加分号的，这更加说明，这个语句是一个重写的过程。