复习JavaSE 6.接口、lambda表达式与内部类

接口不是类 是对类的一组需求描述，为定义类的行为提供了灵活性
这些类要遵从接口描述的统一格式定义 任务由实现接口的类完成
接口不能包含实例域
可以在接口中提供方法，但是方法不能引用实例域

实现接口类 把方法声明为public
instanceof 可以检查一个对象是否实现一个接口
接口可以继承接口
类可以实现多接口 不可以实现多抽象类
实例 通过Arrays中的sort方法 按工资对员工进行排序
Arrays中的sort方法 默认方法会对对象进行比较排序 ·

if (a[i].compareTo(a[j]>0))
{
   //
}

所以需要在Employee方法中重写Comparable接口中compareTo方法 改变比较的方法

/**
 * @ClssName Employee
 * @Autor Yu
 * @Description TODO
 * @Date 2019/2/28 21:32
 * Version 1.0
 */
public class Employee implements Comparable<Employee> {
    private String name;
    private double salary;

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;

    }
    public String getName() {
        return name;
    }

    public double getSalary() {
        return salary;
    }

    public  void raiseSalary(double byPercent){
        double raise=salary*byPercent/100;
        salary+=raise;
    }

    @Override
    public int compareTo(Employee o) {
        return Double.compare(this.salary,o.salary);
    }
}

public class EmployeeSortTest {
    public static void main(String[] args) {
        Employee[] staff=new Employee[3];
        staff[0]=new Employee("Carl",75000);
        staff[1]=new Employee("Harry",50000);
        staff[2]=new Employee("tony",40000);
        Arrays.sort(staff);

        for (Employee e:staff)
            System.out.println("name="+e.getName()+",salary="+e.getSalary());

    }
}

不按照字典排序 按照自己的需求排序
利用Compa'rator接口

/**
 * @ClssName EmployeeTest1
 * @Autor Yu
 * @Description TODO
 * @Date 2019/2/28 22:17
 * Version 1.0
 */
public class EmployeeTest1 {
    public static void main(String[] args) {
        Employee[] staff=new Employee[3];
        staff[0]=new Employee("Yus",75000);
        staff[1]=new Employee("Harry",50000);
        staff[2]=new Employee("tony",40000);
        Arrays.sort(staff, new ComparatorByName());

        for (Employee e:staff)
            System.out.println("name="+e.getName()+",salary="+e.getSalary());

    }
}

/**
 * @ClssName ComparatorByName
 * @Autor Yu
 * @Description TODO
 * @Date 2019/2/28 22:27
 * Version 1.0
 */
public class ComparatorByName implements Comparator<Employee> {

        @Override
        public int compare(Employee o1, Employee o2) {
            return o2.getName().length()-o1.getName().length();
        }

}

默认方法 ：
可以为接口方法提供默认实现方法 用default修饰
伴随类往往实现了相应接口的部分方法
将方法实现默认方法 可以解决不必在新增方法后 实现类也需要实现该方法 也可以正常工作

超类优先： 如果超类中提供了具体方法 同名而且相同参数类型的默认方法会被忽略
接口冲突：如果一个超类提供了一个默认方法 另一个接口提供了一个同名而且参数类型相同的方法 必须覆盖这个方法解决
类优先：如果超类和接口中都有相同方法 接口方法会被忽略

设计模式 回调：
某个特定事件发生时应该采取的动作 类似于点击事件

内部类：
原因：
内部类可以访问类所在的作用域中的数据 包括私有数据
内部类可以对同一个包中的其他类隐藏起来
当想定义一个回调函数不想编写大量代码时，使用匿名内部类比较便捷

成员内部类
静态内部类 非静态内部类
外部域访问 Outer.this.age
内部域访问this.age

非静态：
内部类不可以使用静态方法 静态域和静态初始化块
非静态内部类先实例化外部再实例化内部
Outer.Inner inner=new Outer().new Inner();

public class OuterTest {
    public static void main(String[] args) {
        Outer.Inner inner=new Outer().new Inner();
        inner.Show();
    }
}
class Outer{
    private String name="于松江";
    class Inner{
        private String name="于大莎";
        public void Show(){
            System.out.println("HAHA  "+Outer.this.name);
        }
    }
}

静态类：
可以直接实例化内部类
Outer.Inner inner=new Outer.Inner();