全部栏目

首页 操作系统 后端开发 数据库 前端开发 移动端开发
您的当前位置：首页正文

Java基础之接口(详细笔记)

2024-11-28 来源：个人技术集锦

 

 接口的本质

接口是抽象类的延伸，可以将它看做是纯粹的抽象类，接口中的所有方法都没有方法体。

在Java程序设计语言中，接口不是类，而是对类的一组需求描述，这些类要遵从接口描述的统一格式进行定义。继承是一个“是不是”的关系，接口实现则是能不能的关系。接口的本质是契约，标准，规范。

1.接口不是类，不能使用new运算符实例化一个接口

2.类可以实现多个接口，弥补Java单继承的局限性

3.接口和类是并列的两个结构

4.接口的方法都是抽象方法

x= new Comparable(...);//ERROR
Comparable x;//OK

接口变量必须引用实现了接口的类对象

x=new Employee(...);//OK provide Employee implements Comparable

接口的语法：

public interface pain{
void draw();
}

定义接口方法可省略public abstract 关键字

一个类继承一个父类的同事再实现一个接口，可以写成如下形式

public class Parallelogram extends Quardrangle implements Paintable{

}

JDK7及以前，只能定义全局常量和抽象方法。

  • 全局常量：public static final的
  • 抽象方法:public abstract 的

JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法，默认方法。

视频笔记：

public class test {
	public static void main(String[] args)
	{
		System.out.println(fly.max_speed);
		System.out.println(fly.min_speed);
	}
}
interface fly{
	//全局常量
	public static final int max_speed=7900;//第一宇宙速度
	public static final int min_speed=1;
}

有些修饰符可省略

 接口中不可创建构造器，则接口不能实例化。

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

 下面看一段代码

public class test {
	public static void main(String[] args)
	{
		System.out.println(fly.max_speed);
		System.out.println(fly.min_speed);
		bird a1=new bird();
		a1.f();
	}
}
interface fly{
	//全局常量
		public static final int max_speed=7900;//第一宇宙速度
		public static final int min_speed=1;
	public  abstract void f();
	void g();//public abstract可省略
		
}
class bird implements  fly{
	public void f()
	{
		System.out.println("飞吧");
	}
	public void g()
	{
		
	}
}

类bird中f()和g()方法都要重写，否则会报错.或者在class前面加个abstract，表面自己还是一个抽象类，不实例化

 实现多个接口:

public class test {
	public static void main(String[] args)
	{
		System.out.println(fly.max_speed);
		System.out.println(fly.min_speed);
		bird a1=new bird();
		a1.f();
	}
}
interface fly{
	//全局常量
		public static final int max_speed=7900;//第一宇宙速度
		public static final int min_speed=1;
	public  abstract void f();
	void g();//public abstract可省略
		
}
interface attack{
	void ak();
	
}
 class bullet implements fly,attack{
	public void ak() {
		
	}
	public void f()
	{
		
	}
	public void g()
	{
		
	}
}
class bird implements  fly{
	public void f()
	{
		System.out.println("飞吧");
	}
	public void g()
	{
		
	}
}

 格式：

class A extends B implements C,D,E

类和接口之间是实现关系，接口和接口之间是继承关系，接口与接口之间也可以多继承

  • 接口的使用，体验多态性
  • 接口实际上可以看做是一种规范

接口也可以继承多个接口

public interface A{ 
public void testA();
}
public interface B{ 
public void testB();
}
public interface C extends A,B{
 public void testC(); 
}

接口的使用也满足多态性

接口的非匿名实现类的非匿名对象

public class test {
	public static void main(String[] args)
	{
    Computer A=new Computer();
    U u1=new U();
    A.transferdate(u1);
	}
}
interface USB	{
	void start();
	void stop();
}
class U implements USB{
	public void start()
	{
		System.out.println("U盘开始工作");
	}
	public void stop()
	{
		System.out.println("U盘结束工作");
	}
}
class  print implements USB{
	public void start()
	{
		System.out.println("打印机开始工作");
	}
	public void stop()
	{
		System.out.println("打印机结束工作");
	}
}
class Computer{
	public void transferdate(USB usb)
	{
		usb.start();
		System.out.println("传输过程");
		usb.stop();
	}
	
}

可以将上下两幅图的代码进行对比 

public class test {
	public static void main(String[] args)
	{
    Computer A=new Computer();
    print k=new print();
    A.transferdate(k);
	}
}
interface USB	{
	void start();
	void stop();
}
class U implements USB{
	public void start()
	{
		System.out.println("U盘开始工作");
	}
	public void stop()
	{
		System.out.println("U盘结束工作");
	}
}
class  print implements USB{
	public void start()
	{
		System.out.println("打印机开始工作");
	}
	public void stop()
	{
		System.out.println("打印机结束工作");
	}
}
class Computer{
	public void transferdate(print usb)
	{
		usb.start();
		System.out.println("传输过程");
		usb.stop();
	}
}

 接口的非匿名实现类的匿名对象

 A.transferdate(new print());

 接口的匿名实现了类的非匿名对象

public class test {
	public static void main(String[] args)
	{
    Computer A=new Computer();
    USB phone=new USB() {
    	public void start()
    	{
    		System.out.println("手机开始工作");
    	}
    	public void stop()
    	{
    		System.out.println("手机结束工作");
    	}	
    };
    A.transferdate(phone);
	}
}
interface USB	{
	void start();
	void stop();
}
class U implements USB{
	public void start()
	{
		System.out.println("U盘开始工作");
	}
	public void stop()
	{
		System.out.println("U盘结束工作");
	}
}
class  print implements USB{
	public void start()
	{
		System.out.println("打印机开始工作");
	}
	public void stop()
	{
		System.out.println("打印机结束工作");
	}
}
class Computer{
	public void transferdate(USB usb)
	{
		usb.start();
		System.out.println("传输过程");
		usb.stop();
	}
}

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

public class test {
	public static void main(String[] args)
	{
    Computer A=new Computer();
    A.transferdate(new USB(){
    	public void start()
    	{
    		System.out.println("xx开始工作");
    	}
    	public void stop()
    	{
    		System.out.println("xx结束工作");
    	}	
    });	
	}
}
interface USB	{
	void start();
	void stop();
}
class U implements USB{
	public void start()
	{
		System.out.println("U盘开始工作");
	}
	public void stop()
	{
		System.out.println("U盘结束工作");
	}
}
class  print implements USB{
	public void start()
	{
		System.out.println("打印机开始工作");
	}
	public void stop()
	{
		System.out.println("打印机结束工作");
	}
}
class Computer{
	public void transferdate(USB usb)
	{
		usb.start();
		System.out.println("传输过程");
		usb.stop();
	}

接口的应用：代理模式

public class test {
	public static void main(String[] args)
	{
		server A=new server();//造完被代理类对象后，扔到代理类对象去调用方法
		proxyserver ps=new proxyserver(A);
		ps.browse();
	}
}
interface network{
	public void browse();
	
}
//被代理类
class server implements network{
	public void browse()
	{
		System.out.println("访问网络");
	}
}
//代理类
class proxyserver implements network{
	private network work;
	public proxyserver (network work)
	{
		this.work=work;
	}
	public void check()
	{
		System.out.println("检查工作");
	}
	public void browse()
	{
		check();
		work.browse();
	}
}

视频笔记： 

 代理模式的应用场景：

  • 安全代理：屏蔽对真实角色(被代理类)的直接访问
  • 远程代理：通过代理类处理远程方法调用(RMI)
  • 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象

分为静态代理(静态定义代理类)和动态代理(动态生成代理类)

笔试题and面试题

下面看一段错误的代码

public class test {
}
interface A{
	int x=0;
}
class B{
	int x=1;
}
class C extends B implements A{
	public void p()
	{
		System.out.println(x);
	}
}

视频笔记：一般父类B的属性和接口的属性尽量不要写重名

public class test {
}
interface A{
	int x=0;
}
class B{
	int x=1;
}
class C extends B implements A{
	public void p()
	{
		//System.out.println(x);
		System.out.println(super.x);//1
		System.out.println(A.x);//A.属性
	}
}

 下面看一段错误的代码

public class test {
}
interface A{
	void f();
}
interface B{
	void f();
}
interface C extends A,B{
	jtest j=new jtest("小明");
}
class jtest implements C{
 private String name;
 public  jtest(String name)
 {
	this.name=name;
 }
 public String  getname()
 {
	 return name;
 }
 public void f()
 {
	 j=new jtest("小王");
	 System.out.println(j.getname());
 }
}
  • 类jtest中对方法f()的重写可以理解为对A,B中的方法f()都重写了
  • 我们需要注意j=new jtest("小王");这行代码，由接口的定义我们可以指知道jtest j=new jtest("小明");这行代码前面省略了public static final等修饰符

 用接口实现两个对象的比较

public interface compareobject {
	public int compare(Object o);//规范：返回0代表相等，返回正数代表当前对象大，返回负数则相反
}
public class square {
private double s;
public double gets()
{
	return s;
}
public void sets(double s)
{
	this.s=s;
}
public square()
{
	super();
}
public square(double s)
{
	super();
	this.s=s;
}
}
//comparesquare类继承square并且实现compareobject的接口，给出接口中方法compare的实现体，用来比较大小
public class comparesquare extends square implements compareobject{
public comparesquare (double s)
{
	super(s);
}
	public int compare(Object o)//规范：返回0代表相等，返回正数代表当前对象大，返回负数则相反
	{
		if(this==o)
		{
			return 0;
		}
		if(o instanceof comparesquare)
		{
			comparesquare n=(comparesquare)o;
		if(this.gets()>n.gets())
		{
			return 1;
		}
		else if(this.gets()<n.gets()) {
			return -1;
		}
		else {
			return 0;
		}
		}
		else {
			return 0;
		}
	}
}
public class test {
	public static void main(String[] args)
	{
	comparesquare A=new comparesquare(28.0);
	comparesquare B=new comparesquare(2.0);
	int m=A.compare(B);
	if(m>0)
	{
		System.out.println("A大");
	}
	if(m<0)
	{ 
		System.out.println("B大");
	}
	if(m==0)
	{
		System.out.println("一样大");
	}	
}
}

Java8中关于接口的改进

  • 接口中的静态方法只能通过接口来调用：接口.静态方法。
  • 通过实现类的对象，可以调用接口中的默认方法

学习如逆水行舟，不进则退，和小吴一起加油吧！

  
显示全文