Java学习笔记03——接口

最新推荐文章于 2023-05-25 17:53:39 发布

HeartJade

最新推荐文章于 2023-05-25 17:53:39 发布

阅读量75

点赞数 1

分类专栏：笔记文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_45762465/article/details/121710240

版权

笔记专栏收录该内容

10 篇文章 0 订阅

订阅专栏

接口

接口的使用

1.接口使用interface来定义

2.Java中，接口和类是并列的两个结构

3.如何定义接口：定义接口中的成员

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

>全局常量：public static final的.但是书写时，可以省略不写

>抽象方法：public abstract的

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

接口中不能定义构造器的！意味着接口不可以实例化
Java开发中，接口通过让类去实现(implements)的方式来使用.

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

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

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

格式：class AA extends BB implements CC,DD,EE

接口与接口之间可以继承，而且可以多继承
接口的具体使用，体现多态性
接口，实际上可以看做是一种规范

面试题：抽象类与接口有哪些异同？

接口的使用

1.接口使用上也满足多态性

2.接口，实际上就是定义了一种规范

3.开发中，体会面向接口编程！

知识点

知识点一：接口中定义的静态方法，只能接口来调用。

知识点二：通过实现类的对象，可以调用接口中的默认方法。

如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法。

知识点三：如果子类（或实现类）继承的父类和接口中声明了同名同参数的方法。

那么子类在灭有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。—》类优先原则

知识点四：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法

那么在实现类没有重写的情况下，报错. ----》接口冲突

那么就必须在实现类中重写此方法。

知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法：接口名+super+类名

方法的调用

class SubClass extends SuperClass implements CompareA,CompareB{
	
	public void method2(){
		System.out.println("SubClass：上海");
	}
	
	public void method3(){
		System.out.println("SubClass：深圳");
	}
	
	
	public void myMethod(){
		method3();//调用自己定义的重写的方法
		super.method3();//调用的是父类中声明的
		//调用接口中的默认方法
		CompareA.super.method3();
		CompareB.super.method3();
	}
}

代理模式

/*
 * 接口的应用：代理模式
 * 
 */
public class NetWorkTest {
	public static void main(String[] args) {
		Server server = new Server();
//		server.browse();
		ProxyServer proxyServer = new ProxyServer(server);
		
		proxyServer.browse();
		
	}
}

interface NetWork{
	
	public void browse();
	
}

//被代理类
class Server implements NetWork{

	@Override
	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("联网之前的检查工作");
	}
	
	@Override
	public void browse() {
		check();
		
		work.browse();
		
	}
	
}

工厂模式

工厂模式：实现了创建者与调用者的分离，即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

无工厂模式

interface Car{
void run();
}
class Audi implements Car{

public void run() { System.out.println("奥迪在跑");
}
}
class BYD implements Car{
public void run() { System.out.println("比亚迪在跑");
}
}

public class Client01 {

public static void main(String[] args) { Car a = new Audi();
Car b = new BYD(); a.run();
b.run();
}

}

简单工厂模式

interface Car {
void run();
}

class Audi implements Car {

public void run() { System.out.println("奥迪在跑");
}
}

class BYD implements Car {
public void run() { System.out.println("比亚迪在跑");
}
}
 //工厂类
class CarFactory {
//方式一
public static Car getCar(String type) {
if ("奥迪".equals(type)) {
return new Audi();
} else if ("比亚迪".equals(type)) {
return new BYD();
} else {
return null;
}
}
}
public class Client02 {

public static void main(String[] args) { Car a = CarFactory.getCar("奥迪"); a.run();
Car b = CarFactory.getCar("比亚迪"); b.run();
}

}

工厂方法模式

interface Car{
void run();
}
//两个实现类

class Audi implements Car{

public void run() { System.out.println("奥迪在跑");
}
}
class BYD implements Car{
public void run() { 
    System.out.println("比亚迪在跑");
	}
}
//工厂接口
interface Factory{ 
    Car getCar();
}
//两个工厂类
class AudiFactory implements Factory{
public Audi getCar(){
return new Audi();
}
}
class BydFactory implements Factory{
public BYD getCar(){
return new BYD();
}
}

public class Client {

public static void main(String[] args) { 
    Car a = new AudiFactory().getCar(); Car b = new BydFactory().getCar(); a.run();
	b.run();
}