类中方法返回对象是否破坏封装原则？

Question

//大家好！类中方法返回对象是否破坏封装原则？先看以下代码：
//Map 中含有Point类对象，Map有一方法getPt（）返回Point对象
//file Point.java
public class Point
{
    private int x;
    private int y;
    
    public int getX()
    {
        return x;
    }
    public int getY()
    {
        return y;
    }    public void setX(int x)
    {
        this.x = x;
    }
    public void setY(int y)
    {
       this.y = y;
    }
}//file Map.java
public class Map
{
    private Point pt;
    
    public void setPt(Point pt)
    {
        this.pt = pt ;
    }
    public Point getPt()
   {
        return pt;
   }}//file TestMap.java
public class TestMap
{
     public static void main(String [] arg)
     {
          Map    mp = new Map();
          Point  pta = new Point();
          pta.setX(5);
          pta.setY(10);
          mp.setPt(pta);          
          System.out.println("before chage map's point is:");
          System.out.println(mp.getPt().getX() + "," + mp.getPt().getY());
          
          Point ptb = mp.getPt();
          ptb.setX(1);//此处直接用返回的对象引用改变类Map中的Point；
          ptb.setY(1);
          System.out.println("after chage map's point is:");
          System.out.println(mp.getPt().getX() + "," + mp.getPt().getY());
//Map 里的private point变为（1，1），但我是没有通过Map的setPt方法改的，
//而是通过返回的类成员直接改变，这样java是否违背类私有成员要由类方法来改变
//这一封装原则？？ 还是这原则要由程序员注意保护？     }
}

Answer 1

不算。setX不就是类方法么？只不过不是Map的而已。其实这个问题涉及的是另一个问题。就是方法参数的问题，方法参数原则上应该是简单的。也就是类似基本类型或者String这样的基础类的
，但是在初始化时，太多的简单参数又会造成另一种程度封装不足。所以现在在构造对象的时候经常会用一些bean对象来快速填充。但是在取数据时，应该尽量返回简单的类型。比如Map类，可以考虑增加函数getPtX和getPtY来代替getPt。

Answer 2

但是在java api中有很多类的method是返回对象的，如public PrintStream append(char c)，
 File getCanonicalFile() 等等；而且我觉得java是面向对象的，复杂类型也是同等的，而且我觉得简单类型还破坏了java的面向对象的原则，因为一切类型都应该是某种类，和类的对象。
所以java有Integer ，Float等类。

Answer 3

这是因为你一个类不可能把问题都解决掉。所谓取舍平衡。比如你现在要做一个程序，别人可能用你这个程序来来计算。
那么你的这个程序中与外部交互的类是不是返回的值尽量简单为好呢？除非，你返回的东西很多很复杂。可是你又为什么一下要返回那么复杂的东西呢，分开多个方法，一个返回一类数据不好么？
你比如File getCanonicalFile()返回一个file，那时因为File实际已经是一个很简单的概念了。但是比如说FileAndDate getCanonicalFileAndDate() ，然后通过FileAndDate.getFile再来获取File。那就是不好的设计了。

Answer 4

我现在觉得，若你决定在类的方法中返回一个对象，你就允许了在类外通过这对象本身修改自己的数据。所以一些只能用类的方法修改的私有对象属性，不要在方法里把他返回。若一定要这样，可以先new一个对象，然后clone，再返回。

Answer 5

这样的确违反了封装原则。但是，用公开的set,get方法来影响私有属性也有一定的意义。就是在继承中，子类可以用继承下来的set,get方法来影响父类中的私有属性。父类就能保持相对的独立性，而子类引用set,get获得属性可以明显的让程序员知道，这些属性并不是子类负责处理的。
    返回clone也是可以的.但是，我认为，既然父类申明为私有的属性，就应当依靠父类的方法处理、加工、引用这个私有属性。而他的子类并不应当直接来处理这个父类的私有属性。从这个意义上讲，返回的对象并不是一个clone也不是非常严重的问题。
    如果父类和子类都需要共同处理同一个属性，那么可以考虑protected了。

Answer 6

class TableManager {
private $tableName,$fields,$conn;

public function __construct($con){
$this->fields = array();
$this->conn=$con;
}
public function __destruct(){

}
public function getConn(){
return $this->conn;
}
public function getTableName(){
return ($this->tableName);
}
public function setTableName($value){
$this->tableName=$value;
}
public function getFields(){
return ($this->fields);
}
public function setFields($value){
$this->fields=$value;
}
//添加新的数据库记录
public function saveNew()
{
//一个空的纪录集合 
$rs=$this->conn->Execute("SELECT * FROM ".$this->tableName);
$insertSQL = $this->conn->GetInsertSQL($rs, $this->fields);
$this->conn->Execute($insertSQL); 
}
//修改数据库记录
public function update($fieldName,$fieldValue)
{
$rs=$this->conn->Execute("SELECT * FROM ".$this->tableName." where ".$fieldName."=".$fieldValue);
$updateSQL = $this->conn->GetUpdateSQL($rs, $this->fields);
$this->conn->Execute($updateSQL); # 更新资料库中的记录
}
public function updateRecords($sqlWhere){
$rs=$this->conn->Execute("SELECT * FROM ".$this->tableName." where ".$sqlWhere);
$updateSQL = $this->conn->GetUpdateSQL($rs, $this->fields);
$this->conn->Execute($updateSQL); # 更新资料库中的记录
}
public function delete(){}
} class PicTableManager extends TableManager {
private $uploadFiles;//数组，保存图片路径字段.
//数组结构:$uploadFiles["uploadFieldName"]=uploadFileObj;
public function __construct($con){
parent::__construct($con);
$this->uploadFiles=array();
}
public function __destruct(){}
public function setUploadFiles($uploadFilesV){
$this->uploadFiles=$uploadFilesV;
}
public function getUploadFilesV(){
return $this->uploadFilesV;
}
//上传图片方法
private  function uploadFiles()
{
foreach ($this->uploadFiles as $uploadObj) {
$uploadObj->uploadFile();
}
}
//删除上传的图片,修改过的图片
public function delUploadedFile($fieldName,$fieldValue)
{
$conn=$this->getConn();
$sqlString="SELECT * FROM ".$this->getTableName()."where ".$fieldName."=".$fieldValue;
$rs=$conn->Execute($sqlString);
foreach ($this->uploadFiles as $uploadFieldName=>$uploadFileObj) {
if (file_exists($rs[$uploadFieldName])) {
     unlink($rs[$uploadFieldName]);//删除文件
}
}
}
//覆写保存新纪录的方法
public function saveNew()
{
$this->uploadFiles();
$tempFields=$this->getFields();
//
foreach ($this->uploadFiles as $uploadFieldName=>$uploadFileObj){
if (!$uploadFileObj->uploadFile()) {
$tempFields[$uploadFieldName]=$uploadFileObj["name"];
}
}
$this->setFields($tempFields);
parent::saveNew();
}
//覆写修改纪录的方法
public function update($fieldName,$fieldValue)
{
$this->delUploadedFile($fieldName,$fieldValue);//删除对应纪录的有关修改过的老图片
$this->uploadFiles();
foreach ($this->uploadFiles as $uploadFileTableName=>$uploadFileObj){
if (!$uploadFileObj["error"]) {
$tempFields[$uploadFileTableName]=$uploadFileObj["name"];
}
}
$this->setFields($tempFields);
parent::update($fieldName,$fieldValue);
}
public function delete()
{}
    }

Answer 7

以上是用php写的两个类。其实和java是一样的。最近喜欢上了php5。
一个是基本的table管理类，里面简单的saveNew方法为保存一个新的纪录。后面是一个带图片上传的table管理子类。
父类的saveNew方法主要处理fields私有属性，类型是数组。而子类的saveNew方法在处理完上传图片后，合成一个新的fields数组，这时候子类的用setFields(fields)数组影响父类的fields数组，然后子类的saveNew方法直接引用父类的saveNew方法就可以了。至于怎么处理fields数组，怎么插入数据库数据，子类根本不用知道。