Java编程算法基础--面向对象的设计原则

 面向对象的设计很重要，主要是处理类间的职责划分和理顺类间的依赖关系。

其设计原则很多，这节列举两条：

1 类间松耦合原则：类间的依赖关系尽量少，并且尽可能弱化。

2 开闭原则：好的设计应当向修改关闭，向扩展开放。

 

类间最强依赖关系:继承

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

假若父类中的内容修改,则继承它的子类也会受到影响  -------> 继承:是一种重型的关系

组合和聚合,则是相对较轻型的关系

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

关闭原则: 对修改关闭,对扩展开放,可以增加类来增加功能,不需要修改已有的类

 

随着经验的增加,对面向对象的设计的掌握会更容易

package NO3;
//面向对象的设计原则
// 1.   A   -> B  消除A,B的直接依赖关系
//情况 1
/*class B{
	
	
}
class A{
	private B x;
	public A(){
	
		x = new B();
	}
	
}*/
//上述这种情况是 A类依赖于B类, A,B之间的关系是 A类包含B类,是属于组合关系
//情况2
/*class B implements IB{
	
}
interface IB{//接口中抽象出B类应该有的性质
	
	
}
class A implements IB{
	
	private IB x;
	public A(){
		
	  x = new B(); //此处用到了Java中的泛化	
	}	
}*/
//情况3
/*class B implements IB{

}
interface IB{//接口中抽象出B类应该有的性质
	
	
}
class A implements IB{
	
	private IB x;
	public A(IB x){
		
	  this.x = x;
	}	
}*/

public class Test05 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
        new A(new B());//此处涉及到了泛化	
	}

}

 

package NO3;


//2.   A不要继承B,但要重用B的功能
//实现-:
/*class B {
	public void f(){}
	public int g(){
		return 1000;
	}
	
	
}
class A {                    //创建代理 (代理模式)
	private B prox = new B();//在A中创建B类的代理,A类无需继承B,就可以使用B类的方法
	public void f(){         //类比:比如我本人是不会下象棋的,我可以绑架一位象棋大师
		prox.f();            //当别人问我招法时,我可以问象棋大师
	}
	public int g(){
	  return prox.g();
	}
	
}*/
//实现二:A 可以冒充 B 去完成IB接口出现的那个任务
/*
interface IB(){ //接口中只有方法的签名,无具体的实现
  
    void f();
    int g();
} 
class B  Implements IB{
  public void f(){}
  public int g(){
	return 1000;
}
}
class A  Implements IB{
private B prox = new B();//在A中创建B类的代理
public void f(){
	prox.f();
  }
public int g(){
  return prox.g();
  }

}*/

public class Test06 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

在实际开发,应该多使用代理模式,来替代继承