学习Java简单整理笔记--Day12

接口

1，引入
---微观的理解：接口像是一个功能
---宏观的理解：接口如同规则一般
2，使用
    1，定义
        1，语法：
            访问权限修饰符   interface  接口名{

            }

        2，可以定义：
            公共静态常量
            公共静态方法
            公共抽象方法

        3，注意：
            1，接口中没有代码块
            2，接口中的属性默认使用public static final 修饰的常量
            3，接口中没有构造函数，因此不能直接创造对象
            4，接口中可以有方法，但必须是静态方法(static)、抽象方法(abstract)，其中默认使
        用public abstract修饰
            5，接口在jdk1.8以及后版本可以有default修饰的普通方法（了解）

package com.qf.demo01;

public interface MyInterface {
	String name = "xxx";
	public static void test01() {
		
	}
	void test02();
	default void test03() {
		
	}
}
class A{
	private static final String name = "xxx";
}

    2，使用
        1，接口使用接口
            关系：一个接口可以继承多个接口
                一个接口可以继承多个接口的静态属性
                一个接口没有继承多个接口的静态方法
            语法：
                访问权限修饰符  interface  子接口名 extends 父接口1，父接口2，...{
                
                }
        2，类使用接口
            关系：一个类可以实现多个接口
            语法：
                访问权限修饰符   class   类名  implements   接口1，接口2，....{

                }
        3，注意：
            1，子类或子接口，可以继承父接口的公共静态常量，公共抽象方法，但没有继承公共
        静态方法
            2，子类对象转换为父类对象时，该父类对象无法调用子类特有的属性和方法，只能
        调用父类中定义的属性和方法
            3，子类对象转换为父类对象时，该父类对象调用重写后的方法，调用的是子类重写后的方法

package com.qf.demo02;
public class Test {
	public static void main(String[] args) {
		/**
		 * 可以继承父接口的静态属性
		 */
		System.out.println(CInterface.testA);
		System.out.println(CInterface.testB);
		/**
		 * 没有继承父接口的静态方法
		 */
//		CInterface.testA01();
//		CInterface.testB01();
		
		DClass dClass = new DClass();
		AInerface a = dClass;
		BInerface b = dClass;
		System.out.println(dClass.testA);
		System.out.println(dClass.testB);
		dClass.testA02();
		dClass.testB02();
		/**
		 * 子类对象转换为父类对象后,无法调用子类特有的属性或方法
		 * 子类对象转换为父类对象后,调用重写的方法时,执行的是子类重写后的方法
		 */
		a.testA02();
	}
}
interface AInerface{
	String testA = "test----A";
	public static void testA01() {
		System.out.println("A接口的静态方法");
	}
	void testA02();
}
interface BInerface{
	String testB = "test----B";
	public static void testB01() {
		System.out.println("B接口的静态方法");
	}
	void testB02();
}
/**
 * 一个接口可以继承多个接口
 */
interface CInterface extends AInerface,BInerface{
	
}
class DClass implements AInerface,BInerface{
	@Override
	public void testB02() {
		// TODO Auto-generated method stub
		System.out.println("实现B接口重写的方法");
	}
	@Override
	public void testA02() {
		// TODO Auto-generated method stub
		System.out.println("实现A接口重写的方法");
	}
	
}

    3，接口与抽象类的区别
        1，不同点
            1，接口：
                含义是功能或者规则
                有公共静态常量，公共静态方法，公共抽象方法
                子类可以实现多个接口
                接口可以继承多个接口
            2，抽象类：
                含义是概念
                有属性，有构造函数，方法，代码块
                子类只能继承一个父类
                只能实现多个接口
        2，相同点
            1，都会生成class文件
            2，都无法直接创建对象
            3，都可以拥有抽象放法
3，常量接口
    概念：在接口中只有公共静态常量
4，接口回调
----总结：
    步骤：
        1，在A中创建接口对象
        2，在A中使用B对象调用b1方法，将接口对象传入B中
        3，在A中使用B对象调用b2方法，在b2方法中使用接口对象调用方法

package com.qf.test02;
//测试类
public class Test {
	public static void main(String[] args) {
		MyTest myTest = new B();
		A a = new A();
		a.setTest(myTest);
		a.a();		
	}
}
//接口
interface MyTest{
	void test();
}
//创建A类，设置接口属性
class A{
	private MyTest myTest;
	public void setTest(MyTest myTest) {
		this.myTest = myTest;
	}
	public void a() {
		myTest.test();
	}
}
//B类实现接口MyTest
class B implements MyTest{

	@Override
	public void test() {
		// TODO Auto-generated method stub
		System.out.println("xxxx");
	}	
}