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

最新推荐文章于 2022-09-05 21:12:44 发布
最新推荐文章于 2022-09-05 21:12:44 发布
阅读量1.3k 收藏 15
点赞数 42
分类专栏： java 笔记 文章标签： javase 入门 java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wuweihendidiao/article/details/122387236
版权
笔记 同时被 2 个专栏收录
33 篇文章 0 订阅
订阅专栏
java
26 篇文章 3 订阅
订阅专栏

目录

 接口的本质

接口的语法：

接口的使用也满足多态性

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

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

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

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

接口的应用：代理模式

笔试题and面试题

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

Java8中关于接口的改进

 

 接口的本质

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

在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中关于接口的改进

  1.  java8中，可以为接口添加静态方法和默认方法。
  2. 静态方法：static修饰，可以通过接口直接调用静态方法，并执行其方法体。
  3. 默认方法：使用default修饰，可以通过实现类的对象来调用。在已有的接口中提供新方法的同时，还保持了与旧代码的兼容性：Java8 API中对Collection,List等接口提供了丰富的默认方法

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

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

  

小吴有想法
关注
  • 42
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 53
    评论
专栏目录
interface和abstract 的区别和相同点
Mandypan的博客
08-06 1万+
在Java语言中，abstract class和interface是支持抽象类定义的两种机制。 不能创建abstract类的实例，然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。 不能有抽象构造函数或抽象静态方法。 Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。 接口（interface）是抽象类的变体。 在接口中，所有方法都是
JAVA接口笔记
照玄
07-19 1032
Java编程语言中禁止多继承属性，但可以通过接口来帮助类扩展方法。接口中可以定义大量的常量和方法，但其中的方法只是一种声明，没有具体的实现，使用接口的类自己实现这些方法。接口与类的不同在于：  (1) 没有变量的声明，但可以定义常量。  (2) 只有方法的声明，没有方法的实现。  接口声明的基本格式如下：          public interface 接口名 extends 接口列表
java接口笔记
qq_35559025的博客
05-16 162
接口笔记 在java9+中，接口内容可以有： 1.成员变量其实就是常量 [public][static][fianl]数据类型 常量名称=数据值 注意 常量必须赋值，且不可改变 常量名称大写，用下划线分离 2.接口中最重要的就是抽象方法 [public][abstract]返回值类型 方法名称（参数列表）； 注意： 实现类必须覆盖重写所有抽象方法，除非实现类是抽象方法 3.从java8开始，接口允许定义静态方法 [public]static 返回值类型 方法名称 （参数列表）{方法体
Java接口笔记
weixin_47113678的博客
07-26 104
接口也是Java实现多态的一种形式。类通过安装接口，实现接口的抽象方法或者使用接口的默认方法、静态方法来达到“扩展”功能的作用。而继承父类则像关键字extends一样，强调的是“继承”的作用。 如果某个类安装了某个接口后，只想使用一次，那么可以不必多创建一个Class文件，而是直接使用该接口的匿名内部类。所谓的匿名内部类，格式为：接口名称(子类) 对象名 = new 接口（子类）名称（）{方法体}；。在方法体内实现接口的抽象方法。 更极端的情况是匿名对象，即对象名也不写，直接new，这种情况下只能调用一个方
JAVA学习笔记1--java中接口的基础知识
young12345670的博客
09-03 200
关于java中接口的基础知识 实现interface(接口)的基本格式 **接口：interface 格式： public interface 接口名{ //抽象方法 } 1、接口中不能定义变量 2、接口的的方法是抽象方法 没有方法体 3、接口不可以创建对象但接口可以作为一种类型存在 实现接口的方式： 创建一个类实现接口 implements（实现） 格式： public class 类名 implements 接口{ } 特殊性质： 1、直接使用接口中的字段 2、必须实现接口
java笔记——接口
weixin_41399650的博客
06-25 160
记录一下学习java核心卷1中第六章（接口、lambda表达式与内部类）中接口的内容
尚硅谷JAVA基础笔记吐血整理
02-03
“尚硅谷JAVA基础笔记”涵盖了Java语言的基础知识，包括语言概述、基本语法、面向对象概念、封装、继承和多态，以及一些关键概念如形参与实参、属性与局部变量、构造器、this关键字、包和MVC设计模式的使用。...
java笔记整理(超详细) java笔记整理(超详细)
07-14
Java集合可以分为Collection和Map两种体系: Collection接口: ​ List:元素有序,可重复的集合 ​ ArrayList: 底层数组实现,有利于随机访问get ​ LinkedList:底层是链表,有利于频繁的插入、删除操作(ArrayList删除和...
Java基础学习详细笔记
11-11
本文将详细解析Java的基础概念，包括源代码的组成、执行流程、命名规则、编码格式、标识符、注释、变量的声明和初始化，以及Java中的成员变量和常量。 首先，源代码中的重要元素包括访问说明符（如public）、类声明...
Java基础笔记.pdf
11-30
本笔记将从基本概念开始，详细讲解 Java 的基础知识。 搭建环境和编译运行 在 Java 中，编译和运行程序需要搭建环境。首先，需要编写 Java 源代码，例如： ```java public class Zbb { public static void main...
java基础总结大全(笔记).pdf
02-28
Java基础总结大全涵盖了Java编程语言的核心概念，从JVM、JRE和JDK的区别，到环境变量的设置，再到变量的定义和类型转换，深入浅出地讲解了Java的基础知识。 1. JVM、JRE和JDK： - JVM（Java Virtual Machine）是...
java基础笔记(12) 接口
weixin_45429835的博客
08-05 88
接口 1.1 概述 生活中的接口：笔记本上的USB USB： 1、笔记本上如果要连入外设，那么这些外设必须都是以USB接口作为连入方式的 2、当笔记本上的USB接口连入了外设后，笔记本就有了额外的功能了，例如：VR，风扇，手柄 接口的好处： 1、实现额外功能的扩展 2、接口是对外暴露的规则，表示如果想要使用接口来扩展功能，那么必须符合这些规则，并且是作为同一体系下的内容 3、达到功能与具体实现的相...
java接口----小白入门笔记
主、Lantu的博客
11-18 259
java接口的概念：接口作为一种特殊的抽象类，指定一个类去做什么，而不是规定他如何去做。 接口的使用：接口的使用与类的使用有些不同。在需要使用类的地方，会直接使用new关键字来构建一个类的实例，但接口不可以这样使用，因为接口不能直接使用 new 关键字来构建实例。 接口必须通过类来实现(implements)它的抽象方法，然后再实例化类。类实现接口的关键字为implements。如果一个类不能实现该
接口-java的笔记小结
drleen的博客
01-24 221
接口 接口的语法 无需定义 即为Pubilc权限 接口的实现 implements来实现接口 类似继承 由于接口中的方法均为抽象方法，因此在实现后需要复写才能够引用。 class Phone implements USB,WIFI{ public void read(){ System.out.println("USB read"); } public vo...
Java中常见的修饰符（public，private，static，final，abstract）
code_change_era的博客
06-21 1859
修饰符 可分为访问修饰符和其它修饰符 访问修饰符 public：用public 修饰的类则该类可以被其它类访问，若该类是使用默认的修饰符，则该类只能被同包中的类访问。 private：更好的封装和隐藏，外部类不能随意存取和修改。 其它修饰符 static 1、static字段： 静态字段最本质的特点是类的字段，不属于任何一个对象的实例。 它不保存在某个对象实例的内存区间中，而是保存在类的公共存储单元中。 类变量可以通过类名直接访问，也可通过实例对象来访问。 static在一定意义上可以用来
Java中的抽象类，与接口
weixin_52821030的博客
11-05 489
1.抽象类 类---用来描述具有共同性质的一组事物的自定义复合数据类型 类---class关键字创建 public class Hello{}---类 抽象类---通过abstract修饰的java类就是。 public abstract class Hello{}---抽象类 2.为什么要有抽象类？ 例如：坐车收费，出租车有收费功能【1元/公里】 ...
Java中abstract的基本使用与详解
热门推荐
weixin_42072632的博客
01-08 2万+
先来看一道题： 下列哪一种叙述是正确的 A：abstract修饰符可修饰字段、方法和类 B：抽象方法的body部分必须用一对大括号{ }包住 C：声明抽象方法，大括号可有可无 D：声明抽象方法不可写出大括号 解析：D java中规定：abstract只能修饰类和方法，不能修饰变量。 1、什么是抽象类？ 类和类之间如果具有相同的特征，将这些共同的特征提取出来，形成的就是抽象类。 类本身是不存在的，所以抽象类无法实例化对象。 类到对象是实例化，对象到类是抽象。 public class Test { p
Java(五)——抽象类 abstract
MrDaKai的博客
09-05 861
Java 抽象类 1. 抽象方法定义 2. 抽象类的使用方式 3. 抽象类中成员的定义 3.1 抽象类中能否定义成员变量 3.2 抽象类中有构造方法吗 3.3 抽象中能否不定义抽象方法 3.4 子类还是抽象类的问题 4.抽象类案例
java基础 学习笔记 markdownr版
最新发布
09-06
Java基础学习笔记 # 一、Java简介 Java是一种面向对象的编程语言，由Sun Microsystems（现在是Oracle）于1995年首次发布。它具有跨平台的特性，可以在不同的操作系统上运行。Java语言被广泛应用于开发各种类型的应用程序，包括桌面应用、Web应用、移动应用等。 # 二、Java基本语法 ## 1. 变量与数据类型 Java是强类型语言，每个变量必须先声明后使用。Java提供了多种数据类型，包括基本数据类型（整数、浮点数、字符、布尔值）和引用数据类型（类、接口、数组）。 ## 2. 运算符 Java提供了多种运算符，包括算术运算符、关系运算符、逻辑运算符等，用于进行各种数学或逻辑运算。 ## 3. 控制流程 Java提供了多种控制流程语句，包括条件语句（if-else语句、switch语句）、循环语句（for循环、while循环）、跳转语句（break语句、continue语句）等，用于控制程序的执行流程。 ## 4. 方法和类 Java中的方法用于封装一段可重复使用的代码，可以带有参数和返回值。类是Java程序的基本组织单位，包含了属性和方法。可以使用关键字class定义一个类，通过实例化类的对象来调用其方法。 # 三、面向对象编程 Java是一种面向对象的编程语言，面向对象编程的核心概念包括封装、继承和多态。 ## 1. 封装 封装是将数据和行为打包成一个类，通过访问修饰符（public、private等）控制对类的成员的访问权限。 ## 2. 继承 继承允许一个类继承另一个类的属性和方法，并且可以通过重写来修改或扩展继承的方法。 ## 3. 多态 多态允许通过父类类型的引用来引用子类对象，实现对不同子类对象的统一调用。 # 四、异常处理 Java提供了异常处理机制，用于处理程序中的错误情况。异常分为可检查异常（checked exception）和不可检查异常（unchecked exception），可以使用try-catch语句来捕获和处理异常。 # 五、Java标准库 Java标准库提供了大量的类和接口，用于完成各种常见的任务。其中包括输入输出、集合、多线程、网络编程等功能，可以大大简化开发过程。 以上是我学习Java基础的笔记总结，希望对你有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 53
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小吴有想法

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值