Java面向对象接口

首先要清楚接口和类是两个并列结构。

接口：举例：

代码理解：

package com.atguigu.java2;

public class InterfaceTest {
	public static void main(String[] args) {
		System.out.println(Flyable.MAX_SPEED);
		System.out.println(Flyable.MIN_SPEED);
//		Flyable.MIN_SPEED=2;   //此处注释打开编译出错，final修饰不可变
		Plane plane =new Plane();
		plane.fly();
	}
}

interface Flyable{
	//定义全局常量
	public static final int MAX_SPEED=7900;
	int MIN_SPEED=1;  //public static final的，书写时可以省略，结构依然在
	//定义抽象方法
	public abstract void fly();
	void stop();   //省略了public abstract，结构依然在，仍为抽象方法 
}

class Plane implements Flyable{ //让飞机类实现“可飞”的接口
//接口中有两个抽象方法，此处需要重写抽象方法或将此飞机类设为抽象类
	@Override
	public void fly() {
		System.out.println("飞机通过引擎起飞");
		
	}
	@Override   //对于抽象的方法，严格来说不是重写，而是实现
	public void stop() {
		System.out.println("驾驶员加速停止");
	}  	
}

abstract class kite implements Flyable{  //注意此处使用了abstract

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

package com.atguigu.java2;

public class InterfaceTest {
	public static void main(String[] args) {
		System.out.println(Flyable.MAX_SPEED);
		System.out.println(Flyable.MIN_SPEED);
		Plane plane =new Plane();
		plane.fly();
	}
}

interface Flyable{
	//定义全局常量
	public static final int MAX_SPEED=7900;
	int MIN_SPEED=1;  
	//定义两个抽象方法
	public abstract void fly();
	void stop();   
}
interface Attackable{
	void attack();   //此为抽象方法省略了public abstract
}

//实现多个接口（需要实现接口中所有抽象方法），逗号隔开
class Bullet extends Object implements Flyable,Attackable,CC{  //先继承父类，再写实现的接口
	@Override
	public void attack() {
			
	}
	@Override
	public void fly() {
		
	}
	@Override
	public void stop() {
		
	}
	//把CC中包含的抽象方法全部实现（重写）
	@Override
	public void method1() {
		
	}
	@Override
	public void method2() {
		
	}  
}
class Plane implements Flyable{ //让飞机类实现“可飞”的接口
	@Override
	public void fly() {
		System.out.println("飞机通过引擎起飞");
	}
	@Override   //对于抽象的方法，严格来说不是重写，而是实现
	public void stop() {
		System.out.println("驾驶员加速停止");
	}  	
}
/
public class USBTest {
	public static void main(String[] args) {
		Computer computer=new Computer();
		//接口不可以造对象，所以只能造它的实现类的对象---->多态
		Flash flash=new Flash();
		computer.transferData(flash);
	}
}
class Computer{
	public void transferData(USB usb){  //声明为USB，实际上new的是一个实现类对象
		usb.start();   //编译的时候认为调用的都是抽象方法，实际执行的是实现类对象重写的方法
		System.out.println("具体传输细节");
		usb.stop();
	}
}

interface USB{       //实际上体现一种规范：谁想和电脑传输数据都要把此接口进行实现，并且把其中的规范明确一下
	//省略长宽尺寸，最大最小的传输速度等常量的定义
	//定义两个抽象方法
	void start(); 
	void stop();
}

class Flash implements USB{  //U盘类
	@Override
	public void start() {
		System.out.println("U盘开启工作");
	}
	@Override
	public void stop() {
		System.out.println("U盘结束工作");
	}
}
class Printer implements USB{  //打印机类
	@Override
	public void start() {
		System.out.println("打印机开启工作");	
	}
	@Override
	public void stop() {
		System.out.println("打印机结束工作");
	}
}

创建接口匿名实现类的对象

package com.atguigu.java2;
public class USBTest {
	public static void main(String[] args) {
		Computer computer=new Computer();
		//接口不可以造对象，所以只能造它的实现类的对象---->多态
		//1，创建接口的非匿名实现类的非匿名对象
		Flash flash=new Flash();
		computer.transferData(flash);
		//2，创建接口的非匿名实现类的匿名对象
		computer.transferData(new Printer());
		//3，创建接口的匿名实现类的非匿名对象
		USB phone=new USB(){  //对象名为phone
			@Override
			public void start() {
				System.out.println("手机开始工作");
			}
			@Override
			public void stop() {
				System.out.println("手机结束工作");
			}
		};
		computer.transferData(phone);
		//4，创建接口的匿名实现类的匿名对象
		computer.transferData(new USB(){
			@Override
			public void start() {
				System.out.println("mp3开始工作");
			}
			@Override
			public void stop() {
				System.out.println("mp3结束工作");
			}
		});
		
	}
}
class Computer{
	public void transferData(USB usb){  //声明为USB，实际上new的是一个实现类对象
		usb.start();   //编译的时候认为调用的都是接口的抽象方法，实际执行的是实现类对象重写的方法
		System.out.println("具体传输细节");
		usb.stop();
	}
}

interface USB{       //实际上体现一种规范：谁想和电脑传输数据都要把此接口进行实现，并且把其中的规范明确一下
	//省略长宽尺寸，最大最小的传输速度等常量的定义
	//定义两个抽象方法
	void start(); 
	void stop();
}

class Flash implements USB{  //U盘类
	@Override
	public void start() {
		System.out.println("U盘开启工作");
	}
	@Override
	public void stop() {
		System.out.println("U盘结束工作");
	}
}
class Printer implements USB{  //打印机类
	@Override
	public void start() {
		System.out.println("打印机开启工作");	
	}
	@Override
	public void stop() {
		System.out.println("打印机结束工作");
	}
}

练习：

①
此程序会编译出错，因为x不明确，需要进行修改：

我们想输出父类的x时，使用：
System.out.println(super.x); //1

我们想输出接口的x，使用：
System.out.println(A.x); //0
接口中的x为全局常量，可以通过此方法调用。

②

③

①Circle

package com.atguigu.exer2;

public class Circle {
	private double radius;
	
	public Circle() {
		super();
	}
	public Circle(double radius) {
		super();
		this.radius = radius;
	}
	
	public double getRadius() {
		return radius;
	}
	public void setRadius(double radius) {
		this.radius = radius;
	}
}

②接口

package com.atguigu.exer2;
public interface CompareObject {
	public int compareTo(Object o); //此方法为抽象方法。若返回值是 0 , 代表相等; 若为正数，代表当前对象大；负数代表当前对象小
}

③ComparableCircle类

package com.atguigu.exer2;

import javax.management.RuntimeErrorException;

public class ComparableCircle extends Circle implements CompareObject{
	public ComparableCircle(double radius) {
		super(radius);
	}
	
	//重写接口中的抽象方法  ---->比较对象大小
	@Override
	public int compareTo(Object o) {
		if(this==o){
			return 0; //地址都一样，必定等
		}
		if(o instanceof ComparableCircle){
			ComparableCircle c=(ComparableCircle)o;
//			return (int) (this.getRadius()-c.getRadius()); //错误。强转会造成精度损失，如2.3-2.1强转后变为0
			//正确写法:
			if(this.getRadius()>c.getRadius()){
				return 1;
			}else if(this.getRadius() 
④ComparableCircleTest测试 
package com.atguigu.exer2;

public class ComparableCircleTest {
	public static void main(String[] args) {
		ComparableCircle c1=new ComparableCircle(3.4);
		ComparableCircle c2=new ComparableCircle(3.6);
		
		int comparevalue=c1.compareTo(c2);
		if(comparevalue>0){
			System.out.println("c1对象大");
		}else if(comparevalue<0){
			System.out.println("c2对象大");
		}else{
			System.out.println("c1与c2一样大");
		}
		
	}
}

 

 JDK7及以前：只能定义全局常量和抽象方法 
 
 全局常量：public static final的，书写时可以省略
   抽象方法：public abstract的
  
JDK8开始：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法。 
接口1： 
package com.atguigu.Java8;

public interface CompareA {  //接口
	//静态方法（可以直接通过接口来调用）
	public static void method1(){   //Java8中可以有方法体
		System.out.println("CompareA:北京");
	}
	//默认方法
	public default void method2(){  //默认方法
		System.out.println("CompareA:上海");
	}
	default void method3(){  //默认方法，省略public
		System.out.println("CompareA:上海");
	}
}

 
接口2： 
package com.atguigu.Java8;

public interface CompareB {
	default void method3(){
		System.out.println("CompareB:上海");
	}
}

 
父类SuperClass： 
package com.atguigu.Java8;

public class SuperClass {
	public void method3(){
		System.out.println("SuperClass:北京");
	}
}

 
SubClassTest： 
package com.atguigu.Java8;
public class SubClassTest {
	public static void main(String[] args) {
		SubClass s=new SubClass();
//		s.method1();    此处注释打开会报错，说没有定义method1方法
		//知识点1：接口中定义的静态方法只能通过接口来调用
		CompareA.method1();  //CompareA:北京。此为正确写法
		//知识点2：通过实现类的对象，可以调用接口中的默认方法;如果实现类重写了接口中的默认方法，调用时，调用的是重写以后的方法
		s.method2();  //SubClass:上海
		
		s.method3();  //注意此处输出SuperClass:北京
		
//		SubClass.method2();  //此处注释打开会报错，因为method2不是静态的，所以不能通过类调用，而是需要经过对象
	}

}

class SubClass extends SuperClass implements CompareA,CompareB{  //继承父类，实现接口
	public void method2(){  //重写覆盖
		System.out.println("SubClass:上海");
	}
	
	public void myMethod(){
		super.method3(); //调用父类中的方法
		//调用接口中的默认方法
		CompareA.super.method3();
		CompareB.super.method3();
	}
}

Java面向对象 接口

Java相关栏目本月热门文章

Java面向对象接口