股票交易c 接口-接口interface_安慕希ai的博客

知识清单

接口使用interface来定义。Java中，接口和类是并列的两个结构。如何定义接口：定义接口中的成员 1JDK7及以前：只能定义全局常量和抽象方法 >全局常量：publicstaticfinal的，但是书写时可以省略不写 >抽象方法：方法会被隐式地指定为publicabstract方法且只能是publicabstract方法，并且接口中所有的方法不能有具体的实现，也就是说，接口中的方法必须都是抽象方法。从这里可以隐约看出接口和抽象类的区别，接口是一种极度抽象的类型，它比抽象类更加“抽象”，并且一般情况下不在接口中定义变量。 2JDK除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法接口中不能定义构造器的！意味着接口不可以实例化Java开发中，接口通过类去实现的方式来使用

如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类

Java类可以实现多个接口—>弥补了Java单继承性的局限性

接口与接口之间可以继承，而且可以多继承接口的具体使用，体现多态性接口，实际上可以看做是一种规范10、抽象类与接口有哪些异同

接口概述

代码演示

/*
 * 接口的使用
 * 1.接口使用interface来定义
 * 2.Java中，接口和类是并列的两个结构
 * 3.如何定义接口：定义接口中的成员
 * 		3.1 JDK7及以前：只能定义全局常量和抽象方法
 * 			>全局常量：public static final的，但是书写时可以省略不写
 * 			>抽象方法：public abstract的
 * 		3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法（略）
 * 4.接口中不能定义构造器的！意味着接口不可以实例化
 * 
 * 5.Java开发中，接口通过类去实现（implements）的方式来使用
 *   如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
 *   如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
 *   
 * 6.Java类可以实现多个接口 --->弥补了Java单继承性的局限性
 * 		格式：class AA extends BB implements CC,DD,EE
 * 7.接口与接口之间可以继承，而且可以多继承
 * 8.接口的具体使用，体现多态性
 * 9.接口，实际上可以看做是一种规范
 * 
 * 10.面试题：抽象类与接口有哪些异同
 */
public class InterfaceTest {
	public static void main(String[] args) {
		System.out.println(Flyable.MAX_SPEED);//7900
		System.out.println(Flyable.MIN_SPEED);//1
//		Flyable.MAX_SPEED=2;
		
		Plane plane =new Plane();
		plane.fly();//通过引擎起飞
		
		//下面都发生了多态
		//class Bullet extends Object implements Flyable,AA,BB, Attackable
		Attackable b=new Bullet();
		b.attack();//我是子弹我很牛逼
		Flyable b1=new Bullet();
		BB b2=new Bullet();
		AA b3=new Bullet();
		
		/*
		 * 输出结果
		 * 7900
			1
			通过引擎起飞
			我是子弹我很牛逼
		 */
	}
}

interface Flyable{
	
	//全局常量
	public static final int MAX_SPEED=7900;//第一宇宙速度
	int MIN_SPEED=1;//省略了public static final
	
	//抽象方法
	public abstract void fly();
	//省略了public abstract
	void stop();
	//public void stop1();
	//abstract void stop2();
	
	//接口中不能有构造器
	//com.liuyongbin.abstraxtExer3
//	public Flyable(){
//		
//	}
}

interface Attackable{
	void attack();
}

class Plane implements Flyable{

	String name;
	
	//实现抽象方法时，eclipse这一行前面会有一个白色的三角形
	@Override
	public void fly() {
		System.out.println('通过引擎起飞');
	}

	@Override
	public void stop() {
		System.out.println('驾驶员减速停止');
	}
	
}

abstract class Kite implements Flyable{
	//重写不重写都不报错
//	@Override
//	public void fly() {
//		
//	}
	public Kite(){
		
	}
}

class Bullet1 extends Kite {

	@Override
	public void stop() {//实现了stop方法，前面是个白色三角
		
	}
	@Override
	public void fly() {//重写Kite中的fly方法，看前面是个绿色三角，这个方法可有可无
						//因为Kite实现了该方法，再写一遍相当于重写	
	}
}

interface AA{
	void method1();
}

interface BB{
	void method2();
}

//接口可以多继承
interface cc extends AA,BB{
	
}


class Bullet extends Object implements Flyable,AA,BB, Attackable{

	@Override
	public void method2() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void method1() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void fly() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void stop() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void attack() {
		System.out.println('我是子弹我很牛逼');
	}

练习1

接口的应用代理模式与工厂模式

代理与工厂

Java8中关于接口的新规范

JDK除了定义全局常量和抽象方法外，还可以定义静态方法、默认方法代码演示

/*
 * JDK8：除了定义全局常量和抽象方法外，还可以定义静态方法、默认方法
 */
public interface CompareA {
	
	//静态方法
	public static void method1(){
		System.out.println('CompareA：北京');
	}
	
	//默认方法
	public  default void method2(){
		System.out.println('CompareA：上海');
	}
	
	default void method3(){//可以通过OutLine查看这个方法类型
		System.out.println('CompareA:上海');
	}
}

接口中定义的静态方法，只能通过接口名来调用。声明一个接口A里面有一个静态方法:method1()

interface A{
	public static  void method1(){
		System.out.println('interface A中的静态方法：method1');
	}
}

Test实现这个接口，只能通过接口名.方法名调用，通过实现类的对象不能调用通过实现类的对象，可以调用接口中的默认方法。如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法。在上述的接口中增加一个默认的default方法

interface A{
	public static  void method1(){
		System.out.println('interface A中的静态方法：method1');
	}
	public default void method2(){
		System.out.println('interface A中的default方法：method2');
	}
}

通过实现类Test的对象进行调用在实现类中重写method2方法，输出如下：

如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没重写此方法的情况下，默认调用的是父类中的同名同参数的方法。–>类优先原则接口A的声明

interface A{
	public default void method2(){
		System.out.println('interface A中的default方法：method2');
	}
}

声明一个父类具有一个与接口A中同名同参的方法

class FatherClass{
	
	public  void method2(){
		System.out.println('interface A中的default方法：method2');
	}
}

Test类继承FatherClass类、实现接口A

public class Test extends FatherClass  implements A{
	
	public static void main(String[] args) {
		Test t=new Test();
		t.method2();
	}
}

输出结果：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没重写此方法的情况下，报错。–>接口冲突。这就需要我们必须在实现类中重写此方法。接口A：

接口B：

Test类如何在子类(或实现类)的方法中调用父类、接口中被重写的方法接口A有一个method

interface A{
	public default void method(){
		System.out.println('interface A中的method方法');
	}
}

接口B中有一个method

interface B{
	public default void method(){
		System.out.println('interface B中的method方法');
	}
}

父类FatherClass有一个method

class FatherClass{
	
	public  void method(){
		System.out.println('FatherClass 中的method方法');
	}
}

Test类继承父类FatherClass实现接口A，B并重写method方法，且增加一个method在method3中调用接口A、B，父类FatherClass中的method方法如下：

public class Test extends FatherClass  implements A,B{
	
	@Override
	public void method() {
		System.out.println('自己定义的method方法');
	}
	
	//?如何在子类(或实现类)的方法中调用父类、接口中被重写的方法
	public  void method2(){
		method();//调用自己重写的method
		super.method();//调用父类的method
		A.super.method();//调用抽象类A的method
		B.super.method();//调用抽象类B的method
	}
	
	public static void main(String[] args) {
		Test t=new Test();
		t.method2();
	}
}

知识点六的一个练习

interface Filial{//孝顺的
	default void help(){
		System.out.println('老妈，我来救你了');
	}
}

interface Spoony{//痴情的
	default void help(){
		System.out.println('媳妇，别怕，我来了');
	}
}

class Father{
	public void help(){
		System.out.println('儿子，救我媳妇');
	}
}

public class Man extends Father implements Filial,Spoony{
	@Override
	public void help() {
		System.out.println('我该就谁呢？');
		Filial.super.help();
		Spoony.super.help();
	}
}

接口的面试题

文章为作者独立观点，不代表观点