Java学习_Day12

接口
含义：题前定义的一套规范
目的：解耦合
定义：
jdk 1.7以前：
语法：[修饰符] interface 接口名{
①接口中的属性默认为共有的静态常量 （public static final可以省略）
②接口中默认的方法是公有的抽象方法 （public abstract 可以省略，但是在实现类中public修饰符不能省略）
③接口中没有构造方法
④接口中不存在代码块
}
jdk 1.8新特性：
特点允许大括号的出现；
1.静态方法：
添加一个static修饰符，默认是public修饰的
只能通过接口名调用
2.默认方法（一般只有两个地方应用 一个是switch中，一个是接口中的默认方法）
添加一个default修饰符，默认为public修饰的
需要通过实现类的对象去调用，然后实现类还可以对默认方法的重写（重写默认方法时候，不需要添加default修饰符）
补充：接口可以继承接口
default在switch中主要的作用是用来检查默认情况或错误情况
在接口中的默认方法相当于普通类中的普通方法一样

				jdk1.9的接口中可以使用私有方法

public interface Person extends Fimally{}  //j接口可以继承接口

//接口中的默认方法
    public  default void start(){  //可以定义默认方法
        System.out.println("开始");
    }
//实现类中的重写
    @Override
    public void start() { //重写默认方法时候，不需要添加default修饰符
        System.out.println("这是对接口中default方法的重写");
    }

	接口的使用：
			作为父类（父接口）
			需要子级去实现接口内的方法
			语法：

public class 子级类名 implements 父类接口名1，父类接口名2{}

				主要：
						实现类必须实现父接口的所有方法；
						接口可以应用多态
						
	接口和类的关系：
			类和类：单继承
			类和接口：多实现
			接口和接口：多继承
			父类和父接口可以同时存在，但是继承必须写在接口前面
			
	类与接口的冲突：
		①父类继承和父接口方法重名的时候，优先调用继承父类的方法
			**当接口的抽象方法名和父类的方法名相同的时候，可以不写实现类**
		②如果两个父接口中有方法冲突(相同的方法)-------》当两个接口的默认方法重名的时候，可以分别调用
			 实现类出现编译错误
            实现类必须重写该方法,然后可以做出选择！
            父接口名.super.方法

    @Override
    public void run() { //当两个接口的静态方法重名的时候，可以分别调用
        CD.super.run();
        Computer.super.run();
    }

   经典的接口
        功能：定义对比两个对象大小的规则
        a、 java.lang.Comparable
            public int compareTo(Object o);
                this 和 o对比大小 -- 返回正数this大，返回负数o大，返回0相等

        b、java.util.Comparator
            public int compare(Object o1, Object o2)
                o1 和 o2对比大小 -- 返回正数o1大，返回负数o2大，返回0相等

内部类
类的五大组成部分：成员变量+成员方法+构造方法+代码块（静态代码块）+内部类（主要是指成员内部类）
a.成员内部类
位置：直接在类体中（和其他成员是同一个级别）
语法： [修饰符] class 类名{}
class文件名（字节码文件）：外部类名$内部类名。class-----》Outer$Inner1.class
内部类的修饰符：
四种权限修饰符+abstract+final+static
内部类可以有那些组成部分：
五大成员（组成部分）都可以，但是不能存在静态资源（但是当类为静态的时候除外）
内部类的使用：
内部类使用外部类资源：
直接使用
外部类使用内部类资源：
需要实例化对象，通过对象调用

/**
 * 同一个类中 private的作用域为整个外部类
 */
public class Person { //外部类
    private int id;     //成员变量
    private  String name;

    public Person() {  //构造方法
    }
    public void add(){
        son son = new son();
        System.out.println(son.age);//外调内 需要实例化对象
    }
    public void run(){  //成员方法
        System.out.println("外部类在跑步");
    }

    {//代码块

    }

    class son{ //内部类
        private int age;
         private String name;

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public son(int age) {
            this.age = age;
        }

        public son() {
        }
        public void add(){
            System.out.println(id);//内调外 直接调用
            System.out.println(this.name);//当前属性
            System.out.println(Person.this.name);//外部类的属性
        }
        public  void swim(){
            System.out.println("内部类在游泳");
        }
        { }
        class daughter{
        }
    }

}


/**
 * 内部类
 * 成员内部类
 */
public class Test1 {
    public static void main(String[] args) {
        //调用内部的属性
        Person.son a =new Person().new son(15);
        a.swim();
        System.out.println(a.getAge());
    }
}

				外部其他类如何调用内部类资源：
				 		需要实例化对象，通过对象访问
				 		语法：外部类名.内部类类名 对象名= 外部类对象.new 内部类类名（[实参列表]）；
				     Outer.Inner1 inner1=new Outer().new Inner1();

b.静态成员内部类
c.方法内部类
d.匿名内部类