Java基础之接口(详细笔记)
博客主页小吴_小吴有想法_CSDN博客-笔记,java,leetcode领域博主
欢迎关注
点赞
收藏和留言
天道酬勤，勤能补拙，和小吴一起加油吧
大一新生，水平有限，恳请各位大佬指点，不胜感激!
- 这里有一点路线小伙伴可以参考一下哈JAVA实现客户信息管理系统以及给大一寒假学生的建议_小吴-CSDN博客
- 参考书籍：Java从入门到精通，Java核心卷1。视频：尚硅谷
目录
接口的本质
接口的语法：
接口的使用也满足多态性
接口的非匿名实现类的非匿名对象
接口的非匿名实现类的匿名对象
接口的匿名实现了类的非匿名对象
接口的匿名实现类的匿名对象
接口的应用：代理模式
笔试题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()0)
{
System.out.println("A大");
}
if(m<0)
{
System.out.println("B大");
}
if(m==0)
{
System.out.println("一样大");
}
}
} 
Java8中关于接口的改进
- java8中，可以为接口添加静态方法和默认方法。
- 静态方法：static修饰，可以通过接口直接调用静态方法，并执行其方法体。
- 默认方法：使用default修饰，可以通过实现类的对象来调用。在已有的接口中提供新方法的同时，还保持了与旧代码的兼容性：Java8 API中对Collection,List等接口提供了丰富的默认方法
- 接口中的静态方法只能通过接口来调用：接口.静态方法。
- 通过实现类的对象，可以调用接口中的默认方法
学习如逆水行舟，不进则退，和小吴一起加油吧！
