6-6面向对象编程（下）----接口(interface)（3）代理模式&练习

接口的应用

一、代理模式（Proxy）
1.概述：
代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其他对象提供一种代理以控制对这个对象的访问。
2.应用场景：
（1）安全代理：屏蔽对真实角色的直接访问。 （2）远程代理：通过代理类处理远程方法调用（RMI）
（3）延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时，不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。 3.分类
（1）静态代理（静态定义代理类） 
（2）动态代理（动态生成代理类）：JDK自带的动态代理，需要反射等知识

代码：

package test4;
 
public class NetWorkTest {
 public static void main(String[] args) {
  Server server = new Server();
  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();
 }
 
}

输出：

联网之前的检查工作
真实的服务器访问网络

附：接口和抽象类之间的对比

二、练习排错
练习一

练习一代码：

package exer4;
 
interface A {
 int x = 0;
}
 
class B {
 int x = 1;
}
 
class C extends B implements A {
 public void pX() {
//  System.out.println(x);//编译不通过，x不明确
  //重名情况下：
  System.out.println(super.x);//1
  System.out.println(A.x);//0
 }
 
 public static void main(String[] args) {
  new C().pX();
 }
}

练习一输出：‘

1
0

练习二

练习二代码：

package exer4;
 
interface Playable {
 void play();
}
 
interface Bounceable {
 void play();
}
 
interface Rollable extends Playable, Bounceable {
 Ball ball = new Ball("PingPang");//前面省略了public static final，为final修饰
}
 
class Ball implements Rollable {
 private String name;
 
 public String getName() {
  return name;
 }
 
 public Ball(String name) {
  this.name = name;
 }
 
 public void play() {
//  ball = new Ball("Football");//编译不通过，final无法重新赋值
  System.out.println(ball.getName());
 }
  
 public static void main(String[] args) {
  ball.play();
 }
}

练习二输出：

PingPang

三、接口练习：比较对象大小

1.定义一个接口用来实现两个对象的比较。 

interface CompareObject{
public int compareTo(Object o); //若返回值是 0 , 代表相等; 若为正数，代表当前对象大；负数代表当前对象小
} 

2.定义一个Circle类，声明redius属性，提供getter和setter方法
3.定义一个ComparableCircle类，继承Circle类并且实现CompareObject接口。在ComparableCircle类中给出接口中方法compareTo的实现体，用来比较两个圆的半径大小。 
4.定义一个测试类InterfaceTest，创建两个ComparableCircle对象，调用compareTo方法比较两个类的半径大小。 
5.思 考 ： 参 照 上 述 做 法 定 义 矩 形 类 Rectangle 和 ComparableRectangle 类 ， 在ComparableRectangle类中给出compareTo方法的实现，比较两个矩形的面积大小

CompareObject类：

package exer5;
 
public interface CompareObject {
 // 若返回值是 0 , 代表相等; 若为正数，代表当前对象大；负数代表当前对象小
 public int compareTo(Object o);
}

Circle类：

package exer5;                                 
                                                
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;                  
 }                                          
}                                              
                                               

ComparableCircle类：

package exer5;
 
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());
   // 正确的：
   if (this.getRadius() > c.getRadius()) {
    return 1;
   } else if (this.getRadius() < c.getRadius()) {
    return -1;
   } else {
    return 0;
   }
  } else {
//   return 0;
   throw new RuntimeException("传入的数据类型不匹配");
  }
 }
 
}

ComparableCircleTest类：

package exer5;
  
public class ComparableCircleTest {
 public static void main(String[] args) {
  ComparableCircle c1 = new ComparableCircle(3.1);
  ComparableCircle c2 = new ComparableCircle(3.7);
  
  int comparableValue = c1.compareTo(c2);
  if (comparableValue > 0) {
   System.out.println("c1大");
  } else if (comparableValue < 0) {
   System.out.println("c2大");
  } else {
   System.out.println("c1和c2一样大");
  }
  
 }
}

输出：

c2大